Linux + iPhone Continuity / iMessage / SMS
experiment: bluetooth + imessage (#9)
Zack Bartelc7cc76545be6
diff --git a/CMakeLists.txt b/CMakeLists.txtindex fa2b3f2..f0c74f0 100644--- a/CMakeLists.txt+++ b/CMakeLists.txt@@ -1,5 +1,5 @@cmake_minimum_required(VERSION 3.19)-project(tether VERSION 0.1.5 LANGUAGES CXX C)+project(tether VERSION 0.1.7 LANGUAGES CXX C)set(CMAKE_CXX_STANDARD 20)set(CMAKE_CXX_STANDARD_REQUIRED ON)@@ -36,7 +36,8 @@ include(FetchContent)FetchContent_Declare(jsonGIT_REPOSITORY https://github.com/nlohmann/json.git- GIT_TAG v3.11.3+ GIT_TAG v3.12.0+ GIT_SHALLOW ON)set(JSON_Install OFF CACHE BOOL "" FORCE)FetchContent_MakeAvailable(json)@@ -44,7 +45,8 @@ FetchContent_MakeAvailable(json)FetchContent_Declare(googletestGIT_REPOSITORY https://github.com/google/googletest.git- GIT_TAG release-1.12.1+ GIT_TAG v1.17.0+ GIT_SHALLOW ON)set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)set(INSTALL_GTEST OFF CACHE BOOL "" FORCE)@@ -125,6 +127,11 @@ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/man/tether.1" "${CMAKE_CURRENT_BINARYinstall(FILES "${CMAKE_CURRENT_BINARY_DIR}/man/tetherd.8"DESTINATION ${CMAKE_INSTALL_MANDIR}/man8)+# Bluetooth CoD unit. Installed but not enabled: it changes how the machine presents itself over Bluetooth, so turning it on is the user's call.+set(SYSTEMD_UNIT_DIR "${CMAKE_INSTALL_LIBDIR}/systemd/system" CACHE PATH "systemd system unit directory")+install(FILES packaging/systemd/[email protected]+ DESTINATION "${SYSTEMD_UNIT_DIR}")+# Extension Building only if npm is availableoption(TETHER_BUILD_EXTENSIONS "Build browser and mail extensions automatically" ON)@@ -168,12 +175,12 @@ set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")# DEBset(CPACK_DEBIAN_PACKAGE_MAINTAINER "[email protected]")-set(CPACK_DEBIAN_PACKAGE_DEPENDS "libgtk-3-0, libnotify4, openssl, libwayland-client0, libavahi-client3")+set(CPACK_DEBIAN_PACKAGE_DEPENDS "libgtk-3-0, libnotify4, openssl, libwayland-client0, libavahi-client3, libglib2.0-0, bluez, bluez-obexd")set(CPACK_DEBIAN_PACKAGE_SECTION "utils")set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "https://github.com/zackb/tether")# RPM-set(CPACK_RPM_PACKAGE_REQUIRES "gtk3, libnotify, openssl, wayland-client, avahi-client")+set(CPACK_RPM_PACKAGE_REQUIRES "gtk3, libnotify, openssl, wayland-client, avahi-client, glib2, bluez, bluez-obexd")set(CPACK_RPM_PACKAGE_LICENSE "MIT")set(CPACK_RPM_PACKAGE_RELOCATABLE FALSE)diff --git a/PKGBUILD b/PKGBUILDindex 9f07a92..f83863c 100644--- a/PKGBUILD+++ b/PKGBUILD@@ -1,11 +1,11 @@pkgname=tether-gitpkgver=r1.1234pkgrel=1-pkgdesc="A Wayland-native local file transfer and clipboard sync tool over mDNS"+pkgdesc="Bridge an iPhone to the Linux desktop: clipboard, files, messages, and notifications"arch=('x86_64')url="https://github.com/zackb/tether"license=('MIT')-depends=('gtk3' 'libnotify' 'openssl' 'wayland' 'avahi')+depends=('gtk3' 'libnotify' 'openssl' 'wayland' 'avahi' 'glib2' 'bluez' 'bluez-utils' 'bluez-obex')makedepends=('cmake' 'ninja' 'git')provides=('tether' 'tether-bin')conflicts=('tether' 'tether-bin')diff --git a/README.md b/README.mdindex e5e0a3a..5137379 100644--- a/README.md+++ b/README.md@@ -27,6 +27,8 @@| **iOS App** | ✅ Stable || **Browser Extension** | ✅ Stable || **Mail Extension** | ✅ Stable |+| **Messages (SMS/iMessage)** | 🧪 Beta |+| **Notification Mirroring** | 🧪 Beta Bluetooth || **TOTP/OTP Vault** | 🗓️ Planning |### Clipboard Sync@@ -35,6 +37,12 @@ Seamlessly share your Wayland compositor (`wlr-data-control`) clipboard over the### File TransferDrag and drop files from Linux directly into the iPhone app, or receive files automatically deposited to your `$XDG_DOWNLOAD_DIR`.+### Messages and Notifications++Read and reply to SMS and iMessage conversations, and see notifications from any app on the phone, on the Linux desktop.++iOS permits no app to touch messages or other apps' notifications. A Bluetooth accessory can, however, receive messages and notifications from the phone.+### Device PairingSecurely pair devices using **Mutually Authenticated TLS (mTLS)**, restricting TCP traffic securely using X.509 RSA certificates.@@ -60,7 +68,7 @@ Tether uses a multi-component architecture:2. **`tether` (CLI)** — A lightweight C++ CLI program to communicate with the daemon. This also allows the WebExtension to interface with the daemon via native messaging.-3. **`tether-gtk` (GTK App)** — A native GTK4 application for Linux that provides a graphical interface to manage devices, send files, trigger clipboard sync, and monitor connection status.+3. **`tether-gtk` (GTK App)** — A native GTK3 application for Linux that provides a graphical interface to manage devices, send files, trigger clipboard sync, read and reply to iPhone messages, see mirrored notifications, and monitor connection status.4. **iPhone App** — Native SwiftUI iOS 16+ app that discovers the daemon via Bonjour/mDNS, utilizing Apple's `Network.framework` for secure TLS negotiation.@@ -78,9 +86,16 @@ Tether uses a multi-component architecture:- `openssl`- `pkg-config`- `ninja`-- `gtk4` (for `tether-gtk`)+- `gtk3` (for `tether-gtk`)- `nlohmann-json`- `glib2`+- `avahi`+- `bluez`, `bluez-utils`, and `bluez-obex` (for messages and notifications)++### Bluetooth (for Messages and Notifications)+- BlueZ 5.86+ running with experimental bearer API, for notification mirroring.+- A controller with BR/EDR, LE, and advertising support.+- Notification mirroring does not work on iOS 18 and earlier.### iOS- iOS 16+@@ -137,12 +152,16 @@ The daemon uses an advisory lock (`$XDG_RUNTIME_DIR/tether/tetherd.lock`) ensuri5. **Start syncing** clipboard and transferring files+6. **For messages and notifications**, (TODO: Bluetooth pairing instructions)+## Roadmap- [x] Complete iOS app development- [x] Add end-to-end encryption for file transfers- [x] Release browser extension for Firefox- [x] Release mail extension for Thunderbird+- [x] Read and reply to iPhone messages over Bluetooth+- [x] Mirror iPhone notifications over Bluetooth- [ ] Implement TOTP/OTP vault with Safari autofill- [ ] Explore macOS supportdiff --git a/docs/BLUETOOTH.md b/docs/BLUETOOTH.mdnew file mode 100644index 0000000..79d98a7--- /dev/null+++ b/docs/BLUETOOTH.md@@ -0,0 +1,328 @@+# Bluetooth: iPhone messages and notifications++Tether accesses SMS/iMessage and other apps' notifications via Bluetooth because iOS apps are+not allowed to access these. It presents the Linux machine to iOS as a paired+Bluetooth accessory. No iOS-side code is involved.++| Feature | Mechanism | Transport | Linux role |+|---|---|---|---|+| SMS / iMessage, read + send | **MAP** (Message Access Profile) via BlueZ `obexd` | BR/EDR | OBEX client |+| Contacts, for sender names | **PBAP** (Phonebook Access Profile) via `obexd` | BR/EDR | OBEX client |+| Notifications from any app | **ANCS** (Apple Notification Center Service) | BLE / GATT | GATT central |++The Tether iOS app is unrelated to these features and just keeps handling clipboard sync and file transfer over TCP + mTLS.++## Delivery modes++Not every machine can do all of it, so Tether resolves one of two modes from live capabilities.++- Full mode: MAP + PBAP + ANCS. Requires BR/EDR, LE, and advertising support, plus+ BlueZ >= 5.86 running with its experimental bearer API (org.bluez.Bearer.LE1).+- Compatibility mode: MAP + PBAP only. Messages and contacts work, notification mirroring does not (older BlueZ).++Run the probe to find out which applies:++```bash+./scripts/bt-probe.sh # read-only+./scripts/bt-probe.sh --set-class # also fixes the adapter Class of Device+```++## Setup requirements++Class of Device must be A/V Hands-Free (major 4, minor 8). iOS only offers the+"Show Message Notifications" and "Sync Contacts" permissions to a device presenting this+class. `sudo btmgmt class 4 8` sets it for now.++**It does not survive a `bluetoothd` restart**. bluetoothd rewrites the+class from its own default every time it starts. Already-granted session survives that, but a phone that has not yet granted the permissions will refuse MAP and PBAP with an OBEX error that seems like a missing service record rather than+like a permissions problem.+The packaged unit handles that:++```bash+sudo systemctl enable --now tether-btclass@hci0+```++`PartOf=bluetooth.service` re-runs it on every `bluetooth.service` restart. It writes the+class, reads it back, and retries for ten seconds.++**BlueZ needs the experimental bearer API** for ANCS. On Arch:++```bash+sudo mkdir -p /etc/systemd/system/bluetooth.service.d+printf '[Service]\nExecStart=\nExecStart=/usr/lib/bluetooth/bluetoothd --experimental\n' \+ | sudo tee /etc/systemd/system/bluetooth.service.d/experimental.conf+sudo systemctl daemon-reload && sudo systemctl restart bluetooth+```++The executable lives at `/usr/libexec/bluetooth/bluetoothd` on Debian based.++**`obexd` must be running** (user service `obex`) for MAP and PBAP. It is socket-activated under normal use.++## Permissions on the phone++After pairing, the iPhone offers "Show Message Notifications" and "Sync Contacts" under+Settings -> Bluetooth -> (i) for the computer's entry. Off by default.++- The toggles can take minutes to appear after paring, and appear only while the ANCS+ advertisement is actively broadcasting. Failed MAP connection attempts alone do not surface them.+- Closing and reopening the entry's detail page refreshes what iOS shows.+- A failed pairing can leave two records for the same computer, the toggles may appear+ under either one. Check both, and delete both before retrying a clean pairing.++Without the relevant permission, MAP or PBAP is visible at the SDP level but rejects the+OBEX connection with `Forbidden` / `0x43`. That is a permissions state, not a pairing+failure (do not re-pair). A transport-level `Connection refused (111)` is different and+usually means another computer already owns the iPhone's single MAP session.++## Conflicts++The iPhone serves one MAP session at a time. Any other program on any machine holding it will block Tether.++## Known limits++These are properties of what iOS exposes:++- MAP reports both SMS and iMessage as `Type: sms-gsm`. The transport a message used is not knowable.+- The iPhone's MAP sent folder is empty and sending produces no useful outgoing event, so sent history cannot be recovered from the phone. Tether records its own sends.+- ANCS supports positive/negative notification actions only. There is no free-text reply over ANCS, replies go through MAP.+- No attachments, reactions, typing indicators, or read receipts.+- MAP gives no conversation identifier and no participant list for group messages, so group support is a guess and is conservative by default.++## Troubleshooting++Start with the two read-only checks. `./scripts/bt-probe.sh` says what the hardware and the+stack can do. `tether --bt-connection` says what is actually up right now.++| Symptom | Cause | What to do |+|---|---|---|+| Messages and contacts worked, then stopped, and the error mentions a service record | `bluetoothd` restarted and reset the Class of Device | `sudo systemctl enable --now tether-btclass@hci0`, then re-pair if the phone dropped the bond |+| The phone never offers notifications / Sync Contacts | The class is wrong, or the ANCS advertisement is not running | Check for `class=ok` in `tether --bt-status`, can take minutes |+| MAP or PBAP reports `forbidden` | The matching toggle on the phone is off | Turn it on. This is not a pairing failure |+| MAP reports `busy`, or the transport says `Connection refused (111)` | Another computer holds the iPhone's single MAP session | Stop the other client |+| Pairing fails with `br-connection-key-missing` | A stale bond on one side, or the adapter is not `Pairable` | Delete the computer's entry on the phone (Forget This Device) and `tether --bt-unpair <addr>` locally, then pair again |+| The phone shows two entries for this computer | A failed pairing left both a Classic and an LE record | Delete both on the phone before retrying |+| LE never connects and the log repeats `org.bluez.Error.InProgress` | BlueZ is holding a connect operation that never completed | `sudo systemctl restart bluetooth`. Disconnecting the device does not clear it. With `tether-btclass@hci0` enabled the class survives the restart |+| Everything connects but `ancs_ready` stays false | Compatibility mode, or iOS has not authorized notification content yet | Check `Mode:` in `tether --bt-status`. In full mode the daemon retries, the first request returns `NotPermitted` until the prompt on the phone is approved |+| A group conversation cannot be replied to | Working as designed until the route is unambiguous | The thread's `reply_reason` says which condition failed |++### Reporting a problem++```bash+tether --bt-diagnostics+```++Prints the delivery mode, auth strategy, Bluetooth settings, current connection state, and timeline of recent link and pairing transitions.++It is redacted for pasting into an issue. Bluetooth addresses, phone numbers, email+addresses, and home and runtime directories become numbered placeholders.+Messages, contact names, and notification content are dropped, and message and notification events never enter the timeline at all. Read it before+you post it anyway.++## Recorded results++Per the maintenance rule below, every entry records phone model, iOS version, BlueZ+version, and controller, and distinguishes what was captured from what was inferred.++### 2026-07-11 — MediaTek MT7925, BlueZ 5.87, iPhone 15 Pro full mode++| | |+|---|---|+| Controller | MediaTek MT7925 (RZ717) Wi-Fi 7 |+| Kernel | 7.1.8-arch1-3 (Arch Linux) |+| BlueZ | 5.87, running with `-E` |+| Adapter roles | central + peripheral; 15 advertising instances |+| Adapter class | `0x7c0408` — A/V Hands-Free |+| Phone | iPhone 15 Pro, iOS _(version not recorded - fill in)_ |++Captured observations against the bonded phone:++- Dual bond confirmed. `Device1` reports `Paired`, `Bonded`, `Connected`, and `Trusted` all true, and `org.bluez.Bearer.LE1` independently reports `Paired`, `Bonded`, and `Connected` all true. One bond covers BR/EDR and LE.+- ANCS is live. Service `7905f431-b5ce-4e99-a40f-4b1e122d00d0` is in the GATT tree along with all three characteristics: Notification Source+ `9fbf120d-6301-42d9-8c58-25e699a21dbd`, Control Point+ `69d1d8f3-45e1-49a8-9821-9bbdfdaad9d9`, and Data Source+ `22eac6e9-24d6-4bb5-be44-b36ace7c7bfb`.+- MAP and PBAP are advertised in the device's profile UUID list: `0x1132` (Message Access Server), `0x1133` (Message Notification Server), and `0x112f` (Phonebook Access Server).+- Apple Media Service `89d3502b-0f36-433a-8ef4-c502ad55f8dc` is also present.++### 2026-07-13 — MAP/PBAP refused while ANCS worked++Captured with the bond fully connected (`Connected` and `ServicesResolved` true, `Bearer.LE1` connected) and the phone unlocked and attended:++- Opening either OBEX session failed with `org.bluez.obex.Error.Failed: Unable to find service record`.+- The same call made by hand with `busctl --user call org.bluez.obex ... CreateSession` failed identically, so this is obexd's SDP lookup, not a Tether problem.+- `bluetoothd` logged the layer underneath:+ `record_cb() Unable to get Hands-Free unit SDP record: Connection refused`+ and `connect to <phone>: Connection refused (111)`. obexd reports a missing+ record whenever its SDP fetch is refused, so "Unable to find service record"+ can be a refusal with a misleading name.+- A full `Disconnect()` / `Connect()` cycle forced fresh SDP discovery. BlueZ+ still reported `0x1132`, `0x1133`, and `0x112f` afterwards, so those UUIDs were+ not stale, yet obexd still could not fetch the records. BlueZ's device+ discovery and obexd's record fetch can disagree even on fresh data.+- ANCS worked throughout. The LE/GATT half of the bond is healthy while the BR/EDR profile half is refused, independent.++Resolved on 2026-07-13. The cause was neither candidate listed at the time:+the adapter's Class of Device had reverted to Computer/Laptop, so iOS+no longer treated the machine as an eligible accessory and refused the record+fetch.++Also worth knowing: a `Connect()` that times out leaves an attempt in flight, and+further attempts fail fast with `br-connection-busy`. Retrying through that state+prolongs it, which is why the bearer supervisor backs off exponentially+instead of retrying on a fixed interval.++### 2026-07-16 - Cause of the OBEX refusal++Same hardware as above. The phone was made to forget this computer and its Bluetooth+stack was reset, which cleared the condition and allowed a clean re-pair through+Tether's own `bt_pair` for the first time.++Class of Device is the cause of the refused record fetch. `btmgmt class 4 8` does+not persist across a `bluetoothd` restart! The adapter reverts to Computer/Laptop+(`0x...010c`). iOS declines to serve MAP and PBAP SDP records and the+refusal is a `Connection refused (111)` under obexd's misleading "Unable to find+service record". Restoring the class and re-pairing opened PBAP immediately. This makes+the CoD a runtime dependency, not a one-time setup step. Anything that restarts+`bluetoothd` silently breaks messages and contacts until it is set again.++The adapter must be `Pairable` for connect-first to work. Idles with `Pairable: no`.+Because connect-first deliberately makes the iPhone the authentication initiator, BlueZ then refuses the inbound pairing request: the Linux side+displays its numeric comparison, iPhone never shows one at all, and fails with `br-connection-key-missing`.+Tether now turns `Pairable` and `Discoverable` on for the duration of the transaction and restores both afterwards.++A stale record on the phone reproduces `br-connection-key-missing` indefinitely. A+failed authentication can leave iOS holding a record for the computer while Linux has+none. The bond must be removed on both sides (Forget This Device and `bluetoothctl remove`) before retrying.+iOS shows no prompt in this state, which is what distinguishes it from a user-cancelled pairing.++Results of the successful transaction:++- Discovery -> `Device1.Connect()` on the unpaired device -> numeric check on both screens -> `Paired`,+then the ANCS solicitation.+- `Device1` and `org.bluez.Bearer.LE1` both report `Paired` and `Bonded`, and+ `BREDR.Connected` and `LE.Connected` are both true. Connect-first produced the+ cross-transport bond on this controller, upgrading the previous line's inference to a capture.+- PBAP opened on the first attempt. MAP reported `Forbidden`, which is a permission+ rather than the transport refusal above, and exactly the distinction `classify_obex_error()` exists to make.+ Granting "Show Message Notifications" cleared it within one poll, with no re-pair and no session restart.+- Messages then listed from `telecom/msg/inbox` and threaded correctly.++Obexd API details, both on BlueZ 5.87 and neither matching what the D-Bus documentation says (shocker):++- `ListMessages` returns `(a{oa{sv}})`: dict keyed by message object path,+ not the `(a(oa{sv}))` array of structs that the API reference says. GDBus rejects the reply on type mismatch(!!?!)+- `MessageAccess1.SetFolder` walks from the session root. `"inbox"`+ alone fails with `Internal Server Error`. `"telecom/msg/inbox"` succeeds, as does+ `"/telecom/msg/inbox"` and a `"telecom"` step. `ListMessages` takes a folder arg relative to the current folder, so an empty string lists the folder+ `SetFolder` already selected.++Message listing fields as actually delivered: `Subject` (body),+`Timestamp` (ISO-8601) local time with no zone suffix (`20254816T509517`),+`Sender`, `SenderAddress`, `Recipient`, `RecipientAddress`, `Type` (`sms-gsm` for both SMS and iMessage),+`Read`, `Sent`, `Folder`, `Size`, and `ConversationId`.+`ConversationId` present but zero on every message, confirming IT CANNOT BE a thread identifier(?!?).++`SenderAddress` is in whatever form the phone has (both bare national number (`5129328901`) and (`+15129328901`) in the same inbox (!?!).+Tether does not invent a country code, so the same person can appear as two threads if their number is in the phone both ways.++A message's D-Bus object path is not a stable identifier. obexd names messages+`/org/bluez/obex/client/session<N>/message<id>`, and `<N>` is the OBEX session number,+which increments on every reconnect. Same message observed as `session9/message…` and `session11/message…` across a restart.+Only the trailing `<id>` is stable, so it is what Tether dedupes and persists on.+The full path is kept separately and refreshed on each re-listing, because it is what `Message1` calls must+address. Keying history on the path instead duplicates the entire mailbox on every reconnect.++### Sending++`MessageAccess1.PushMessage(sourcefile, folder, args)` takes a file, so the+bMessage is staged in `$XDG_RUNTIME_DIR` mode 0600 and removed afterwards (`Charset` must be `utf8`,+let obexd transcode to the native charset mangles anything outside the phone's default encoding.)++Success means the phone accepted the message, not that it delivered it. MAP reports+nothing back about delivery. Tether records its own sends locally, and that record is the+only evidence they happened. A push that times out is reported.++`TYPE` is always `SMS_GSM`, including for AppleID recipients: iOS decides between SMS+and iMessage on its own, and nothing on the Linux side can force or check that choice.++### ANCS++On the same hardware: after the LE bearer connects, BlueZ enumerates the ANCS+service and all three characteristics: Notification Source, Control Point and Data Source, under the device object, and `StartNotify` succeeds on both notifying+characteristics.++The permission is in Settings -> Bluetooth -> (i) -> Share System Notifications, and it is separate from the Message Notifications toggle that MAP needs.++Control Point responses have no request identifier, so only one request may be out at a time. And Data Source+responses carry no total length (?!?) and come back fragmented, so the only way to know+response has ended is to know exactly which attributes were requested. Those two facts+are why the sequencer exists.++### Group messages++Off by default, `group_messages_enabled` and+`ancs_content_enabled` in `~/.config/tether/bluetooth.json`, so group support cannot work without content mirroring.++MAP delivers a group message with one sender, no participant list and no conversation+identifier. The only other hint is to correlate Apple Messages ANCS notification:+its title is the sender, and its subtitle is either `To you & ...` for an unnamed group or+the group's name. Neither form contains a member list...++- Correlation is bounded to a 30-second window, and two notifications with the same+ text are refused instead of guessing, the wrong choice would put a message in the wrong conversation and send a reply at the wrong people.+- An unnamed group is repliable only when **every** participant name resolves to exactly one contact address. A name matching several contacts is refused.+- A named group stays read-only until we figure out the member list in `~/.config/tether/groups.json`.+ That list affects Tether's reply routing only and never modifies the group on the phone.+- iOS reports nothing when a member is added or removed, so an unknown sender is the only available signal that a member list has gone stale.+- Because iOS supplies a name but no conversation identifier, distinct named groups+ sharing a name collapse into one local thread. There is no way to tell them apart.++Repeated recipient vCards were observed to enter an existing iMessage group when the+recipient set matched, rather than fanning out into separate one-to-one threads. That is+an observation, not a guarantee.++### 2026-07-16: a reverted Class of Device does not revoke a granted session++Same hardware. `systemctl restart bluetooth` reverted the class from+`0x7c0408` to `0x7c010c` (Computer / Laptop), exactly as expected. MAP, PBAP, and ANCS+then reconnected and stayed up, with `tether --bt-status` reporting `class=wrong`+throughout.++So the class governs whether iOS offers and grants the Messages and Contacts permissions,+not whether it keeps honoring permissions it has already granted. The earlier refusal+recorded above happened while those grants were being established. Setting the class is+still required, just not continuously, which is why the breakage is delayed+and looks unrelated to the restart that caused it.++### 2026-07-16: LE bearer stuck on `InProgress`++Same hardware. After the daemon stopped and restarted twice within about twenty seconds while an LE bearer+connect was outstanding, every subsequent `Bearer.LE1.Connect` returned+`org.bluez.Error.InProgress` indefinitely. BR/EDR, MAP, and PBAP were unaffected and stayed up throughout, only ANCS was lost.++`bluetoothctl disconnect` on the device did not clear it, so the stuck state lives above+the ACL. `systemctl restart bluetooth` did clear it: LE connected and ANCS reported+`Notification mirroring is active` on the first attempt afterwards, with no other change.++The supervisor previously did its retry backoff on this error the same way it does on a+refusal. It now retries `InProgress` at the base interval and reserves the exponential growth for refusals,+which is what the phone actually sends when it declines. That does not fix the stuck state, but it stops the daemon from+sleeping through the recovery.++### PBAP++`Select("int", "pb")` followed by `PullAll` with `Format: vcard30` and `MaxCount` returned 456 contacts on the first attempt.++The transfer object disappears from D-Bus the moment it finishes, so a vanished object+is a normal terminal state rather than a failure (file may still take a bit to appear afterwards),+which is why the pull waits instead of giving up. Contacts are staged in `$XDG_RUNTIME_DIR` rather than `/tmp`, since a+phonebook is personal data, and the cache and journal are both written mode 0600.++***THIS HAS TO CHANGE BEFORE PUBLIC RELEASE.***++## Credits++[BlueFerry](https://github.com/erikwb/blueferry) (Erik Bourget and contributors), `PROTOCOL.md` records the findings this implementation relies on.+Tether's Bluetooth support is an independent implementation written against those published+findings, Apple's ANCS specification, the Bluetooth SIG MAP and PBAP specifications, and+the BlueZ D-Bus API.diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.mdindex 28b4851..33c9942 100644--- a/docs/PROTOCOL.md+++ b/docs/PROTOCOL.md@@ -212,3 +212,150 @@ Tether uses the local UNIX socket to coordinate OTP syncing between mail clients"otp": "123456"}```++---++## 6. Bluetooth: iPhone Messages and Notifications++These commands ride the same UNIX socket and the same newline-delimited JSON. They are+local-only: nothing here is reachable over TCP, because everything here is personal data.++Two transports sit behind them, and they fail independently: MAP and PBAP are OBEX+sessions over BR/EDR, while ANCS is a GATT client over BLE. See [BLUETOOTH.md](BLUETOOTH.md) for how they are set up.++Some commands answer on the requesting socket, and some broadcast to every local+subscriber. Anything a second client would want to see is broadcast.++### Adapter and pairing++#### `bt_status` (Client -> Daemon, answered directly)+Reports adapter capability and the resolved delivery mode.+**Payload**: `{"command": "bt_status"}`+**Response**: `available`, `capability` (`mode` is `full` or `compatibility`, plus+`bearer_api`, `powered`, `le_central`, `le_peripheral`, `advertising`, `class_ok`, and a+`reasons` array naming anything missing), and an `adapters` array.++#### `bt_list_devices` (Client -> Daemon, answered directly)+**Payload**: `{"command": "bt_list_devices"}`+**Response**: `{"command": "bt_devices", "devices": [...]}`, each entry carrying address,+name, `paired`, `bonded`, `connected`, `le_bearer`, and whether the device advertises+`map`, `pbap`, and `ancs`.++#### `bt_pair` / `bt_unpair` (Client -> Daemon, broadcast)+**Payload**: `{"command": "bt_pair", "address": "AA:BB:CC:DD:EE:FF"}`+Runs asynchronously and reports through `bt_pair_progress` events, then one+`bt_pair_result` (or `bt_unpair_result`). Only one pairing transaction runs at a time; a+second returns `{"status": "busy"}`. A successful pair selects the device and starts+supervision.++#### `bt_set_device` (Client -> Daemon)+**Payload**: `{"command": "bt_set_device", "address": "AA:BB:CC:DD:EE:FF"}`+Points supervision at an already-bonded phone.++#### `bt_pair_progress` / `bt_pair_result` (Daemon -> Clients)+`bt_pair_progress` carries `step` and `detail` for display during the transaction.+`bt_pair_result` carries `success`, `status`, `message`, and `dual_bond` — the last being+whether the bond covers LE as well as BR/EDR, which is what decides if ANCS is reachable.++### Connection state++#### `bt_connection` (Client -> Daemon, answered directly)+**Payload**: `{"command": "bt_connection"}`+Returns the same object the daemon broadcasts as `bt_connection_changed`.++#### `bt_connection_changed` (Daemon -> Clients)+Broadcast when the published state actually changes, not on a timer.++```json+{+ "command": "bt_connection_changed",+ "device_present": true,+ "device_paired": true,+ "classic_connected": true,+ "le_available": true,+ "le_connected": false,+ "map_open": true,+ "pbap_open": true,+ "map_error": "none",+ "pbap_error": "none",+ "ancs_ready": false,+ "link_reason": "Connected. Bringing up the LE link for notifications...",+ "profile_reason": "Messages and contacts are connected."+}+```++The two `*_reason` strings are written for display (permission is off or a transport that is busy).+`map_error` and `pbap_error` name the classification: `forbidden` means the toggle on the phone is off,+`busy` means another computer holds the phone's single MAP session.++### Messages++#### `bt_list_threads` (Client -> Daemon, answered directly)+**Payload**: `{"command": "bt_list_threads"}`+**Response**: `{"command": "bt_threads", "threads": [...]}`. Each thread carries `thread`+(the key), `name`, `address`, `preview`, `timestamp`, `unread`, `count`, `group`, and+`repliable`. Group threads add `reply_status` and, when they cannot be replied to, a+`reply_reason` written for display.++Thread keys are derived from the normalized peer address — `tel:+15035550101` for a phone+number, the lowercased address for an Apple ID — because MAP provides no conversation+identifier. Group keys are `group:name:<slug>` or `group:members:<slugs>`.++#### `bt_list_messages` (Client -> Daemon, answered directly)+**Payload**: `{"command": "bt_list_messages", "thread": "tel:+15035550101"}`+**Response**: `{"command": "bt_messages", "thread": ..., "messages": [...]}` with `handle`,+`body`, `timestamp`, `outgoing`, `read`, and `folder` per message.++#### `bt_mark_read` (Client -> Daemon, broadcast)+**Payload**: `{"command": "bt_mark_read", "handle": "...", "read": true}`+Writes through to the phone over OBEX, so it answers asynchronously with a+`bt_message_read` event carrying `success` and, on failure, `message`.++#### `bt_send_message` (Client -> Daemon, broadcast)+**Payload**: `{"command": "bt_send_message", "thread": "tel:+15035550101", "body": "on my way"}`+Builds a bMessage and pushes it to the phone's outbox. Answers asynchronously with+`bt_send_result` (`success`, and `message` when it failed).++Recipients are validated before they are interpolated into the bMessage: an address+containing CR, LF, or a vCard delimiter is rejected rather than escaped, because such an+address could otherwise add a recipient and deliver the message to someone else. Body lines+beginning with a bMessage structural token are byte-stuffed.++A successful send also broadcasts a `bt_message` event. That is the only record the send+happened — the iPhone's MAP sent folder stays empty and no outgoing notification arrives.++#### `bt_message` (Daemon -> Clients)+Broadcast once per newly observed message, incoming or locally sent.++### Notifications++#### `bt_list_notifications` (Client -> Daemon, answered directly)+**Payload**: `{"command": "bt_list_notifications"}`+**Response**: `{"command": "bt_notifications", "notifications": [...]}` with `uid`,+`app_id`, `app_name`, `title`, `subtitle`, `body`, `category`, `timestamp`, and which+actions the notification offers.++Bodies are present only when notification content mirroring is enabled; by default the+daemon requests the owning app and nothing more. Messages notifications+(`com.apple.MobileSMS`) are retained but never raise a desktop popup, since MAP already+delivers those with working read state.++#### `bt_notification_action` (Client -> Daemon, broadcast)+**Payload**: `{"command": "bt_notification_action", "uid": 42, "action": "positive"}`+ANCS offers positive and negative actions only — there is no free-text reply on a mirrored+notification. Answers with `bt_notification_action_result`.++### Diagnostics++#### `bt_diagnostics` (Client -> Daemon, answered directly)+**Payload**: `{"command": "bt_diagnostics"}`+Returns a report intended to be pasted into a bug report: version, auth strategy, the+Bluetooth settings in effect, the current capability and connection state, and an ordered+timeline of recent link and pairing transitions stamped in milliseconds.++The daemon redacts before answering. Bluetooth addresses, phone numbers, email addresses,+and home and runtime directories become numbered placeholders — `<address-1>` recurs for+one device, so a reader can still follow which device a line refers to without learning+which device it is. Message bodies, contact names, and notification content are dropped+outright rather than redacted, and message and notification events never enter the timeline+in the first place.diff --git a/docs/TODO.md b/docs/TODO.mdindex 257dd9b..2e59592 100644--- a/docs/TODO.md+++ b/docs/TODO.md@@ -1,9 +1,9 @@- [x] mDNS discovery-- [ ] PKGBUILD+- [x] PKGBUILD- [ ] TOTP vault-- [-] iPhone app- - [ ] iOS sharesheet thing-- [ ] WebExtension+- [x] iPhone app+ - [x] iOS sharesheet thing+- [x] WebExtension- [ ] TUI- [ ] layershell popups for- [x] device pairing requestdiff --git a/extension/build.sh b/extension/build.shindex f03dcf8..7676171 100755--- a/extension/build.sh+++ b/extension/build.sh@@ -9,6 +9,10 @@ BROWSER_DIR="$BUILD_DIR/browser"MAIL_DIR="$BUILD_DIR/mail"CHROME_DIR="$BUILD_DIR/chromium"+# esbuild comes from extension/node_modules; without it npx would fetch an+# unpinned copy off the network mid-build+[ -d extension/node_modules ] || npm --prefix extension ci+mkdir -p "$BROWSER_DIR/src/background" "$BROWSER_DIR/src/content"mkdir -p "$MAIL_DIR/src/mail"mkdir -p "$CHROME_DIR/src/background" "$CHROME_DIR/src/content"diff --git a/extension/manifest-browser.json b/extension/manifest-browser.jsonindex 85ce211..3e654f4 100644--- a/extension/manifest-browser.json+++ b/extension/manifest-browser.json@@ -1,13 +1,10 @@{"manifest_version": 3,"name": "Tether Browser Extension",- "version": "1.0.3",+ "version": "1.0.5","description": "Autofills OTPs on webpages using Tether daemon","permissions": [- "nativeMessaging",- "activeTab",- "scripting",- "storage"+ "nativeMessaging"],"host_permissions": ["<all_urls>"diff --git a/extension/manifest-mail.json b/extension/manifest-mail.jsonindex 120f536..4e42688 100644--- a/extension/manifest-mail.json+++ b/extension/manifest-mail.json@@ -1,19 +1,18 @@{"manifest_version": 2,"name": "Tether Mail Extension",- "version": "1.0.3",+ "version": "1.0.5","description": "Extracts OTPs from emails for Tether daemon","browser_specific_settings": {"gecko": {"id": "[email protected]",- "strict_min_version": "115.0"+ "strict_min_version": "137.0"}},"permissions": ["nativeMessaging","messagesRead",- "accountsRead",- "storage"+ "accountsRead"],"background": {"scripts": [diff --git a/extension/package-lock.json b/extension/package-lock.jsonindex 364ff1c..715249e 100644--- a/extension/package-lock.json+++ b/extension/package-lock.json@@ -8,29 +8,62 @@"name": "tether-extension","version": "1.0.0","devDependencies": {- "jsdom": "^25.0.0",- "mailparser": "^3.7.0",- "vitest": "^2.1.0"+ "esbuild": "^0.25.0",+ "jsdom": "^30.0.0",+ "mailparser": "^3.9.14",+ "vitest": "^4.0.0"}},"node_modules/@asamuzakjp/css-color": {- "version": "3.2.0",- "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-3.2.0.tgz",- "integrity": "sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==",+ "version": "6.0.5",+ "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-6.0.5.tgz",+ "integrity": "sha512-mbhpPMmnw/kwW19aRNmSUl1QzLbdGo1SCuE49BT98MNwqF6zaHb3o2owssFc/PEO/4t2UjqtCNwocuDtJornzA==","dev": true,"license": "MIT","dependencies": {- "@csstools/css-calc": "^2.1.3",- "@csstools/css-color-parser": "^3.0.9",- "@csstools/css-parser-algorithms": "^3.0.4",- "@csstools/css-tokenizer": "^3.0.3",- "lru-cache": "^10.4.3"+ "@csstools/css-calc": "^3.2.1",+ "@csstools/css-color-parser": "^4.1.9",+ "@csstools/css-parser-algorithms": "^4.0.0",+ "@csstools/css-tokenizer": "^4.0.0",+ "lru-cache": "^11.5.2"+ },+ "engines": {+ "node": "^22.13.0 || >=24.0.0"+ }+ },+ "node_modules/@asamuzakjp/dom-selector": {+ "version": "8.3.2",+ "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-8.3.2.tgz",+ "integrity": "sha512-93Z1N+BQNXysodoicpOIyNh2drHfz/CTf9nnT0FEx72GJcIiwgydD7tGAr78j41LsYn3hlRn+LdGPuBLn1Bl8Q==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "bidi-js": "^1.0.3",+ "css-tree": "^3.2.1",+ "is-potential-custom-element-name": "^1.0.1",+ "lru-cache": "^11.5.2"+ },+ "engines": {+ "node": "^22.13.0 || >=24.0.0"+ }+ },+ "node_modules/@bramus/specificity": {+ "version": "2.4.2",+ "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.2.tgz",+ "integrity": "sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "css-tree": "^3.0.0"+ },+ "bin": {+ "specificity": "bin/cli.js"}},"node_modules/@csstools/color-helpers": {- "version": "5.1.0",- "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.1.0.tgz",- "integrity": "sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==",+ "version": "6.1.0",+ "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.1.0.tgz",+ "integrity": "sha512-064IFJdjTfUqnjpCVpMOdbr8FLQBhinbZj6yRv2An2E41O/pLEXqfFRWqGq/SxlE5PEUYTlvWsG2r8MswAVvkg==","dev": true,"funding": [{@@ -44,13 +77,13 @@],"license": "MIT-0","engines": {- "node": ">=18"+ "node": ">=20.19.0"}},"node_modules/@csstools/css-calc": {- "version": "2.1.4",- "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-2.1.4.tgz",- "integrity": "sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==",+ "version": "3.3.0",+ "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.3.0.tgz",+ "integrity": "sha512-c5ihYsPkdG6JCkU2zTMm4+k6r7RXuGxtWYhu5DHMIiF1FHzrfmHL5so11AoFpUv/tu61xfcmT4AmKoFfMPoqdQ==","dev": true,"funding": [{@@ -64,17 +97,17 @@],"license": "MIT","engines": {- "node": ">=18"+ "node": ">=20.19.0"},"peerDependencies": {- "@csstools/css-parser-algorithms": "^3.0.5",- "@csstools/css-tokenizer": "^3.0.4"+ "@csstools/css-parser-algorithms": "^4.0.0",+ "@csstools/css-tokenizer": "^4.0.0"}},"node_modules/@csstools/css-color-parser": {- "version": "3.1.0",- "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-3.1.0.tgz",- "integrity": "sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==",+ "version": "4.1.10",+ "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.1.10.tgz",+ "integrity": "sha512-UZhQLIUyJaaMepqehrCODwCg2KW25vFvLWBmqYFaPclYvvxzj/sG8LBOhBFCp11i9uE7t1EyS+RAoV9tztPFyw==","dev": true,"funding": [{@@ -88,21 +121,21 @@],"license": "MIT","dependencies": {- "@csstools/color-helpers": "^5.1.0",- "@csstools/css-calc": "^2.1.4"+ "@csstools/color-helpers": "^6.1.0",+ "@csstools/css-calc": "^3.3.0"},"engines": {- "node": ">=18"+ "node": ">=20.19.0"},"peerDependencies": {- "@csstools/css-parser-algorithms": "^3.0.5",- "@csstools/css-tokenizer": "^3.0.4"+ "@csstools/css-parser-algorithms": "^4.0.0",+ "@csstools/css-tokenizer": "^4.0.0"}},"node_modules/@csstools/css-parser-algorithms": {- "version": "3.0.5",- "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.5.tgz",- "integrity": "sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==",+ "version": "4.0.0",+ "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.0.tgz",+ "integrity": "sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==","dev": true,"funding": [{@@ -116,16 +149,41 @@],"license": "MIT","engines": {- "node": ">=18"+ "node": ">=20.19.0"},"peerDependencies": {- "@csstools/css-tokenizer": "^3.0.4"+ "@csstools/css-tokenizer": "^4.0.0"+ }+ },+ "node_modules/@csstools/css-syntax-patches-for-csstree": {+ "version": "1.1.7",+ "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.7.tgz",+ "integrity": "sha512-fQ+05118eQS1cofO3aJpB5efgpBZMvIzwr/sbC8kDLVA5XLG8q1kJV5yzrUAI1f7lvhPnm8fgIjzFB8/O/5Dig==",+ "dev": true,+ "funding": [+ {+ "type": "github",+ "url": "https://github.com/sponsors/csstools"+ },+ {+ "type": "opencollective",+ "url": "https://opencollective.com/csstools"+ }+ ],+ "license": "MIT-0",+ "peerDependencies": {+ "css-tree": "^3.2.1"+ },+ "peerDependenciesMeta": {+ "css-tree": {+ "optional": true+ }}},"node_modules/@csstools/css-tokenizer": {- "version": "3.0.4",- "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-3.0.4.tgz",- "integrity": "sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==",+ "version": "4.0.0",+ "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-4.0.0.tgz",+ "integrity": "sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==","dev": true,"funding": [{@@ -139,13 +197,13 @@],"license": "MIT","engines": {- "node": ">=18"+ "node": ">=20.19.0"}},"node_modules/@esbuild/aix-ppc64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",- "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",+ "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==","cpu": ["ppc64"],@@ -156,13 +214,13 @@"aix"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/android-arm": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",- "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",+ "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==","cpu": ["arm"],@@ -173,13 +231,13 @@"android"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/android-arm64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",- "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",+ "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==","cpu": ["arm64"],@@ -190,13 +248,13 @@"android"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/android-x64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",- "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",+ "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==","cpu": ["x64"],@@ -207,13 +265,13 @@"android"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/darwin-arm64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",- "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",+ "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==","cpu": ["arm64"],@@ -224,13 +282,13 @@"darwin"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/darwin-x64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",- "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",+ "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==","cpu": ["x64"],@@ -241,13 +299,13 @@"darwin"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/freebsd-arm64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",- "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",+ "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==","cpu": ["arm64"],@@ -258,13 +316,13 @@"freebsd"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/freebsd-x64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",- "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",+ "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==","cpu": ["x64"],@@ -275,13 +333,13 @@"freebsd"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/linux-arm": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",- "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",+ "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==","cpu": ["arm"],@@ -292,13 +350,13 @@"linux"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/linux-arm64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",- "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",+ "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==","cpu": ["arm64"],@@ -309,13 +367,13 @@"linux"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/linux-ia32": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",- "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",+ "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==","cpu": ["ia32"],@@ -326,13 +384,13 @@"linux"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/linux-loong64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",- "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",+ "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==","cpu": ["loong64"],@@ -343,13 +401,13 @@"linux"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/linux-mips64el": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",- "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",+ "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==","cpu": ["mips64el"],@@ -360,13 +418,13 @@"linux"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/linux-ppc64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",- "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",+ "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==","cpu": ["ppc64"],@@ -377,13 +435,13 @@"linux"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/linux-riscv64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",- "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",+ "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==","cpu": ["riscv64"],@@ -394,13 +452,13 @@"linux"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/linux-s390x": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",- "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",+ "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==","cpu": ["s390x"],@@ -411,13 +469,13 @@"linux"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/linux-x64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",- "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",+ "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==","cpu": ["x64"],@@ -428,13 +486,30 @@"linux"],"engines": {- "node": ">=12"+ "node": ">=18"+ }+ },+ "node_modules/@esbuild/netbsd-arm64": {+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",+ "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "netbsd"+ ],+ "engines": {+ "node": ">=18"}},"node_modules/@esbuild/netbsd-x64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",- "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",+ "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==","cpu": ["x64"],@@ -445,13 +520,30 @@"netbsd"],"engines": {- "node": ">=12"+ "node": ">=18"+ }+ },+ "node_modules/@esbuild/openbsd-arm64": {+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",+ "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "openbsd"+ ],+ "engines": {+ "node": ">=18"}},"node_modules/@esbuild/openbsd-x64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",- "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",+ "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==","cpu": ["x64"],@@ -462,13 +554,30 @@"openbsd"],"engines": {- "node": ">=12"+ "node": ">=18"+ }+ },+ "node_modules/@esbuild/openharmony-arm64": {+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",+ "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "openharmony"+ ],+ "engines": {+ "node": ">=18"}},"node_modules/@esbuild/sunos-x64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",- "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",+ "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==","cpu": ["x64"],@@ -479,13 +588,13 @@"sunos"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/win32-arm64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",- "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",+ "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==","cpu": ["arm64"],@@ -496,13 +605,13 @@"win32"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/win32-ia32": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",- "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",+ "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==","cpu": ["ia32"],@@ -513,13 +622,13 @@"win32"],"engines": {- "node": ">=12"+ "node": ">=18"}},"node_modules/@esbuild/win32-x64": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",- "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",+ "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==","cpu": ["x64"],@@ -530,7 +639,25 @@"win32"],"engines": {- "node": ">=12"+ "node": ">=18"+ }+ },+ "node_modules/@exodus/bytes": {+ "version": "1.15.1",+ "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.15.1.tgz",+ "integrity": "sha512-S6mL0yNB/Abt9Ei4tq8gDhcczc4S3+vQ4ra7vxnAf+YHC02srtqxKKZghx2Dq6p0e66THKwR6r8N6P95wEty7Q==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": "^20.19.0 || ^22.12.0 || >=24.0.0"+ },+ "peerDependencies": {+ "@noble/hashes": "^1.8.0 || ^2.0.0"+ },+ "peerDependenciesMeta": {+ "@noble/hashes": {+ "optional": true+ }}},"node_modules/@jridgewell/sourcemap-codec": {@@ -540,24 +667,20 @@"dev": true,"license": "MIT"},- "node_modules/@rollup/rollup-android-arm-eabi": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.2.tgz",- "integrity": "sha512-dnlp69efPPg6Uaw2dVqzWRfAWRnYVb1XJ8CyyhIbZeaq4CA5/mLeZ1IEt9QqQxmbdvagjLIm2ZL8BxXv5lH4Yw==",- "cpu": [- "arm"- ],+ "node_modules/@oxc-project/types": {+ "version": "0.142.0",+ "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.142.0.tgz",+ "integrity": "sha512-7W+2q5AKQVU36fkaryontrHn3YDt1RyUYXatw9i5H8ocYe2sPKSFB6eS8WNPeRKiN1qAWWZUPm7gwFzJGrccqQ==","dev": true,"license": "MIT",- "optional": true,- "os": [- "android"- ]+ "funding": {+ "url": "https://github.com/sponsors/Boshen"+ }},- "node_modules/@rollup/rollup-android-arm64": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.2.tgz",- "integrity": "sha512-OqZTwDRDchGRHHm/hwLOL7uVPB9aUvI0am/eQuWMNyFHf5PSEQmyEeYYheA0EPPKUO/l0uigCp+iaTjoLjVoHg==",+ "node_modules/@rolldown/binding-android-arm64": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.2.2.tgz",+ "integrity": "sha512-l7x215OGvo1s52JWmR8U/DAVzEDWBCIbTm28aeJV/WDTSHgcKXaZTuBT0hJMs5NggilfJTW3clZVvd24yfKJxA==","cpu": ["arm64"],@@ -566,12 +689,15 @@"optional": true,"os": ["android"- ]+ ],+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-darwin-arm64": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.2.tgz",- "integrity": "sha512-UwRE7CGpvSVEQS8gUMBe1uADWjNnVgP3Iusyda1nSRwNDCsRjnGc7w6El6WLQsXmZTbLZx9cecegumcitNfpmA==",+ "node_modules/@rolldown/binding-darwin-arm64": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.2.2.tgz",+ "integrity": "sha512-9u9Xv6c1AJZT0FfwH5vrMG5Jjcwhc1MlyrPu0XfTqkzsmqfks2M6W/o5XwAJgVVN/jHpqqngC1WevHKKTIUtIA==","cpu": ["arm64"],@@ -580,12 +706,15 @@"optional": true,"os": ["darwin"- ]+ ],+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-darwin-x64": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.2.tgz",- "integrity": "sha512-gjEtURKLCC5VXm1I+2i1u9OhxFsKAQJKTVB8WvDAHF+oZlq0GTVFOlTlO1q3AlCTE/DF32c16ESvfgqR7343/g==",+ "node_modules/@rolldown/binding-darwin-x64": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.2.2.tgz",+ "integrity": "sha512-9W1mbGZAfW3oqd85bhBkmpyHCCzL1TeG/zFFP3vg7b0rlly8cxOcre5nXwz+LHazCwac2MNWgPdPCHndABjpWQ==","cpu": ["x64"],@@ -594,26 +723,15 @@"optional": true,"os": ["darwin"- ]- },- "node_modules/@rollup/rollup-freebsd-arm64": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.2.tgz",- "integrity": "sha512-Bcl6CYDeAgE70cqZaMojOi/eK63h5Me97ZqAQoh77VPjMysA/4ORQBRGo3rRy45x4MzVlU9uZxs8Uwy7ZaKnBw==",- "cpu": [- "arm64"],- "dev": true,- "license": "MIT",- "optional": true,- "os": [- "freebsd"- ]+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-freebsd-x64": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.2.tgz",- "integrity": "sha512-LU+TPda3mAE2QB0/Hp5VyeKJivpC6+tlOXd1VMoXV/YFMvk/MNk5iXeBfB4MQGRWyOYVJ01625vjkr0Az98OJQ==",+ "node_modules/@rolldown/binding-freebsd-x64": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.2.2.tgz",+ "integrity": "sha512-0p1lhiCSCyaerFwtrdZQUx7NqGk6LQnaRKWX7tFQqwQgvX0rjM15cIkm3pax1UpEakK14C4mOxx/jSqCBdBRqQ==","cpu": ["x64"],@@ -622,46 +740,32 @@"optional": true,"os": ["freebsd"- ]- },- "node_modules/@rollup/rollup-linux-arm-gnueabihf": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.2.tgz",- "integrity": "sha512-2QxQrM+KQ7DAW4o22j+XZ6RKdxjLD7BOWTP0Bv0tmjdyhXSsr2Ul1oJDQqh9Zf5qOwTuTc7Ek83mOFaKnodPjg==",- "cpu": [- "arm"- ],- "dev": true,- "libc": [- "glibc"],- "license": "MIT",- "optional": true,- "os": [- "linux"- ]+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-linux-arm-musleabihf": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.2.tgz",- "integrity": "sha512-TbziEu2DVsTEOPif2mKWkMeDMLoYjx95oESa9fkQQK7r/Orta0gnkcDpzwufEcAO2BLBsD7mZkXGFqEdMRRwfw==",+ "node_modules/@rolldown/binding-linux-arm-gnueabihf": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.2.2.tgz",+ "integrity": "sha512-e+cOJXrJ2L3zx6YzqPg+f6Wbk3V1cKB8bOhbaYdVYN3DdquzNdRAmrbETz1qnt5yp/c7JNlNjmITiA2cVneQ7w==","cpu": ["arm"],"dev": true,- "libc": [- "musl"- ],"license": "MIT","optional": true,"os": ["linux"- ]+ ],+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-linux-arm64-gnu": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.2.tgz",- "integrity": "sha512-bO/rVDiDUuM2YfuCUwZ1t1cP+/yqjqz+Xf2VtkdppefuOFS2OSeAfgafaHNkFn0t02hEyXngZkxtGqXcXwO8Rg==",+ "node_modules/@rolldown/binding-linux-arm64-gnu": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.2.2.tgz",+ "integrity": "sha512-JsSMsj6sNat/MuhG5fnBD7QgbtpHKVe30x5/bAVirDHdhoQRXJkF6xc0Jqk8O4fiCUQAzMOoH9wZi3m60c8wtg==","cpu": ["arm64"],@@ -673,12 +777,15 @@"optional": true,"os": ["linux"- ]+ ],+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-linux-arm64-musl": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.2.tgz",- "integrity": "sha512-hr26p7e93Rl0Za+JwW7EAnwAvKkehh12BU1Llm9Ykiibg4uIr2rbpxG9WCf56GuvidlTG9KiiQT/TXT1yAWxTA==",+ "node_modules/@rolldown/binding-linux-arm64-musl": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.2.2.tgz",+ "integrity": "sha512-B5G/zJdHaoJn9vD50eGHWkiWfmq8Uhi3IiLPJTzmZTrAalk1bztUikSXo0qga18ibE0IXboyeMUnhPjhAJ45wQ==","cpu": ["arm64"],@@ -690,14 +797,17 @@"optional": true,"os": ["linux"- ]+ ],+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-linux-loong64-gnu": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.2.tgz",- "integrity": "sha512-pOjB/uSIyDt+ow3k/RcLvUAOGpysT2phDn7TTUB3n75SlIgZzM6NKAqlErPhoFU+npgY3/n+2HYIQVbF70P9/A==",+ "node_modules/@rolldown/binding-linux-ppc64-gnu": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.2.2.tgz",+ "integrity": "sha512-6mC/awzKka8W6EoekjegpfGkjz8jXWDX63pqu/HYVpyKtZfu65Jsh4QAH3Kej3CAv/c1oGX7psTmFEbr0mDxLA==","cpu": [- "loong64"+ "ppc64"],"dev": true,"libc": [@@ -707,31 +817,17 @@"optional": true,"os": ["linux"- ]- },- "node_modules/@rollup/rollup-linux-loong64-musl": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.2.tgz",- "integrity": "sha512-2/w+q8jszv9Ww1c+6uJT3OwqhdmGP2/4T17cu8WuwyUuuaCDDJ2ojdyYwZzCxx0GcsZBhzi3HmH+J5pZNXnd+Q==",- "cpu": [- "loong64"- ],- "dev": true,- "libc": [- "musl"],- "license": "MIT",- "optional": true,- "os": [- "linux"- ]+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-linux-ppc64-gnu": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.2.tgz",- "integrity": "sha512-11+aL5vKheYgczxtPVVRhdptAM2H7fcDR5Gw4/bTcteuZBlH4oP9f5s9zYO9aGZvoGeBpqXI/9TZZihZ609wKw==",+ "node_modules/@rolldown/binding-linux-s390x-gnu": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.2.2.tgz",+ "integrity": "sha512-412MX9fJLdA1IK28EZnc8jYv2HRTleOZgfLQumJ5zy7OeJLZlg/CETwFaXjNmGVxG51cFHpKLqb5LKvBC+HsHA==","cpu": [- "ppc64"+ "s390x"],"dev": true,"libc": [@@ -741,31 +837,17 @@"optional": true,"os": ["linux"- ]- },- "node_modules/@rollup/rollup-linux-ppc64-musl": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.2.tgz",- "integrity": "sha512-i16fokAGK46IVZuV8LIIwMdtqhin9hfYkCh8pf8iC3QU3LpwL+1FSFGej+O7l3E/AoknL6Dclh2oTdnRMpTzFQ==",- "cpu": [- "ppc64"- ],- "dev": true,- "libc": [- "musl"],- "license": "MIT",- "optional": true,- "os": [- "linux"- ]+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-linux-riscv64-gnu": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.2.tgz",- "integrity": "sha512-49FkKS6RGQoriDSK/6E2GkAsAuU5kETFCh7pG4yD/ylj9rKhTmO3elsnmBvRD4PgJPds5W2PkhC82aVwmUcJ7A==",+ "node_modules/@rolldown/binding-linux-x64-gnu": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.2.2.tgz",+ "integrity": "sha512-Q/+HI/ToJafZ1iCqGgVQXUEkIjufHCTF0gBQ2a5o3cg7GJ2h0qyq3nvvSmU+bGda2/7ygXpTY4TM6gO9OhQ0ZA==","cpu": [- "riscv64"+ "x64"],"dev": true,"libc": [@@ -775,14 +857,17 @@"optional": true,"os": ["linux"- ]+ ],+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-linux-riscv64-musl": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.2.tgz",- "integrity": "sha512-mjYNkHPfGpUR00DuM1ZZIgs64Hpf4bWcz9Z41+4Q+pgDx73UwWdAYyf6EG/lRFldmdHHzgrYyge5akFUW0D3mQ==",+ "node_modules/@rolldown/binding-linux-x64-musl": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.2.2.tgz",+ "integrity": "sha512-ZKp/w41n6wCvxzxQHtQSbuphfX3Y4cCvbjkKHusrLx4lh+JWLTU7StSltO/DKARISzbj368d+qUaCjI8K2wzXw==","cpu": [- "riscv64"+ "x64"],"dev": true,"libc": [@@ -792,325 +877,216 @@"optional": true,"os": ["linux"- ]+ ],+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-linux-s390x-gnu": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.2.tgz",- "integrity": "sha512-ALyvJz965BQk8E9Al/JDKKDLH2kfKFLTGMlgkAbbYtZuJt9LU8DW3ZoDMCtQpXAltZxwBHevXz5u+gf0yA0YoA==",+ "node_modules/@rolldown/binding-openharmony-arm64": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.2.2.tgz",+ "integrity": "sha512-pxE6xD4KS3eAROkKK5yrhB9/3+vhlhVGMvlQLbdpzrBGDbKrnzx3RLwPaHvasLo6jgaiBLn7e04Df9C4tYhjmA==","cpu": [- "s390x"+ "arm64"],"dev": true,- "libc": [- "glibc"- ],"license": "MIT","optional": true,"os": [- "linux"- ]+ "openharmony"+ ],+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-linux-x64-gnu": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.2.tgz",- "integrity": "sha512-UQjrkIdWrKI626Du8lCQ6MJp/6V1LAo2bOK9OTu4mSn8GGXIkPXk/Vsp4bLHCd9Z9Iz2OTEaokUE90VweJgIYQ==",+ "node_modules/@rolldown/binding-win32-arm64-msvc": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.2.2.tgz",+ "integrity": "sha512-4MqEue5re+xIZzAWsB8sj0P1kqZySWqIuN4t6QaIO/YA6SFwySOLruvWQFzfmqk8LBK2P30KCSJwf6mJCZZ5/A==","cpu": [- "x64"+ "arm64"],"dev": true,- "libc": [- "glibc"- ],"license": "MIT","optional": true,"os": [- "linux"- ]+ "win32"+ ],+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-linux-x64-musl": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.2.tgz",- "integrity": "sha512-bTsRGj6VlSdn/XD4CGyzMnzaBs9bsRxy79eTqTCBsA8TMIEky7qg48aPkvJvFe1HyzQ5oMZdg7AnVlWQSKLTnw==",+ "node_modules/@rolldown/binding-win32-x64-msvc": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.2.2.tgz",+ "integrity": "sha512-NweNxxD0Nf9t8v7kodun45Ijp3EIwYY+uydPP6qBEYvfBqhIjN6dZMzlQja3tqX/aLs3F3Uz+AxDpKgRhpOZQg==","cpu": ["x64"],"dev": true,- "libc": [- "musl"- ],- "license": "MIT",- "optional": true,- "os": [- "linux"- ]- },- "node_modules/@rollup/rollup-openbsd-x64": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.2.tgz",- "integrity": "sha512-6d4Z3534xitaA1FcMWP7mQPq5zGwBmGbhphh2DwaA1aNIXUu3KTOfwrWpbwI4/Gr0uANo7NTtaykFyO2hPuFLg==",- "cpu": [- "x64"- ],- "dev": true,- "license": "MIT",- "optional": true,- "os": [- "openbsd"- ]- },- "node_modules/@rollup/rollup-openharmony-arm64": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.2.tgz",- "integrity": "sha512-NetAg5iO2uN7eB8zE5qrZ3CSil+7IJt4WDFLcC75Ymywq1VZVD6qJ6EvNLjZ3rEm6gB7XW5JdT60c6MN35Z85Q==",- "cpu": [- "arm64"- ],- "dev": true,- "license": "MIT",- "optional": true,- "os": [- "openharmony"- ]- },- "node_modules/@rollup/rollup-win32-arm64-msvc": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.2.tgz",- "integrity": "sha512-NCYhOotpgWZ5kdxCZsv6Iudx0wX8980Q/oW4pNFNihpBKsDbEA1zpkfxJGC0yugsUuyDZ7gL37dbzwhR0VI7pQ==",- "cpu": [- "arm64"- ],- "dev": true,"license": "MIT","optional": true,"os": ["win32"- ]- },- "node_modules/@rollup/rollup-win32-ia32-msvc": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.2.tgz",- "integrity": "sha512-RXsaOqXxfoUBQoOgvmmijVxJnW2IGB0eoMO7F8FAjaj0UTywUO/luSqimWBJn04WNgUkeNhh7fs7pESXajWmkg==",- "cpu": [- "ia32"],- "dev": true,- "license": "MIT",- "optional": true,- "os": [- "win32"- ]- },- "node_modules/@rollup/rollup-win32-x64-gnu": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.2.tgz",- "integrity": "sha512-qdAzEULD+/hzObedtmV6iBpdL5TIbKVztGiK7O3/KYSf+HIzU257+MX1EXJcyIiDbMAqmbwaufcYPvyRryeZtA==",- "cpu": [- "x64"- ],- "dev": true,- "license": "MIT",- "optional": true,- "os": [- "win32"- ]+ "engines": {+ "node": "^20.19.0 || >=22.12.0"+ }},- "node_modules/@rollup/rollup-win32-x64-msvc": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.2.tgz",- "integrity": "sha512-Nd/SgG27WoA9e+/TdK74KnHz852TLa94ovOYySo/yMPuTmpckK/jIF2jSwS3g7ELSKXK13/cVdmg1Z/DaCWKxA==",- "cpu": [- "x64"- ],+ "node_modules/@rolldown/pluginutils": {+ "version": "1.0.1",+ "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz",+ "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==","dev": true,- "license": "MIT",- "optional": true,- "os": [- "win32"- ]+ "license": "MIT"},"node_modules/@selderee/plugin-htmlparser2": {- "version": "0.11.0",- "resolved": "https://registry.npmjs.org/@selderee/plugin-htmlparser2/-/plugin-htmlparser2-0.11.0.tgz",- "integrity": "sha512-P33hHGdldxGabLFjPPpaTxVolMrzrcegejx+0GxjrIb9Zv48D8yAIA/QTDR2dFl7Uz7urX8aX6+5bCZslr+gWQ==",+ "version": "0.12.0",+ "resolved": "https://registry.npmjs.org/@selderee/plugin-htmlparser2/-/plugin-htmlparser2-0.12.0.tgz",+ "integrity": "sha512-oELmoyA6ML9jDRMV3kgcMQFKxUfBU0yFVn6yTctVaLT5ygXnxH52I3TZEgV9EhXJC68/uFvE5Daj1/25c0Xa/A==","dev": true,"license": "MIT","dependencies": {- "domhandler": "^5.0.3",- "selderee": "^0.11.0"+ "domelementtype": "~2.3.0",+ "domhandler": "~5.0.3"},"funding": {- "url": "https://ko-fi.com/killymxi"+ "url": "https://github.com/sponsors/KillyMXI"+ },+ "peerDependencies": {+ "selderee": "~0.12.0"}},- "node_modules/@types/estree": {- "version": "1.0.8",- "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",- "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",+ "node_modules/@standard-schema/spec": {+ "version": "1.1.0",+ "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",+ "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==","dev": true,"license": "MIT"},- "node_modules/@vitest/expect": {- "version": "2.1.9",- "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-2.1.9.tgz",- "integrity": "sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==",+ "node_modules/@types/chai": {+ "version": "5.2.3",+ "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",+ "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==","dev": true,"license": "MIT","dependencies": {- "@vitest/spy": "2.1.9",- "@vitest/utils": "2.1.9",- "chai": "^5.1.2",- "tinyrainbow": "^1.2.0"- },- "funding": {- "url": "https://opencollective.com/vitest"+ "@types/deep-eql": "*",+ "assertion-error": "^2.0.1"}},- "node_modules/@vitest/mocker": {- "version": "2.1.9",- "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-2.1.9.tgz",- "integrity": "sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==",+ "node_modules/@types/deep-eql": {+ "version": "4.0.2",+ "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",+ "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/@types/estree": {+ "version": "1.0.9",+ "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",+ "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/@vitest/expect": {+ "version": "4.1.10",+ "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.10.tgz",+ "integrity": "sha512-YsCn+qAk1GWjQOWFEsEcL2gNQ0zmVmQu3T03qP6UyjhtmdtwtbuI+DASn/7iQB3HGTXkdBwGddzxPlmiql5vlA==","dev": true,"license": "MIT","dependencies": {- "@vitest/spy": "2.1.9",- "estree-walker": "^3.0.3",- "magic-string": "^0.30.12"+ "@standard-schema/spec": "^1.1.0",+ "@types/chai": "^5.2.2",+ "@vitest/spy": "4.1.10",+ "@vitest/utils": "4.1.10",+ "chai": "^6.2.2",+ "tinyrainbow": "^3.1.0"},"funding": {"url": "https://opencollective.com/vitest"- },- "peerDependencies": {- "msw": "^2.4.9",- "vite": "^5.0.0"- },- "peerDependenciesMeta": {- "msw": {- "optional": true- },- "vite": {- "optional": true- }}},"node_modules/@vitest/pretty-format": {- "version": "2.1.9",- "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.9.tgz",- "integrity": "sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==",+ "version": "4.1.10",+ "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.10.tgz",+ "integrity": "sha512-W1HsjSH4MXQ9YfmmhLAoIYf1HRfekQCGngeIgcei6MP5QQGWUe0gkopdZQaVCFO+JDJMrAJGwa5pRpNpvy4P8Q==","dev": true,"license": "MIT","dependencies": {- "tinyrainbow": "^1.2.0"+ "tinyrainbow": "^3.1.0"},"funding": {"url": "https://opencollective.com/vitest"}},"node_modules/@vitest/runner": {- "version": "2.1.9",- "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-2.1.9.tgz",- "integrity": "sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==",+ "version": "4.1.10",+ "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.10.tgz",+ "integrity": "sha512-IKI6kpIH+LmpROplyLwBBaCfMgOZOMsygVa6BARD6ahA04VRuJSa6OaVG7kRvSEMD870Vd91rSSw0eegtWyLGg==","dev": true,"license": "MIT","dependencies": {- "@vitest/utils": "2.1.9",- "pathe": "^1.1.2"+ "@vitest/utils": "4.1.10",+ "pathe": "^2.0.3"},"funding": {"url": "https://opencollective.com/vitest"}},"node_modules/@vitest/snapshot": {- "version": "2.1.9",- "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-2.1.9.tgz",- "integrity": "sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==",+ "version": "4.1.10",+ "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.10.tgz",+ "integrity": "sha512-xRkfOT1qpTAi/Ti4Y1LtfRc3kEuqxGw59eN2jN9pRWMtS/XDevekhcFSqvQqjUNGksfjMJu3Y+oJ+4Ypn2OaJw==","dev": true,"license": "MIT","dependencies": {- "@vitest/pretty-format": "2.1.9",- "magic-string": "^0.30.12",- "pathe": "^1.1.2"+ "@vitest/pretty-format": "4.1.10",+ "@vitest/utils": "4.1.10",+ "magic-string": "^0.30.21",+ "pathe": "^2.0.3"},"funding": {"url": "https://opencollective.com/vitest"}},"node_modules/@vitest/spy": {- "version": "2.1.9",- "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-2.1.9.tgz",- "integrity": "sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==",+ "version": "4.1.10",+ "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.10.tgz",+ "integrity": "sha512-PLf/Ugvoq5wO/b4rwYCR1h2PSIdXz7wnkQFMiUpLdtM7l6pqVFcQIBEHyT1+l+cj7mNwAfZHzqXqDyjvOuwbDw==","dev": true,"license": "MIT",- "dependencies": {- "tinyspy": "^3.0.2"- },"funding": {"url": "https://opencollective.com/vitest"}},"node_modules/@vitest/utils": {- "version": "2.1.9",- "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-2.1.9.tgz",- "integrity": "sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==",+ "version": "4.1.10",+ "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.10.tgz",+ "integrity": "sha512-fy9am/HWxbaGt/Sawrp90vt6Y6jQwf1RX77cz3uwoJwJVMli/e1IEwRPnMNJ7vKfPTwo0diXifkpPvwH9v7nGA==","dev": true,"license": "MIT","dependencies": {- "@vitest/pretty-format": "2.1.9",- "loupe": "^3.1.2",- "tinyrainbow": "^1.2.0"+ "@vitest/pretty-format": "4.1.10",+ "convert-source-map": "^2.0.0",+ "tinyrainbow": "^3.1.0"},"funding": {"url": "https://opencollective.com/vitest"}},"node_modules/@zone-eu/mailsplit": {- "version": "5.4.8",- "resolved": "https://registry.npmjs.org/@zone-eu/mailsplit/-/mailsplit-5.4.8.tgz",- "integrity": "sha512-eEyACj4JZ7sjzRvy26QhLgKEMWwQbsw1+QZnlLX+/gihcNH07lVPOcnwf5U6UAL7gkc//J3jVd76o/WS+taUiA==",+ "version": "5.4.14",+ "resolved": "https://registry.npmjs.org/@zone-eu/mailsplit/-/mailsplit-5.4.14.tgz",+ "integrity": "sha512-rz0FQOhN3Vq1XrSeSSa9+dPcaFbBxmQPjiZm6zS9oxdVHV7rOWIAYX3yP2YAUf0qBncY8CI+NogzPCmMVrMXcw==","dev": true,"license": "(MIT OR EUPL-1.1+)","dependencies": {"libbase64": "1.3.0",- "libmime": "5.3.7",+ "libmime": "5.4.1","libqp": "2.1.1"}},- "node_modules/@zone-eu/mailsplit/node_modules/iconv-lite": {- "version": "0.6.3",- "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",- "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",- "dev": true,- "license": "MIT",- "dependencies": {- "safer-buffer": ">= 2.1.2 < 3.0.0"- },- "engines": {- "node": ">=0.10.0"- }- },- "node_modules/@zone-eu/mailsplit/node_modules/libmime": {- "version": "5.3.7",- "resolved": "https://registry.npmjs.org/libmime/-/libmime-5.3.7.tgz",- "integrity": "sha512-FlDb3Wtha8P01kTL3P9M+ZDNDWPKPmKHWaU/cG/lg5pfuAwdflVpZE+wm9m7pKmC5ww6s+zTxBKS1p6yl3KpSw==",- "dev": true,- "license": "MIT",- "dependencies": {- "encoding-japanese": "2.2.0",- "iconv-lite": "0.6.3",- "libbase64": "1.3.0",- "libqp": "2.1.1"- }- },- "node_modules/agent-base": {- "version": "7.1.4",- "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",- "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",- "dev": true,- "license": "MIT",- "engines": {- "node": ">= 14"- }- },"node_modules/assertion-error": {"version": "2.0.1","resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",@@ -1121,128 +1097,74 @@"node": ">=12"}},- "node_modules/asynckit": {- "version": "0.4.0",- "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",- "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",- "dev": true,- "license": "MIT"- },- "node_modules/cac": {- "version": "6.7.14",- "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",- "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",- "dev": true,- "license": "MIT",- "engines": {- "node": ">=8"- }- },- "node_modules/call-bind-apply-helpers": {- "version": "1.0.2",- "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",- "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",+ "node_modules/bidi-js": {+ "version": "1.0.3",+ "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.0.3.tgz",+ "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==","dev": true,"license": "MIT","dependencies": {- "es-errors": "^1.3.0",- "function-bind": "^1.1.2"- },- "engines": {- "node": ">= 0.4"+ "require-from-string": "^2.0.2"}},"node_modules/chai": {- "version": "5.3.3",- "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",- "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",+ "version": "6.2.2",+ "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",+ "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==","dev": true,"license": "MIT",- "dependencies": {- "assertion-error": "^2.0.1",- "check-error": "^2.1.1",- "deep-eql": "^5.0.1",- "loupe": "^3.1.0",- "pathval": "^2.0.0"- },"engines": {"node": ">=18"}},- "node_modules/check-error": {- "version": "2.1.3",- "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz",- "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==",- "dev": true,- "license": "MIT",- "engines": {- "node": ">= 16"- }- },- "node_modules/combined-stream": {- "version": "1.0.8",- "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",- "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",+ "node_modules/convert-source-map": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",+ "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==","dev": true,- "license": "MIT",- "dependencies": {- "delayed-stream": "~1.0.0"- },- "engines": {- "node": ">= 0.8"- }+ "license": "MIT"},- "node_modules/cssstyle": {- "version": "4.6.0",- "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-4.6.0.tgz",- "integrity": "sha512-2z+rWdzbbSZv6/rhtvzvqeZQHrBaqgogqt85sqFNbabZOuFbCVFb8kPeEtZjiKkbrm395irpNKiYeFeLiQnFPg==",+ "node_modules/css-tree": {+ "version": "3.2.1",+ "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",+ "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==","dev": true,"license": "MIT","dependencies": {- "@asamuzakjp/css-color": "^3.2.0",- "rrweb-cssom": "^0.8.0"+ "mdn-data": "2.27.1",+ "source-map-js": "^1.2.1"},"engines": {- "node": ">=18"+ "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"}},- "node_modules/cssstyle/node_modules/rrweb-cssom": {- "version": "0.8.0",- "resolved": "https://registry.npmjs.org/rrweb-cssom/-/rrweb-cssom-0.8.0.tgz",- "integrity": "sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==",- "dev": true,- "license": "MIT"- },"node_modules/data-urls": {- "version": "5.0.0",- "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-5.0.0.tgz",- "integrity": "sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==",+ "version": "7.0.0",+ "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz",+ "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==","dev": true,"license": "MIT","dependencies": {- "whatwg-mimetype": "^4.0.0",- "whatwg-url": "^14.0.0"+ "whatwg-mimetype": "^5.0.0",+ "whatwg-url": "^16.0.0"},"engines": {- "node": ">=18"+ "node": "^20.19.0 || ^22.12.0 || >=24.0.0"}},- "node_modules/debug": {- "version": "4.4.3",- "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",- "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",+ "node_modules/data-urls/node_modules/whatwg-url": {+ "version": "16.0.1",+ "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-16.0.1.tgz",+ "integrity": "sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==","dev": true,"license": "MIT","dependencies": {- "ms": "^2.1.3"+ "@exodus/bytes": "^1.11.0",+ "tr46": "^6.0.0",+ "webidl-conversions": "^8.0.1"},"engines": {- "node": ">=6.0"- },- "peerDependenciesMeta": {- "supports-color": {- "optional": true- }+ "node": "^20.19.0 || ^22.12.0 || >=24.0.0"}},"node_modules/decimal.js": {@@ -1252,34 +1174,24 @@"dev": true,"license": "MIT"},- "node_modules/deep-eql": {- "version": "5.0.2",- "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",- "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",+ "node_modules/deepmerge-ts": {+ "version": "7.1.5",+ "resolved": "https://registry.npmjs.org/deepmerge-ts/-/deepmerge-ts-7.1.5.tgz",+ "integrity": "sha512-HOJkrhaYsweh+W+e74Yn7YStZOilkoPb6fycpwNLKzSPtruFs48nYis0zy5yJz1+ktUhHxoRDJ27RQAWLIJVJw==","dev": true,- "license": "MIT",- "engines": {- "node": ">=6"- }- },- "node_modules/deepmerge": {- "version": "4.3.1",- "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",- "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",- "dev": true,- "license": "MIT",+ "license": "BSD-3-Clause","engines": {- "node": ">=0.10.0"+ "node": ">=16.0.0"}},- "node_modules/delayed-stream": {- "version": "1.0.0",- "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",- "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",+ "node_modules/detect-libc": {+ "version": "2.1.2",+ "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",+ "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==","dev": true,- "license": "MIT",+ "license": "Apache-2.0","engines": {- "node": ">=0.4.0"+ "node": ">=8"}},"node_modules/dom-serializer": {@@ -1341,21 +1253,6 @@"url": "https://github.com/fb55/domutils?sponsor=1"}},- "node_modules/dunder-proto": {- "version": "1.0.1",- "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",- "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",- "dev": true,- "license": "MIT",- "dependencies": {- "call-bind-apply-helpers": "^1.0.1",- "es-errors": "^1.3.0",- "gopd": "^1.2.0"- },- "engines": {- "node": ">= 0.4"- }- },"node_modules/encoding-japanese": {"version": "2.2.0","resolved": "https://registry.npmjs.org/encoding-japanese/-/encoding-japanese-2.2.0.tgz",@@ -1379,66 +1276,17 @@"url": "https://github.com/fb55/entities?sponsor=1"}},- "node_modules/es-define-property": {- "version": "1.0.1",- "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",- "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",- "dev": true,- "license": "MIT",- "engines": {- "node": ">= 0.4"- }- },- "node_modules/es-errors": {- "version": "1.3.0",- "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",- "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",- "dev": true,- "license": "MIT",- "engines": {- "node": ">= 0.4"- }- },"node_modules/es-module-lexer": {- "version": "1.7.0",- "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",- "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",+ "version": "2.3.1",+ "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.1.tgz",+ "integrity": "sha512-shc1dbU90Yl/xq1QrC7QRtfcwURZuVRfPhZbDoldJ1cn1gzDvBaBWlv0eFolj5+0znnPJz5TXLxsN77X/12KTA==","dev": true,"license": "MIT"},- "node_modules/es-object-atoms": {- "version": "1.1.1",- "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",- "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",- "dev": true,- "license": "MIT",- "dependencies": {- "es-errors": "^1.3.0"- },- "engines": {- "node": ">= 0.4"- }- },- "node_modules/es-set-tostringtag": {- "version": "2.1.0",- "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",- "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",- "dev": true,- "license": "MIT",- "dependencies": {- "es-errors": "^1.3.0",- "get-intrinsic": "^1.2.6",- "has-tostringtag": "^1.0.2",- "hasown": "^2.0.2"- },- "engines": {- "node": ">= 0.4"- }- },"node_modules/esbuild": {- "version": "0.21.5",- "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",- "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",+ "version": "0.25.12",+ "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",+ "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==","dev": true,"hasInstallScript": true,"license": "MIT",@@ -1446,32 +1294,35 @@"esbuild": "bin/esbuild"},"engines": {- "node": ">=12"+ "node": ">=18"},"optionalDependencies": {- "@esbuild/aix-ppc64": "0.21.5",- "@esbuild/android-arm": "0.21.5",- "@esbuild/android-arm64": "0.21.5",- "@esbuild/android-x64": "0.21.5",- "@esbuild/darwin-arm64": "0.21.5",- "@esbuild/darwin-x64": "0.21.5",- "@esbuild/freebsd-arm64": "0.21.5",- "@esbuild/freebsd-x64": "0.21.5",- "@esbuild/linux-arm": "0.21.5",- "@esbuild/linux-arm64": "0.21.5",- "@esbuild/linux-ia32": "0.21.5",- "@esbuild/linux-loong64": "0.21.5",- "@esbuild/linux-mips64el": "0.21.5",- "@esbuild/linux-ppc64": "0.21.5",- "@esbuild/linux-riscv64": "0.21.5",- "@esbuild/linux-s390x": "0.21.5",- "@esbuild/linux-x64": "0.21.5",- "@esbuild/netbsd-x64": "0.21.5",- "@esbuild/openbsd-x64": "0.21.5",- "@esbuild/sunos-x64": "0.21.5",- "@esbuild/win32-arm64": "0.21.5",- "@esbuild/win32-ia32": "0.21.5",- "@esbuild/win32-x64": "0.21.5"+ "@esbuild/aix-ppc64": "0.25.12",+ "@esbuild/android-arm": "0.25.12",+ "@esbuild/android-arm64": "0.25.12",+ "@esbuild/android-x64": "0.25.12",+ "@esbuild/darwin-arm64": "0.25.12",+ "@esbuild/darwin-x64": "0.25.12",+ "@esbuild/freebsd-arm64": "0.25.12",+ "@esbuild/freebsd-x64": "0.25.12",+ "@esbuild/linux-arm": "0.25.12",+ "@esbuild/linux-arm64": "0.25.12",+ "@esbuild/linux-ia32": "0.25.12",+ "@esbuild/linux-loong64": "0.25.12",+ "@esbuild/linux-mips64el": "0.25.12",+ "@esbuild/linux-ppc64": "0.25.12",+ "@esbuild/linux-riscv64": "0.25.12",+ "@esbuild/linux-s390x": "0.25.12",+ "@esbuild/linux-x64": "0.25.12",+ "@esbuild/netbsd-arm64": "0.25.12",+ "@esbuild/netbsd-x64": "0.25.12",+ "@esbuild/openbsd-arm64": "0.25.12",+ "@esbuild/openbsd-x64": "0.25.12",+ "@esbuild/openharmony-arm64": "0.25.12",+ "@esbuild/sunos-x64": "0.25.12",+ "@esbuild/win32-arm64": "0.25.12",+ "@esbuild/win32-ia32": "0.25.12",+ "@esbuild/win32-x64": "0.25.12"}},"node_modules/estree-walker": {@@ -1494,21 +1345,22 @@"node": ">=12.0.0"}},- "node_modules/form-data": {- "version": "4.0.5",- "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",- "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",+ "node_modules/fdir": {+ "version": "6.5.0",+ "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",+ "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==","dev": true,"license": "MIT",- "dependencies": {- "asynckit": "^0.4.0",- "combined-stream": "^1.0.8",- "es-set-tostringtag": "^2.1.0",- "hasown": "^2.0.2",- "mime-types": "^2.1.12"- },"engines": {- "node": ">= 6"+ "node": ">=12.0.0"+ },+ "peerDependencies": {+ "picomatch": "^3 || ^4"+ },+ "peerDependenciesMeta": {+ "picomatch": {+ "optional": true+ }}},"node_modules/fsevents": {@@ -1526,110 +1378,6 @@"node": "^8.16.0 || ^10.6.0 || >=11.0.0"}},- "node_modules/function-bind": {- "version": "1.1.2",- "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",- "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",- "dev": true,- "license": "MIT",- "funding": {- "url": "https://github.com/sponsors/ljharb"- }- },- "node_modules/get-intrinsic": {- "version": "1.3.0",- "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",- "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",- "dev": true,- "license": "MIT",- "dependencies": {- "call-bind-apply-helpers": "^1.0.2",- "es-define-property": "^1.0.1",- "es-errors": "^1.3.0",- "es-object-atoms": "^1.1.1",- "function-bind": "^1.1.2",- "get-proto": "^1.0.1",- "gopd": "^1.2.0",- "has-symbols": "^1.1.0",- "hasown": "^2.0.2",- "math-intrinsics": "^1.1.0"- },- "engines": {- "node": ">= 0.4"- },- "funding": {- "url": "https://github.com/sponsors/ljharb"- }- },- "node_modules/get-proto": {- "version": "1.0.1",- "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",- "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",- "dev": true,- "license": "MIT",- "dependencies": {- "dunder-proto": "^1.0.1",- "es-object-atoms": "^1.0.0"- },- "engines": {- "node": ">= 0.4"- }- },- "node_modules/gopd": {- "version": "1.2.0",- "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",- "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",- "dev": true,- "license": "MIT",- "engines": {- "node": ">= 0.4"- },- "funding": {- "url": "https://github.com/sponsors/ljharb"- }- },- "node_modules/has-symbols": {- "version": "1.1.0",- "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",- "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",- "dev": true,- "license": "MIT",- "engines": {- "node": ">= 0.4"- },- "funding": {- "url": "https://github.com/sponsors/ljharb"- }- },- "node_modules/has-tostringtag": {- "version": "1.0.2",- "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",- "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",- "dev": true,- "license": "MIT",- "dependencies": {- "has-symbols": "^1.0.3"- },- "engines": {- "node": ">= 0.4"- },- "funding": {- "url": "https://github.com/sponsors/ljharb"- }- },- "node_modules/hasown": {- "version": "2.0.3",- "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.3.tgz",- "integrity": "sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==",- "dev": true,- "license": "MIT",- "dependencies": {- "function-bind": "^1.1.2"- },- "engines": {- "node": ">= 0.4"- }- },"node_modules/he": {"version": "1.2.0","resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",@@ -1641,39 +1389,42 @@}},"node_modules/html-encoding-sniffer": {- "version": "4.0.0",- "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-4.0.0.tgz",- "integrity": "sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==",+ "version": "6.0.0",+ "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz",+ "integrity": "sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==","dev": true,"license": "MIT","dependencies": {- "whatwg-encoding": "^3.1.1"+ "@exodus/bytes": "^1.6.0"},"engines": {- "node": ">=18"+ "node": "^20.19.0 || ^22.12.0 || >=24.0.0"}},"node_modules/html-to-text": {- "version": "9.0.5",- "resolved": "https://registry.npmjs.org/html-to-text/-/html-to-text-9.0.5.tgz",- "integrity": "sha512-qY60FjREgVZL03vJU6IfMV4GDjGBIoOyvuFdpBDIX9yTlDw0TjxVBQp+P8NvpdIXNJvfWBTNul7fsAQJq2FNpg==",+ "version": "10.0.0",+ "resolved": "https://registry.npmjs.org/html-to-text/-/html-to-text-10.0.0.tgz",+ "integrity": "sha512-2OH59Gtprdczel+7Rxgpz9hGVJREaf8Lt1H4kZwWHpEn70VQKRuMNGsb2eDbwaTzrYzb0hheiOG1P7Dim0B4dQ==","dev": true,"license": "MIT","dependencies": {- "@selderee/plugin-htmlparser2": "^0.11.0",- "deepmerge": "^4.3.1",+ "@selderee/plugin-htmlparser2": "~0.12.0",+ "deepmerge-ts": "^7.1.5","dom-serializer": "^2.0.0",- "htmlparser2": "^8.0.2",- "selderee": "^0.11.0"+ "htmlparser2": "^10.1.0",+ "selderee": "~0.12.0"},"engines": {- "node": ">=14"+ "node": ">=20.19.0"+ },+ "funding": {+ "url": "https://github.com/sponsors/KillyMXI"}},"node_modules/htmlparser2": {- "version": "8.0.2",- "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.2.tgz",- "integrity": "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==",+ "version": "10.1.0",+ "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-10.1.0.tgz",+ "integrity": "sha512-VTZkM9GWRAtEpveh7MSF6SjjrpNVNNVJfFup7xTY3UpFtm67foy9HDVXneLtFVt4pMz5kZtgNcvCniNFb1hlEQ==","dev": true,"funding": ["https://github.com/fb55/htmlparser2?sponsor=1",@@ -1686,42 +1437,27 @@"dependencies": {"domelementtype": "^2.3.0","domhandler": "^5.0.3",- "domutils": "^3.0.1",- "entities": "^4.4.0"+ "domutils": "^3.2.2",+ "entities": "^7.0.1"}},- "node_modules/http-proxy-agent": {- "version": "7.0.2",- "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",- "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",+ "node_modules/htmlparser2/node_modules/entities": {+ "version": "7.0.1",+ "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",+ "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==","dev": true,- "license": "MIT",- "dependencies": {- "agent-base": "^7.1.0",- "debug": "^4.3.4"- },+ "license": "BSD-2-Clause","engines": {- "node": ">= 14"- }- },- "node_modules/https-proxy-agent": {- "version": "7.0.6",- "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",- "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",- "dev": true,- "license": "MIT",- "dependencies": {- "agent-base": "^7.1.2",- "debug": "4"+ "node": ">=0.12"},- "engines": {- "node": ">= 14"+ "funding": {+ "url": "https://github.com/fb55/entities?sponsor=1"}},"node_modules/iconv-lite": {- "version": "0.7.2",- "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",- "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",+ "version": "0.7.3",+ "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.3.tgz",+ "integrity": "sha512-IKXpvIzjnC9XTAUbVBcMfGS0EPaIXtW6v+zr+RRp+hqULEpo0owZax6wyRwPOJbWbzjYspQwusTsfVr0ifh4uQ==","dev": true,"license": "MIT","dependencies": {@@ -1743,39 +1479,39 @@"license": "MIT"},"node_modules/jsdom": {- "version": "25.0.1",- "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-25.0.1.tgz",- "integrity": "sha512-8i7LzZj7BF8uplX+ZyOlIz86V6TAsSs+np6m1kpW9u0JWi4z/1t+FzcK1aek+ybTnAC4KhBL4uXCNT0wcUIeCw==",+ "version": "30.0.1",+ "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-30.0.1.tgz",+ "integrity": "sha512-52v7mUVUfNQVYYqE1lcdaymWL0njO7lTLUog6ZvW2U5KsbiLk/GnZlVJ+qx0xfNJZ6Gn+KSpPNE52vurbxZwrA==","dev": true,"license": "MIT","dependencies": {- "cssstyle": "^4.1.0",- "data-urls": "^5.0.0",- "decimal.js": "^10.4.3",- "form-data": "^4.0.0",- "html-encoding-sniffer": "^4.0.0",- "http-proxy-agent": "^7.0.2",- "https-proxy-agent": "^7.0.5",+ "@asamuzakjp/css-color": "^6.0.5",+ "@asamuzakjp/dom-selector": "^8.3.0",+ "@bramus/specificity": "^2.4.2",+ "@csstools/css-syntax-patches-for-csstree": "^1.1.7",+ "@exodus/bytes": "^1.15.1",+ "css-tree": "^3.2.1",+ "data-urls": "^7.0.0",+ "decimal.js": "^10.6.0",+ "html-encoding-sniffer": "^6.0.0","is-potential-custom-element-name": "^1.0.1",- "nwsapi": "^2.2.12",- "parse5": "^7.1.2",- "rrweb-cssom": "^0.7.1",+ "lru-cache": "^11.5.2",+ "parse5": "^8.0.1","saxes": "^6.0.0","symbol-tree": "^3.2.4",- "tough-cookie": "^5.0.0",+ "tough-cookie": "^6.0.2",+ "undici": "^8.9.0","w3c-xmlserializer": "^5.0.0",- "webidl-conversions": "^7.0.0",- "whatwg-encoding": "^3.1.1",- "whatwg-mimetype": "^4.0.0",- "whatwg-url": "^14.0.0",- "ws": "^8.18.0",+ "webidl-conversions": "^8.0.1",+ "whatwg-mimetype": "^5.0.0",+ "whatwg-url": "^17.1.0","xml-name-validator": "^5.0.0"},"engines": {- "node": ">=18"+ "node": "^22.22.2 || ^24.15.0 || >=26.0.0"},"peerDependencies": {- "canvas": "^2.11.2"+ "canvas": "^3.2.3"},"peerDependenciesMeta": {"canvas": {@@ -1783,66 +1519,345 @@}}},- "node_modules/leac": {- "version": "0.6.0",- "resolved": "https://registry.npmjs.org/leac/-/leac-0.6.0.tgz",- "integrity": "sha512-y+SqErxb8h7nE/fiEX07jsbuhrpO9lL8eca7/Y1nuWV2moNlXhyd59iDGcRf6moVyDMbmTNzL40SUyrFU/yDpg==",+ "node_modules/leac": {+ "version": "0.7.0",+ "resolved": "https://registry.npmjs.org/leac/-/leac-0.7.0.tgz",+ "integrity": "sha512-qMrZeyEekgdRQ9o6a4NAB2EQZrv827GJdn1vnapwSJ90hWRB4TzUSunvacPkxQ2TnNqHNI1/zSt0hlo0crG8Jw==",+ "dev": true,+ "license": "MIT",+ "funding": {+ "url": "https://github.com/sponsors/KillyMXI"+ }+ },+ "node_modules/libbase64": {+ "version": "1.3.0",+ "resolved": "https://registry.npmjs.org/libbase64/-/libbase64-1.3.0.tgz",+ "integrity": "sha512-GgOXd0Eo6phYgh0DJtjQ2tO8dc0IVINtZJeARPeiIJqge+HdsWSuaDTe8ztQ7j/cONByDZ3zeB325AHiv5O0dg==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/libmime": {+ "version": "5.4.1",+ "resolved": "https://registry.npmjs.org/libmime/-/libmime-5.4.1.tgz",+ "integrity": "sha512-0wHGhsofo9IdQPenr3BBHXuxcwMq4atFUTsZ9Ogc1OvI5h4rUdDIrBQEN9JHjCXfDMrE59LUMJWsTD82wTYk8A==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "encoding-japanese": "2.2.0",+ "iconv-lite": "0.7.3",+ "libbase64": "1.3.0",+ "libqp": "2.1.1"+ }+ },+ "node_modules/libqp": {+ "version": "2.1.1",+ "resolved": "https://registry.npmjs.org/libqp/-/libqp-2.1.1.tgz",+ "integrity": "sha512-0Wd+GPz1O134cP62YU2GTOPNA7Qgl09XwCqM5zpBv87ERCXdfDtyKXvV7c9U22yWJh44QZqBocFnXN11K96qow==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/lightningcss": {+ "version": "1.33.0",+ "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.33.0.tgz",+ "integrity": "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA==",+ "dev": true,+ "license": "MPL-2.0",+ "dependencies": {+ "detect-libc": "^2.0.3"+ },+ "engines": {+ "node": ">= 12.0.0"+ },+ "funding": {+ "type": "opencollective",+ "url": "https://opencollective.com/parcel"+ },+ "optionalDependencies": {+ "lightningcss-android-arm64": "1.33.0",+ "lightningcss-darwin-arm64": "1.33.0",+ "lightningcss-darwin-x64": "1.33.0",+ "lightningcss-freebsd-x64": "1.33.0",+ "lightningcss-linux-arm-gnueabihf": "1.33.0",+ "lightningcss-linux-arm64-gnu": "1.33.0",+ "lightningcss-linux-arm64-musl": "1.33.0",+ "lightningcss-linux-x64-gnu": "1.33.0",+ "lightningcss-linux-x64-musl": "1.33.0",+ "lightningcss-win32-arm64-msvc": "1.33.0",+ "lightningcss-win32-x64-msvc": "1.33.0"+ }+ },+ "node_modules/lightningcss-android-arm64": {+ "version": "1.33.0",+ "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.33.0.tgz",+ "integrity": "sha512-gEpRTalKdosp4Bb8qWtc2iOgE5SeIHlpS1up9bFq2wAyYhl1UdTObYiHe98zEM9SQvSoqQZ1IQD0JNpg3Ml5pg==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MPL-2.0",+ "optional": true,+ "os": [+ "android"+ ],+ "engines": {+ "node": ">= 12.0.0"+ },+ "funding": {+ "type": "opencollective",+ "url": "https://opencollective.com/parcel"+ }+ },+ "node_modules/lightningcss-darwin-arm64": {+ "version": "1.33.0",+ "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.33.0.tgz",+ "integrity": "sha512-Sciaz8eenNTKn9b3t7+xr0ipTp9YxKQY4npwQ3mrRuL0BAVHBLyZxofhaKBAVtzmtRZ/zTyo0/to4B1uWG/Djg==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MPL-2.0",+ "optional": true,+ "os": [+ "darwin"+ ],+ "engines": {+ "node": ">= 12.0.0"+ },+ "funding": {+ "type": "opencollective",+ "url": "https://opencollective.com/parcel"+ }+ },+ "node_modules/lightningcss-darwin-x64": {+ "version": "1.33.0",+ "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.33.0.tgz",+ "integrity": "sha512-Z5UPAxzrjlWNNyGy6i65cJzzvgJ5D3T6wMvs+gWpY9d7qRhANrxqAp6LhxIgZhWEw18RfJTGcRxjuLIBr+m8XQ==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MPL-2.0",+ "optional": true,+ "os": [+ "darwin"+ ],+ "engines": {+ "node": ">= 12.0.0"+ },+ "funding": {+ "type": "opencollective",+ "url": "https://opencollective.com/parcel"+ }+ },+ "node_modules/lightningcss-freebsd-x64": {+ "version": "1.33.0",+ "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.33.0.tgz",+ "integrity": "sha512-QQM/Ti/hQajJwCY+RiWuCZ9sdtI/XQk7nDK5vC8kkdwixezOlDgvDx7+RT+QjK6FcFT4MpsuoBnHIo/O3StRRg==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MPL-2.0",+ "optional": true,+ "os": [+ "freebsd"+ ],+ "engines": {+ "node": ">= 12.0.0"+ },+ "funding": {+ "type": "opencollective",+ "url": "https://opencollective.com/parcel"+ }+ },+ "node_modules/lightningcss-linux-arm-gnueabihf": {+ "version": "1.33.0",+ "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.33.0.tgz",+ "integrity": "sha512-N7FVBe6iS24MlM6R/4RBTxGhQheZGs7tiQ9U32UtF75NzP5Q7xWPRqLBCKxlRQRk3rY1jCIPLzx7WzOhuUIRLQ==",+ "cpu": [+ "arm"+ ],+ "dev": true,+ "license": "MPL-2.0",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">= 12.0.0"+ },+ "funding": {+ "type": "opencollective",+ "url": "https://opencollective.com/parcel"+ }+ },+ "node_modules/lightningcss-linux-arm64-gnu": {+ "version": "1.33.0",+ "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.33.0.tgz",+ "integrity": "sha512-j2v/itmy4HlNxlc6voKXYgBqNi0Ng2LShg4z7GufpEgs05P+2suBVyi9I6YHq5uoVFx9ETin3eCEhLVyXGQnKg==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "libc": [+ "glibc"+ ],+ "license": "MPL-2.0",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">= 12.0.0"+ },+ "funding": {+ "type": "opencollective",+ "url": "https://opencollective.com/parcel"+ }+ },+ "node_modules/lightningcss-linux-arm64-musl": {+ "version": "1.33.0",+ "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.33.0.tgz",+ "integrity": "sha512-yiO5ROMuYQgXbC60yjZU5CYSFZGKXL0HFATXt9mHJn1+zW55oCtMI9NfcVhYLMFDL7gV7oBPon/EmMMGg2OvtQ==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "libc": [+ "musl"+ ],+ "license": "MPL-2.0",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">= 12.0.0"+ },+ "funding": {+ "type": "opencollective",+ "url": "https://opencollective.com/parcel"+ }+ },+ "node_modules/lightningcss-linux-x64-gnu": {+ "version": "1.33.0",+ "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.33.0.tgz",+ "integrity": "sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "libc": [+ "glibc"+ ],+ "license": "MPL-2.0",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">= 12.0.0"+ },+ "funding": {+ "type": "opencollective",+ "url": "https://opencollective.com/parcel"+ }+ },+ "node_modules/lightningcss-linux-x64-musl": {+ "version": "1.33.0",+ "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.33.0.tgz",+ "integrity": "sha512-RYiYbkokw0trfKqqzfF55lginwEPrD3OJDfTuJzFs1MK6iFnDenaz1fqLLtX4ITG3OktJQXOeTaw1awrBAlZPw==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "libc": [+ "musl"+ ],+ "license": "MPL-2.0",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">= 12.0.0"+ },+ "funding": {+ "type": "opencollective",+ "url": "https://opencollective.com/parcel"+ }+ },+ "node_modules/lightningcss-win32-arm64-msvc": {+ "version": "1.33.0",+ "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.33.0.tgz",+ "integrity": "sha512-1K+MPfLSFVpphzpdbfkhlWk6wBrTObBzS2T6db10PNOZgR9GoVsAWzwNyuhUYYbTp23j+4RrncfujZ4uAzXvwA==",+ "cpu": [+ "arm64"+ ],"dev": true,- "license": "MIT",+ "license": "MPL-2.0",+ "optional": true,+ "os": [+ "win32"+ ],+ "engines": {+ "node": ">= 12.0.0"+ },"funding": {- "url": "https://ko-fi.com/killymxi"+ "type": "opencollective",+ "url": "https://opencollective.com/parcel"}},- "node_modules/libbase64": {- "version": "1.3.0",- "resolved": "https://registry.npmjs.org/libbase64/-/libbase64-1.3.0.tgz",- "integrity": "sha512-GgOXd0Eo6phYgh0DJtjQ2tO8dc0IVINtZJeARPeiIJqge+HdsWSuaDTe8ztQ7j/cONByDZ3zeB325AHiv5O0dg==",- "dev": true,- "license": "MIT"- },- "node_modules/libmime": {- "version": "5.3.8",- "resolved": "https://registry.npmjs.org/libmime/-/libmime-5.3.8.tgz",- "integrity": "sha512-ZrCY+Q66mPvasAfjsQ/IgahzoBvfE1VdtGRpo1hwRB1oK3wJKxhKA3GOcd2a6j7AH5eMFccxK9fBoCpRZTf8ng==",+ "node_modules/lightningcss-win32-x64-msvc": {+ "version": "1.33.0",+ "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.33.0.tgz",+ "integrity": "sha512-OlEICDx/Xl0FqSp4bry8zFnCvGpig3Gl4gCquvYwHuqJKEC1+n9NgDniFvqHGmMv1ZkqDJrDqKKSykTDX+ehuA==",+ "cpu": [+ "x64"+ ],"dev": true,- "license": "MIT",- "dependencies": {- "encoding-japanese": "2.2.0",- "iconv-lite": "0.7.2",- "libbase64": "1.3.0",- "libqp": "2.1.1"+ "license": "MPL-2.0",+ "optional": true,+ "os": [+ "win32"+ ],+ "engines": {+ "node": ">= 12.0.0"+ },+ "funding": {+ "type": "opencollective",+ "url": "https://opencollective.com/parcel"}},- "node_modules/libqp": {- "version": "2.1.1",- "resolved": "https://registry.npmjs.org/libqp/-/libqp-2.1.1.tgz",- "integrity": "sha512-0Wd+GPz1O134cP62YU2GTOPNA7Qgl09XwCqM5zpBv87ERCXdfDtyKXvV7c9U22yWJh44QZqBocFnXN11K96qow==",- "dev": true,- "license": "MIT"- },"node_modules/linkify-it": {- "version": "5.0.0",- "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-5.0.0.tgz",- "integrity": "sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==",+ "version": "5.0.2",+ "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-5.0.2.tgz",+ "integrity": "sha512-ONTm2jCMAVZjgQa/Fy1kScXsuOoF5NPTsoFBdE1KVIZ2vAh/r9+Bqo+0jINCBYnavTPQZz38QzFTme79ENoN3Q==","dev": true,+ "funding": [+ {+ "type": "github",+ "url": "https://github.com/sponsors/puzrin"+ },+ {+ "type": "github",+ "url": "https://github.com/sponsors/markdown-it"+ }+ ],"license": "MIT","dependencies": {"uc.micro": "^2.0.0"}},- "node_modules/loupe": {- "version": "3.2.1",- "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",- "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",- "dev": true,- "license": "MIT"- },"node_modules/lru-cache": {- "version": "10.4.3",- "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",- "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",+ "version": "11.5.2",+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.2.tgz",+ "integrity": "sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==","dev": true,- "license": "ISC"+ "license": "BlueOak-1.0.0",+ "engines": {+ "node": "20 || >=22"+ }},"node_modules/magic-string": {"version": "0.30.21",@@ -1855,68 +1870,35 @@}},"node_modules/mailparser": {- "version": "3.9.8",- "resolved": "https://registry.npmjs.org/mailparser/-/mailparser-3.9.8.tgz",- "integrity": "sha512-7jSlFGXiianVnhnb6wdutJFloD34488nrHY7r6FNqwXAhZ7YiJDYrKKTxZJ0oSrXcAPHm8YoYnh97xyGtrBQ3w==",+ "version": "3.9.14",+ "resolved": "https://registry.npmjs.org/mailparser/-/mailparser-3.9.14.tgz",+ "integrity": "sha512-3QD6TRXcyXtq2NCuyA2AEjqmallQkyxYmZI9GMCIvQDCaB9Uc034WUI1x8RUBYFnk5+p7h14JEz4O/lrxQmttw==","dev": true,"license": "MIT","dependencies": {- "@zone-eu/mailsplit": "5.4.8",+ "@zone-eu/mailsplit": "5.4.14","encoding-japanese": "2.2.0","he": "1.2.0",- "html-to-text": "9.0.5",- "iconv-lite": "0.7.2",- "libmime": "5.3.8",- "linkify-it": "5.0.0",- "nodemailer": "8.0.5",+ "html-to-text": "10.0.0",+ "iconv-lite": "0.7.3",+ "libmime": "5.4.1",+ "linkify-it": "5.0.2",+ "nodemailer": "9.0.3","punycode.js": "2.3.1","tlds": "1.261.0"}},- "node_modules/math-intrinsics": {- "version": "1.1.0",- "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",- "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",- "dev": true,- "license": "MIT",- "engines": {- "node": ">= 0.4"- }- },- "node_modules/mime-db": {- "version": "1.52.0",- "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",- "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",- "dev": true,- "license": "MIT",- "engines": {- "node": ">= 0.6"- }- },- "node_modules/mime-types": {- "version": "2.1.35",- "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",- "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",- "dev": true,- "license": "MIT",- "dependencies": {- "mime-db": "1.52.0"- },- "engines": {- "node": ">= 0.6"- }- },- "node_modules/ms": {- "version": "2.1.3",- "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",- "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",+ "node_modules/mdn-data": {+ "version": "2.27.1",+ "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",+ "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==","dev": true,- "license": "MIT"+ "license": "CC0-1.0"},"node_modules/nanoid": {- "version": "3.3.12",- "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",- "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",+ "version": "3.3.17",+ "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.17.tgz",+ "integrity": "sha512-xQLf0A3HOMlgHq0n247/LRuAOYmB7dXJ/DvAxGvsSBij45XtBSmQycu+F8ODbHwns/XyFZagyL1+J0Offw1E0g==","dev": true,"funding": [{@@ -1933,87 +1915,84 @@}},"node_modules/nodemailer": {- "version": "8.0.5",- "resolved": "https://registry.npmjs.org/nodemailer/-/nodemailer-8.0.5.tgz",- "integrity": "sha512-0PF8Yb1yZuQfQbq+5/pZJrtF6WQcjTd5/S4JOHs9PGFxuTqoB/icwuB44pOdURHJbRKX1PPoJZtY7R4VUoCC8w==",+ "version": "9.0.3",+ "resolved": "https://registry.npmjs.org/nodemailer/-/nodemailer-9.0.3.tgz",+ "integrity": "sha512-n+YP+NKwR5zRWa60k3GiQ6Q3B4KXCoAw40dAKeCtYn020iNN74aWK2liXIC3ZEATeGql7we3tE3t8QwhY0eskw==","dev": true,"license": "MIT-0","engines": {"node": ">=6.0.0"}},- "node_modules/nwsapi": {- "version": "2.2.23",- "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.23.tgz",- "integrity": "sha512-7wfH4sLbt4M0gCDzGE6vzQBo0bfTKjU7Sfpqy/7gs1qBfYz2vEJH6vXcBKpO3+6Yu1telwd0t9HpyOoLEQQbIQ==",+ "node_modules/obug": {+ "version": "2.1.4",+ "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.4.tgz",+ "integrity": "sha512-4a+OsYv9UktOJKE+l1A4OufDgdRF9PifWj+tJnHURo/P+WOxpG4GzUFL9qCalmWauao6ogiG+QvnCovwPoyAWA==","dev": true,- "license": "MIT"+ "funding": [+ "https://github.com/sponsors/sxzz",+ "https://opencollective.com/debug"+ ],+ "license": "MIT",+ "engines": {+ "node": ">=12.20.0"+ }},"node_modules/parse5": {- "version": "7.3.0",- "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",- "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",+ "version": "8.0.1",+ "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",+ "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==","dev": true,"license": "MIT","dependencies": {- "entities": "^6.0.0"+ "entities": "^8.0.0"},"funding": {"url": "https://github.com/inikulin/parse5?sponsor=1"}},"node_modules/parse5/node_modules/entities": {- "version": "6.0.1",- "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",- "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",+ "version": "8.0.0",+ "resolved": "https://registry.npmjs.org/entities/-/entities-8.0.0.tgz",+ "integrity": "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==","dev": true,"license": "BSD-2-Clause","engines": {- "node": ">=0.12"+ "node": ">=20.19.0"},"funding": {"url": "https://github.com/fb55/entities?sponsor=1"}},"node_modules/parseley": {- "version": "0.12.1",- "resolved": "https://registry.npmjs.org/parseley/-/parseley-0.12.1.tgz",- "integrity": "sha512-e6qHKe3a9HWr0oMRVDTRhKce+bRO8VGQR3NyVwcjwrbhMmFCX9KszEV35+rn4AdilFAq9VPxP/Fe1wC9Qjd2lw==",+ "version": "0.13.1",+ "resolved": "https://registry.npmjs.org/parseley/-/parseley-0.13.1.tgz",+ "integrity": "sha512-uNBJZzmb60l6p6VWLTmevizNAGnE0xoSf1n0B4q3ntegDNzcS68NRCcBDZTcyXHxt2XhBChsCuqj4M+nChvE/A==","dev": true,"license": "MIT","dependencies": {- "leac": "^0.6.0",- "peberminta": "^0.9.0"+ "leac": "^0.7.0",+ "peberminta": "^0.10.0"},"funding": {- "url": "https://ko-fi.com/killymxi"+ "url": "https://github.com/sponsors/KillyMXI"}},"node_modules/pathe": {- "version": "1.1.2",- "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",- "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",+ "version": "2.0.3",+ "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",+ "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==","dev": true,"license": "MIT"},- "node_modules/pathval": {- "version": "2.0.1",- "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",- "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",- "dev": true,- "license": "MIT",- "engines": {- "node": ">= 14.16"- }- },"node_modules/peberminta": {- "version": "0.9.0",- "resolved": "https://registry.npmjs.org/peberminta/-/peberminta-0.9.0.tgz",- "integrity": "sha512-XIxfHpEuSJbITd1H3EeQwpcZbTLHc+VVr8ANI9t5sit565tsI4/xK3KWTUFE2e6QiangUkh3B0jihzmGnNrRsQ==",+ "version": "0.10.0",+ "resolved": "https://registry.npmjs.org/peberminta/-/peberminta-0.10.0.tgz",+ "integrity": "sha512-80B2AsU+I4Qdb0ZAPSfe9UwvGzwkM37IKIFEvdS3D/3Ndgv2bsuJ0bfG1+iEYO+l7Gfd4EUJmuRyq7efLgRMzQ==","dev": true,"license": "MIT","funding": {- "url": "https://ko-fi.com/killymxi"+ "url": "https://github.com/sponsors/KillyMXI"}},"node_modules/picocolors": {@@ -2023,10 +2002,23 @@"dev": true,"license": "ISC"},+ "node_modules/picomatch": {+ "version": "4.0.5",+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",+ "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=12"+ },+ "funding": {+ "url": "https://github.com/sponsors/jonschlinkert"+ }+ },"node_modules/postcss": {- "version": "8.5.13",- "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.13.tgz",- "integrity": "sha512-qif0+jGGZoLWdHey3UFHHWP0H7Gbmsk8T5VEqyYFbWqPr1XqvLGBbk/sl8V5exGmcYJklJOhOQq1pV9IcsiFag==",+ "version": "8.5.25",+ "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.25.tgz",+ "integrity": "sha512-DTPx3RWSSnWyzLxQnlH0rJP+EW5ekl16ZU4/psbIhA0e53kJfdgaN5vKM+xP7yJtXVu+nfdVFmlgFDEKAe4Pyw==","dev": true,"funding": [{@@ -2044,7 +2036,7 @@],"license": "MIT","dependencies": {- "nanoid": "^3.3.11",+ "nanoid": "^3.3.16","picocolors": "^1.1.1","source-map-js": "^1.2.1"},@@ -2072,57 +2064,48 @@"node": ">=6"}},- "node_modules/rollup": {- "version": "4.60.2",- "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.2.tgz",- "integrity": "sha512-J9qZyW++QK/09NyN/zeO0dG/1GdGfyp9lV8ajHnRVLfo/uFsbji5mHnDgn/qYdUHyCkM2N+8VyspgZclfAh0eQ==",+ "node_modules/require-from-string": {+ "version": "2.0.2",+ "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",+ "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=0.10.0"+ }+ },+ "node_modules/rolldown": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.2.2.tgz",+ "integrity": "sha512-opwpo1tQBAcpSUJDt94B7hhLNGOKjCdE//XXjeLrnx9b83bjnw45tXdg1b09yEw/VLFBJGZpwRULMmOZo7ol+A==","dev": true,"license": "MIT","dependencies": {- "@types/estree": "1.0.8"+ "@oxc-project/types": "=0.142.0",+ "@rolldown/pluginutils": "^1.0.0"},"bin": {- "rollup": "dist/bin/rollup"+ "rolldown": "bin/cli.mjs"},"engines": {- "node": ">=18.0.0",- "npm": ">=8.0.0"+ "node": "^20.19.0 || >=22.12.0"},"optionalDependencies": {- "@rollup/rollup-android-arm-eabi": "4.60.2",- "@rollup/rollup-android-arm64": "4.60.2",- "@rollup/rollup-darwin-arm64": "4.60.2",- "@rollup/rollup-darwin-x64": "4.60.2",- "@rollup/rollup-freebsd-arm64": "4.60.2",- "@rollup/rollup-freebsd-x64": "4.60.2",- "@rollup/rollup-linux-arm-gnueabihf": "4.60.2",- "@rollup/rollup-linux-arm-musleabihf": "4.60.2",- "@rollup/rollup-linux-arm64-gnu": "4.60.2",- "@rollup/rollup-linux-arm64-musl": "4.60.2",- "@rollup/rollup-linux-loong64-gnu": "4.60.2",- "@rollup/rollup-linux-loong64-musl": "4.60.2",- "@rollup/rollup-linux-ppc64-gnu": "4.60.2",- "@rollup/rollup-linux-ppc64-musl": "4.60.2",- "@rollup/rollup-linux-riscv64-gnu": "4.60.2",- "@rollup/rollup-linux-riscv64-musl": "4.60.2",- "@rollup/rollup-linux-s390x-gnu": "4.60.2",- "@rollup/rollup-linux-x64-gnu": "4.60.2",- "@rollup/rollup-linux-x64-musl": "4.60.2",- "@rollup/rollup-openbsd-x64": "4.60.2",- "@rollup/rollup-openharmony-arm64": "4.60.2",- "@rollup/rollup-win32-arm64-msvc": "4.60.2",- "@rollup/rollup-win32-ia32-msvc": "4.60.2",- "@rollup/rollup-win32-x64-gnu": "4.60.2",- "@rollup/rollup-win32-x64-msvc": "4.60.2",- "fsevents": "~2.3.2"- }- },- "node_modules/rrweb-cssom": {- "version": "0.7.1",- "resolved": "https://registry.npmjs.org/rrweb-cssom/-/rrweb-cssom-0.7.1.tgz",- "integrity": "sha512-TrEMa7JGdVm0UThDJSx7ddw5nVm3UJS9o9CCIZ72B1vSyEZoziDqBYP3XIoi/12lKrJR8rE3jeFHMok2F/Mnsg==",- "dev": true,- "license": "MIT"+ "@rolldown/binding-android-arm64": "1.2.2",+ "@rolldown/binding-darwin-arm64": "1.2.2",+ "@rolldown/binding-darwin-x64": "1.2.2",+ "@rolldown/binding-freebsd-x64": "1.2.2",+ "@rolldown/binding-linux-arm-gnueabihf": "1.2.2",+ "@rolldown/binding-linux-arm64-gnu": "1.2.2",+ "@rolldown/binding-linux-arm64-musl": "1.2.2",+ "@rolldown/binding-linux-ppc64-gnu": "1.2.2",+ "@rolldown/binding-linux-s390x-gnu": "1.2.2",+ "@rolldown/binding-linux-x64-gnu": "1.2.2",+ "@rolldown/binding-linux-x64-musl": "1.2.2",+ "@rolldown/binding-openharmony-arm64": "1.2.2",+ "@rolldown/binding-win32-arm64-msvc": "1.2.2",+ "@rolldown/binding-win32-x64-msvc": "1.2.2"+ }},"node_modules/safer-buffer": {"version": "2.1.2",@@ -2145,16 +2128,16 @@}},"node_modules/selderee": {- "version": "0.11.0",- "resolved": "https://registry.npmjs.org/selderee/-/selderee-0.11.0.tgz",- "integrity": "sha512-5TF+l7p4+OsnP8BCCvSyZiSPc4x4//p5uPwK8TCnVPJYRmU2aYKMpOXvw8zM5a5JvuuCGN1jmsMwuU2W02ukfA==",+ "version": "0.12.0",+ "resolved": "https://registry.npmjs.org/selderee/-/selderee-0.12.0.tgz",+ "integrity": "sha512-b1YMh3+DHZp59DLna3qVwQ5iOla/nrI6mLBNW02XxU77M3046Df6VLkoaJyFz20VsGIG5kkp+FK0kg4K4HnUFw==","dev": true,"license": "MIT","dependencies": {- "parseley": "^0.12.0"+ "parseley": "~0.13.1"},"funding": {- "url": "https://ko-fi.com/killymxi"+ "url": "https://github.com/sponsors/KillyMXI"}},"node_modules/siginfo": {@@ -2182,9 +2165,9 @@"license": "MIT"},"node_modules/std-env": {- "version": "3.10.0",- "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",- "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",+ "version": "4.2.0",+ "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.2.0.tgz",+ "integrity": "sha512-oCUKSupKTHX53EyjDtuZQ64pjLJ6yYCtpmEw0goYxtjG9KpbRe8KAsl2tBUGU9DyMcJ0RwJ8GqJAFzMXcXW1Rw==","dev": true,"license": "MIT"},@@ -2203,36 +2186,36 @@"license": "MIT"},"node_modules/tinyexec": {- "version": "0.3.2",- "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",- "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",- "dev": true,- "license": "MIT"- },- "node_modules/tinypool": {- "version": "1.1.1",- "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",- "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",+ "version": "1.3.0",+ "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.3.0.tgz",+ "integrity": "sha512-QKAl9m8gWWGHV8jZcPeym6j+XULi6tOf1mT83WYJ4Lk2ytW/uwAWkrP0uFsdoYMdueVJ0qs26wZ+23xeB4ibNQ==","dev": true,"license": "MIT","engines": {- "node": "^18.0.0 || >=20.0.0"+ "node": ">=18"}},- "node_modules/tinyrainbow": {- "version": "1.2.0",- "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-1.2.0.tgz",- "integrity": "sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==",+ "node_modules/tinyglobby": {+ "version": "0.2.17",+ "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",+ "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==","dev": true,"license": "MIT",+ "dependencies": {+ "fdir": "^6.5.0",+ "picomatch": "^4.0.4"+ },"engines": {- "node": ">=14.0.0"+ "node": ">=12.0.0"+ },+ "funding": {+ "url": "https://github.com/sponsors/SuperchupuDev"}},- "node_modules/tinyspy": {- "version": "3.0.2",- "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz",- "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==",+ "node_modules/tinyrainbow": {+ "version": "3.1.1",+ "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.1.tgz",+ "integrity": "sha512-yau8yJdTt989Mm0Bd/236QnzEiPf2xLLTqUZRUJOo/3CB078LSwzei343DgtJVmfJKJE3TMINY1u42SQsP6mXw==","dev": true,"license": "MIT","engines": {@@ -2250,49 +2233,49 @@}},"node_modules/tldts": {- "version": "6.1.86",- "resolved": "https://registry.npmjs.org/tldts/-/tldts-6.1.86.tgz",- "integrity": "sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==",+ "version": "7.4.10",+ "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.10.tgz",+ "integrity": "sha512-GgouD1B+sWwvkaEq8vXC15DjQitxbvs12oIXELpconwm+Tg3zfcEv4jgzq3vtKverDXsg3VI8aRgNL2Nra0Iog==","dev": true,"license": "MIT","dependencies": {- "tldts-core": "^6.1.86"+ "tldts-core": "^7.4.10"},"bin": {"tldts": "bin/cli.js"}},"node_modules/tldts-core": {- "version": "6.1.86",- "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-6.1.86.tgz",- "integrity": "sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==",+ "version": "7.4.10",+ "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.10.tgz",+ "integrity": "sha512-KnQjp53ZekKgm/r3l+u8kJGGzYgrWdP8+Mql7a4vijh2WE0IrZWspQj/TpTxDho/YxO+AnOZnIjQcCD+q6iJsw==","dev": true,"license": "MIT"},"node_modules/tough-cookie": {- "version": "5.1.2",- "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-5.1.2.tgz",- "integrity": "sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==",+ "version": "6.0.2",+ "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.2.tgz",+ "integrity": "sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==","dev": true,"license": "BSD-3-Clause","dependencies": {- "tldts": "^6.1.32"+ "tldts": "^7.0.5"},"engines": {"node": ">=16"}},"node_modules/tr46": {- "version": "5.1.1",- "resolved": "https://registry.npmjs.org/tr46/-/tr46-5.1.1.tgz",- "integrity": "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==",+ "version": "6.0.0",+ "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",+ "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==","dev": true,"license": "MIT","dependencies": {"punycode": "^2.3.1"},"engines": {- "node": ">=18"+ "node": ">=20"}},"node_modules/uc.micro": {@@ -2302,151 +2285,207 @@"dev": true,"license": "MIT"},- "node_modules/vite": {- "version": "5.4.21",- "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",- "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",+ "node_modules/undici": {+ "version": "8.10.0",+ "resolved": "https://registry.npmjs.org/undici/-/undici-8.10.0.tgz",+ "integrity": "sha512-HvltHd7avK13QIw/oLe4qoOLyoVSoafqJ2jYOrtMRBkbYT31eiBQ8O0ehRKZiEZCMEyLFQNIADpgCWC5fALvYQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=22.19.0"+ }+ },+ "node_modules/vitest": {+ "version": "4.1.10",+ "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.10.tgz",+ "integrity": "sha512-R9jUTe5S4Qb0HCd4TNqpC7oGcrMssMRGXLW80ubjWsW9VH5GF8y1Y0SFLY9AbqSk6nt0PnOx4H4WNJYZ13GUPw==","dev": true,"license": "MIT","dependencies": {- "esbuild": "^0.21.3",- "postcss": "^8.4.43",- "rollup": "^4.20.0"+ "@vitest/expect": "4.1.10",+ "@vitest/mocker": "4.1.10",+ "@vitest/pretty-format": "4.1.10",+ "@vitest/runner": "4.1.10",+ "@vitest/snapshot": "4.1.10",+ "@vitest/spy": "4.1.10",+ "@vitest/utils": "4.1.10",+ "es-module-lexer": "^2.0.0",+ "expect-type": "^1.3.0",+ "magic-string": "^0.30.21",+ "obug": "^2.1.1",+ "pathe": "^2.0.3",+ "picomatch": "^4.0.3",+ "std-env": "^4.0.0-rc.1",+ "tinybench": "^2.9.0",+ "tinyexec": "^1.0.2",+ "tinyglobby": "^0.2.15",+ "tinyrainbow": "^3.1.0",+ "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",+ "why-is-node-running": "^2.3.0"},"bin": {- "vite": "bin/vite.js"+ "vitest": "vitest.mjs"},"engines": {- "node": "^18.0.0 || >=20.0.0"+ "node": "^20.0.0 || ^22.0.0 || >=24.0.0"},"funding": {- "url": "https://github.com/vitejs/vite?sponsor=1"- },- "optionalDependencies": {- "fsevents": "~2.3.3"+ "url": "https://opencollective.com/vitest"},"peerDependencies": {- "@types/node": "^18.0.0 || >=20.0.0",- "less": "*",- "lightningcss": "^1.21.0",- "sass": "*",- "sass-embedded": "*",- "stylus": "*",- "sugarss": "*",- "terser": "^5.4.0"+ "@edge-runtime/vm": "*",+ "@opentelemetry/api": "^1.9.0",+ "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",+ "@vitest/browser-playwright": "4.1.10",+ "@vitest/browser-preview": "4.1.10",+ "@vitest/browser-webdriverio": "4.1.10",+ "@vitest/coverage-istanbul": "4.1.10",+ "@vitest/coverage-v8": "4.1.10",+ "@vitest/ui": "4.1.10",+ "happy-dom": "*",+ "jsdom": "*",+ "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"},"peerDependenciesMeta": {+ "@edge-runtime/vm": {+ "optional": true+ },+ "@opentelemetry/api": {+ "optional": true+ },"@types/node": {"optional": true},- "less": {+ "@vitest/browser-playwright": {"optional": true},- "lightningcss": {+ "@vitest/browser-preview": {"optional": true},- "sass": {+ "@vitest/browser-webdriverio": {"optional": true},- "sass-embedded": {+ "@vitest/coverage-istanbul": {"optional": true},- "stylus": {+ "@vitest/coverage-v8": {"optional": true},- "sugarss": {+ "@vitest/ui": {"optional": true},- "terser": {+ "happy-dom": {+ "optional": true+ },+ "jsdom": {"optional": true+ },+ "vite": {+ "optional": false}}},- "node_modules/vite-node": {- "version": "2.1.9",- "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-2.1.9.tgz",- "integrity": "sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==",+ "node_modules/vitest/node_modules/@vitest/mocker": {+ "version": "4.1.10",+ "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.10.tgz",+ "integrity": "sha512-v0xaezt+DKEmKfaxg133ldzADrwLGd7Ze1MfQQTYfvs8OqZIwbxyxaYURivwV7sWy5fqn3rH5uOrSp07bp44Ow==","dev": true,"license": "MIT","dependencies": {- "cac": "^6.7.14",- "debug": "^4.3.7",- "es-module-lexer": "^1.5.4",- "pathe": "^1.1.2",- "vite": "^5.0.0"- },- "bin": {- "vite-node": "vite-node.mjs"- },- "engines": {- "node": "^18.0.0 || >=20.0.0"+ "@vitest/spy": "4.1.10",+ "estree-walker": "^3.0.3",+ "magic-string": "^0.30.21"},"funding": {"url": "https://opencollective.com/vitest"+ },+ "peerDependencies": {+ "msw": "^2.4.9",+ "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"+ },+ "peerDependenciesMeta": {+ "msw": {+ "optional": true+ },+ "vite": {+ "optional": true+ }}},- "node_modules/vitest": {- "version": "2.1.9",- "resolved": "https://registry.npmjs.org/vitest/-/vitest-2.1.9.tgz",- "integrity": "sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==",+ "node_modules/vitest/node_modules/vite": {+ "version": "8.2.0",+ "resolved": "https://registry.npmjs.org/vite/-/vite-8.2.0.tgz",+ "integrity": "sha512-pn+CFpM0lwDeKwmOq1ZaBK/9sjorZcgqxki6MbY/jPEVd9vichIlmlD4HmQ5wdP5EgqQCFRaACBxMC7uEGc6lQ==","dev": true,"license": "MIT","dependencies": {- "@vitest/expect": "2.1.9",- "@vitest/mocker": "2.1.9",- "@vitest/pretty-format": "^2.1.9",- "@vitest/runner": "2.1.9",- "@vitest/snapshot": "2.1.9",- "@vitest/spy": "2.1.9",- "@vitest/utils": "2.1.9",- "chai": "^5.1.2",- "debug": "^4.3.7",- "expect-type": "^1.1.0",- "magic-string": "^0.30.12",- "pathe": "^1.1.2",- "std-env": "^3.8.0",- "tinybench": "^2.9.0",- "tinyexec": "^0.3.1",- "tinypool": "^1.0.1",- "tinyrainbow": "^1.2.0",- "vite": "^5.0.0",- "vite-node": "2.1.9",- "why-is-node-running": "^2.3.0"+ "lightningcss": "^1.33.0",+ "picomatch": "^4.0.5",+ "postcss": "^8.5.23",+ "rolldown": "~1.2.0",+ "tinyglobby": "^0.2.17"},"bin": {- "vitest": "vitest.mjs"+ "vite": "bin/vite.js"},"engines": {- "node": "^18.0.0 || >=20.0.0"+ "node": "^20.19.0 || >=22.12.0"},"funding": {- "url": "https://opencollective.com/vitest"+ "url": "https://github.com/vitejs/vite?sponsor=1"+ },+ "optionalDependencies": {+ "fsevents": "~2.3.3"},"peerDependencies": {- "@edge-runtime/vm": "*",- "@types/node": "^18.0.0 || >=20.0.0",- "@vitest/browser": "2.1.9",- "@vitest/ui": "2.1.9",- "happy-dom": "*",- "jsdom": "*"+ "@types/node": "^20.19.0 || >=22.12.0",+ "@vitejs/devtools": "^0.4.0",+ "esbuild": "^0.27.0 || ^0.28.0",+ "jiti": ">=1.21.0",+ "less": "^4.0.0",+ "sass": "^1.70.0",+ "sass-embedded": "^1.70.0",+ "stylus": ">=0.54.8",+ "sugarss": "^5.0.0",+ "terser": "^5.16.0",+ "tsx": "^4.8.1",+ "yaml": "^2.4.2"},"peerDependenciesMeta": {- "@edge-runtime/vm": {+ "@types/node": {"optional": true},- "@types/node": {+ "@vitejs/devtools": {"optional": true},- "@vitest/browser": {+ "esbuild": {"optional": true},- "@vitest/ui": {+ "jiti": {"optional": true},- "happy-dom": {+ "less": {"optional": true},- "jsdom": {+ "sass": {+ "optional": true+ },+ "sass-embedded": {+ "optional": true+ },+ "stylus": {+ "optional": true+ },+ "sugarss": {+ "optional": true+ },+ "terser": {+ "optional": true+ },+ "tsx": {+ "optional": true+ },+ "yaml": {"optional": true}}@@ -2465,64 +2504,38 @@}},"node_modules/webidl-conversions": {- "version": "7.0.0",- "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz",- "integrity": "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==",+ "version": "8.0.1",+ "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",+ "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==","dev": true,"license": "BSD-2-Clause","engines": {- "node": ">=12"- }- },- "node_modules/whatwg-encoding": {- "version": "3.1.1",- "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz",- "integrity": "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==",- "deprecated": "Use @exodus/bytes instead for a more spec-conformant and faster implementation",- "dev": true,- "license": "MIT",- "dependencies": {- "iconv-lite": "0.6.3"- },- "engines": {- "node": ">=18"- }- },- "node_modules/whatwg-encoding/node_modules/iconv-lite": {- "version": "0.6.3",- "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",- "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",- "dev": true,- "license": "MIT",- "dependencies": {- "safer-buffer": ">= 2.1.2 < 3.0.0"- },- "engines": {- "node": ">=0.10.0"+ "node": ">=20"}},"node_modules/whatwg-mimetype": {- "version": "4.0.0",- "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",- "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",+ "version": "5.0.0",+ "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",+ "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==","dev": true,"license": "MIT","engines": {- "node": ">=18"+ "node": ">=20"}},"node_modules/whatwg-url": {- "version": "14.2.0",- "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-14.2.0.tgz",- "integrity": "sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==",+ "version": "17.1.0",+ "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-17.1.0.tgz",+ "integrity": "sha512-3GeworPmc2ZfEEHP7lEbUfBX/L75wdEsi0rLNhXcXxnoN5jyq0SL5gCy06SGW2cyTIZdTvWIDQNQoza++vKeaw==","dev": true,"license": "MIT","dependencies": {- "tr46": "^5.1.0",- "webidl-conversions": "^7.0.0"+ "@exodus/bytes": "^1.15.1",+ "tr46": "^6.0.0",+ "webidl-conversions": "^8.0.1"},"engines": {- "node": ">=18"+ "node": "^22.14.0 || >=24.0.0"}},"node_modules/why-is-node-running": {@@ -2542,28 +2555,6 @@"node": ">=8"}},- "node_modules/ws": {- "version": "8.20.0",- "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",- "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",- "dev": true,- "license": "MIT",- "engines": {- "node": ">=10.0.0"- },- "peerDependencies": {- "bufferutil": "^4.0.1",- "utf-8-validate": ">=5.0.2"- },- "peerDependenciesMeta": {- "bufferutil": {- "optional": true- },- "utf-8-validate": {- "optional": true- }- }- },"node_modules/xml-name-validator": {"version": "5.0.0","resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",diff --git a/extension/package.json b/extension/package.jsonindex 1bb24dd..2d7f7c8 100644--- a/extension/package.json+++ b/extension/package.json@@ -7,8 +7,9 @@"test:watch": "vitest"},"devDependencies": {- "vitest": "^2.1.0",- "jsdom": "^25.0.0",- "mailparser": "^3.7.0"+ "esbuild": "^0.25.0",+ "vitest": "^4.0.0",+ "jsdom": "^30.0.0",+ "mailparser": "^3.9.14"}}\ No newline at end of filediff --git a/extension/src/mail/extractor.js b/extension/src/mail/extractor.jsindex 4752eb7..396d18d 100644--- a/extension/src/mail/extractor.js+++ b/extension/src/mail/extractor.js@@ -96,7 +96,7 @@ export function isFalsePositive(num, context) {// ---------------------------------------------------------------------------// FALLBACK text extraction: manually walk getFull() parts.-// Used when listInlineTextParts() is unavailable (older Thunderbird builds).+// Recovery path for messages whose MIME tree makes listInlineTextParts() throw.// For HTML parts we use DOMParser to tag prominent elements for the scorer,// then grab the full body plain text.// ---------------------------------------------------------------------------@@ -152,12 +152,12 @@ function extractTextFromParts(parts) {}// ----------------------------------------------------------------------------// PRIMARY text extraction: uses newer Thunderbird APIs (TB 102+).+// PRIMARY text extraction. Both APIs set the manifest's strict_min_version://-// messenger.messages.listInlineTextParts(id)+// messenger.messages.listInlineTextParts(id) - TB 128+// - gives us clean content without manually walking the MIME tree//-// messenger.messengerUtilities.convertToPlainText(html)+// messenger.messengerUtilities.convertToPlainText(html) - TB 137+// - Thunderbird's own HTML-to-plaintext converter; handles tables,// encoded entities, and nested elements far better than a hand-rolled// DOMParser tag-strip. Borrowed from thunderbird-vericode's approach.@@ -165,7 +165,7 @@ function extractTextFromParts(parts) {// We still run the DOMParser tagging pass on the raw HTML before// converting, so the scorer's +25 bonus is preserved on this code path too.//-// Falls back to extractTextFromParts() for older Thunderbird/Betterbird builds.+// extractTextFromParts() catches runtime failures, not missing APIs.// ---------------------------------------------------------------------------async function getEmailText(messageId) {try {@@ -218,9 +218,9 @@ async function getEmailText(messageId) {return text;} catch (e) {- // listInlineTextParts or convertToPlainText not available- // fall back to the manual DOMParser path.- console.log("listInlineTextParts unavailable, falling back to getFull():", e.message);+ // strict_min_version guarantees both APIs exist, so this is a message+ // they choked on. Retry by walking the MIME tree ourselves.+ console.log("listInlineTextParts failed, falling back to getFull():", e.message);const full = await messenger.messages.getFull(messageId);return extractTextFromParts(full.parts);}diff --git a/packaging/systemd/[email protected] b/packaging/systemd/[email protected]new file mode 100644index 0000000..f8cd204--- /dev/null+++ b/packaging/systemd/[email protected]@@ -0,0 +1,22 @@+[Unit]+# set Class of Device A/V Hands-Free (major 4, minor 8).+# bluetoothd resets the class to its own default every time it+# starts, and when it does, MAP and PBAP stop working with an OBEX error.+#+# %i is the adapter, e.g. [email protected].+Description=Set Bluetooth Class of Device to A/V Hands-Free on %i for Tether+Documentation=https://github.com/zackb/tether/blob/main/docs/BLUETOOTH.md+After=bluetooth.service+PartOf=bluetooth.service++[Service]+Type=oneshot+RemainAfterExit=yes+ExecStart=/bin/sh -c 'for i in 1 2 3 4 5 6 7 8 9 10; do \+ btmgmt --index %i class 4 8 >/dev/null 2>&1; \+ btmgmt --index %i info 2>/dev/null | grep -q "class 0x..0408" && exit 0; \+ sleep 1; \+done; exit 1'++[Install]+WantedBy=bluetooth.servicediff --git a/scripts/bt-probe.sh b/scripts/bt-probe.shnew file mode 100755index 0000000..d192e26--- /dev/null+++ b/scripts/bt-probe.sh@@ -0,0 +1,185 @@+#!/usr/bin/env bash+# Report whether this machine can carry Tether's iPhone Bluetooth features.+#+# Full mode = MAP + PBAP (messages, contacts) + ANCS (notifications)+# Compatibility = MAP + PBAP only; no notification mirroring+#+# Read-only unless --set-class is given.++set -uo pipefail++ADAPTER=${ADAPTER:-hci0}+ADAPTER_PATH="/org/bluez/$ADAPTER"++# A/V Hands-Free. iOS only offers the Messages/Contacts permission toggles to a+# device presenting this class. BlueZ ORs service bits on top, so only the low+# 13 bits (format + major + minor) are comparable.+TARGET_COD_LOW=0x0408+COD_MASK=0x1fff++set_class=0+[[ ${1:-} == --set-class ]] && set_class=1++red=$'\e[31m'; grn=$'\e[32m'; ylw=$'\e[33m'; dim=$'\e[2m'; rst=$'\e[0m'+[[ -t 1 ]] || { red=; grn=; ylw=; dim=; rst=; }++blockers=0 # hardware/stack cannot do the job at all+degraded=0 # capable of MAP/PBAP but not ANCS+conflicts=0 # capable, but something else is in the way right now++ok() { printf ' %s✓%s %s\n' "$grn" "$rst" "$1"; }+warn() { printf ' %s!%s %s\n' "$ylw" "$rst" "$1"; degraded=$((degraded + 1)); }+clash() { printf ' %s!%s %s\n' "$ylw" "$rst" "$1"; conflicts=$((conflicts + 1)); }+bad() { printf ' %s✗%s %s\n' "$red" "$rst" "$1"; blockers=$((blockers + 1)); }+note() { printf ' %s%s%s\n' "$dim" "$1" "$rst"; }++prop() {+ busctl --system get-property org.bluez "$ADAPTER_PATH" "$1" "$2" 2>/dev/null |+ awk '{ $1=""; sub(/^ /,""); gsub(/"/,""); print }'+}++echo+echo "Tether Bluetooth capability probe"+echo "================================="++# --- tools ---------------------------------------------------------------+echo+echo "Tooling"+for t in busctl btmgmt bluetoothctl; do+ if command -v "$t" >/dev/null; then ok "$t"; else bad "$t not found"; fi+done+command -v btmon >/dev/null || note "btmon not installed; useful for debugging pairing"++# --- bluez ---------------------------------------------------------------+echo+echo "BlueZ"+bluez_ver=$(bluetoothctl --version 2>/dev/null | awk '{print $2}')+if [[ -z $bluez_ver ]]; then+ bad "could not determine BlueZ version"+elif [[ $(printf '%s\n5.86\n' "$bluez_ver" | sort -V | head -1) == "5.86" ]]; then+ ok "version $bluez_ver (>= 5.86)"+else+ warn "version $bluez_ver is older than 5.86 — ANCS unavailable"+ note "MAP and PBAP still work; notification mirroring does not"+fi++# org.bluez.Bearer.LE1 appears only on bonded devices, and only when bluetoothd+# runs with --experimental (short form -E). A live interface on an existing bond+# is ground truth; the daemon command line is the fallback before anything is+# paired. Do not test for the long form alone, Arch's packaging uses -E.+bearer_seen=$(busctl --system call org.bluez / org.freedesktop.DBus.ObjectManager \+ GetManagedObjects 2>/dev/null | grep -c 'org\.bluez\.Bearer\.LE1')+if (( bearer_seen > 0 )); then+ ok "Bearer.LE1 present on a bonded device (Bearer API confirmed live)"+elif pgrep -af 'bluetoothd' | grep -qE -- '(^|[[:space:]])(-E|--experimental)([[:space:]]|$)'; then+ ok "bluetoothd running with --experimental (Bearer API available)"+else+ warn "bluetoothd is NOT running with --experimental — Bearer.LE1 unavailable"+ note "ANCS needs it to drive the LE half of the bond. To enable:"+ note " sudo mkdir -p /etc/systemd/system/bluetooth.service.d"+ note " printf '[Service]\\nExecStart=\\nExecStart=/usr/lib/bluetooth/bluetoothd --experimental\\n' \\"+ note " | sudo tee /etc/systemd/system/bluetooth.service.d/experimental.conf"+ note " sudo systemctl daemon-reload && sudo systemctl restart bluetooth"+fi++# --- adapter -------------------------------------------------------------+echo+echo "Adapter ($ADAPTER)"+if ! busctl --system introspect org.bluez "$ADAPTER_PATH" >/dev/null 2>&1; then+ bad "adapter $ADAPTER not present on the system bus"+ echo+ echo "Set ADAPTER=hciN to probe a different adapter."+ exit 1+fi++addr=$(prop org.bluez.Adapter1 Address)+name=$(prop org.bluez.Adapter1 Alias)+ok "$addr ($name)"++[[ $(prop org.bluez.Adapter1 Powered) == true ]] && ok "powered on" || bad "powered off (bluetoothctl power on)"++roles=$(prop org.bluez.Adapter1 Roles)+# BR/EDR is implied by a working Adapter1; LE requires both GATT roles. Peripheral+# is what lets us broadcast the post-bond ANCS solicitation advert that makes iOS+# surface its permission toggles.+[[ $roles == *central* ]] && ok "LE central role" || bad "no LE central role — ANCS impossible"+[[ $roles == *peripheral* ]] && ok "LE peripheral role" || warn "no LE peripheral role — cannot solicit ANCS"++instances=$(prop org.bluez.LEAdvertisingManager1 SupportedInstances)+if [[ -n ${instances:-} && $instances -gt 0 ]]; then+ ok "advertising supported ($instances instances)"+else+ warn "no advertising instances — iOS may never show the permission toggles"+fi++# --- class of device -----------------------------------------------------+echo+echo "Class of Device"+cod=$(prop org.bluez.Adapter1 Class)+if [[ -z ${cod:-} ]]; then+ warn "could not read adapter class"+else+ printf -v cod_hex '0x%06x' "$cod"+ low=$(( cod & COD_MASK ))+ if (( low == TARGET_COD_LOW )); then+ ok "$cod_hex — A/V Hands-Free (major 4, minor 8)"+ else+ major=$(( (cod >> 8) & 0x1f ))+ warn "$cod_hex — major $major, expected A/V Hands-Free (major 4, minor 8)"+ note "iOS will not treat this machine as an eligible accessory."+ if (( set_class )); then+ echo+ note "running: btmgmt class 4 8"+ if sudo btmgmt --index "${ADAPTER#hci}" class 4 8; then+ note "class set; re-run this probe to confirm"+ note "Make it stick: sudo systemctl enable --now tether-btclass@$ADAPTER"+ else+ note "failed — run 'sudo btmgmt class 4 8' by hand"+ fi+ else+ note "Fix with: $0 --set-class (or: sudo btmgmt class 4 8)"+ note "That lasts until bluetoothd restarts. To make it stick:"+ note " sudo systemctl enable --now tether-btclass@$ADAPTER"+ fi+ fi+fi++# --- conflicts -----------------------------------------------------------+# The iPhone serves exactly one MAP session at a time. Any other local process+# holding it makes Tether's MAP connect fail with "Connection refused (111)",+# which looks nothing like a permissions problem and wastes a lot of debugging.+echo+echo "Conflicts"+if systemctl --user is-active --quiet blueferry.service 2>/dev/null; then+ clash "blueferry.service is running and will hold the iPhone's MAP session"+ note "Stop it while testing Tether: systemctl --user stop blueferry.service"+else+ ok "no other known MAP consumer running"+fi++if systemctl --user is-active --quiet obex.service 2>/dev/null; then+ ok "obexd active (required for MAP and PBAP)"+else+ warn "obexd is not active — MAP and PBAP will not connect"+ note "It is socket-activated; 'systemctl --user start obex' forces it up."+fi++# --- verdict -------------------------------------------------------------+echo+echo "Verdict"+if (( blockers > 0 )); then+ printf ' %sBLOCKED%s — %d hard problem(s) above must be resolved first.\n' "$red" "$rst" "$blockers"+ exit 1+fi++if (( degraded > 0 )); then+ printf ' %sCOMPATIBILITY MODE%s — messages and contacts (MAP/PBAP) should work;\n' "$ylw" "$rst"+ printf ' notification mirroring (ANCS) will not, until the %d capability gap(s) above are fixed.\n' "$degraded"+else+ printf ' %sFULL MODE%s — this machine can carry MAP, PBAP, and ANCS.\n' "$grn" "$rst"+fi++if (( conflicts > 0 )); then+ printf ' %s%d conflict(s)%s must be cleared before Tether can connect right now.\n' "$ylw" "$conflicts" "$rst"+fi+exit 0diff --git a/src/cli/main.cpp b/src/cli/main.cppindex fc4d7a7..166c4b4 100644--- a/src/cli/main.cpp+++ b/src/cli/main.cpp@@ -1,6 +1,8 @@#include <atomic>#include <csignal>+#include <ctime>#include <iostream>+#include <nlohmann/json.hpp>#include <string>#include <tether/client.hpp>#include <tether/crypto.hpp>@@ -104,6 +106,15 @@ void print_help() {<< " --port <num> Connect over TCP port (default 5134).\n"<< " --timeout <ms> Discovery scan duration in milliseconds (default 3000).\n"<< " --list-devices List all paired connection devices.\n"+ << " --bt-status Show Bluetooth adapter capability and delivery mode.\n"+ << " --bt-devices List Bluetooth devices known to BlueZ.\n"+ << " --bt-connection Show Bluetooth link and profile connection state.\n"+ << " --bt-threads List iPhone message conversations.\n"+ << " --bt-messages <thread> Show messages in one conversation.\n"+ << " --bt-send <thread> <text> Reply in one conversation.\n"+ << " --bt-pair <addr> Pair with an iPhone over Bluetooth.\n"+ << " --bt-unpair <addr> Remove a Bluetooth bond.\n"+ << " --bt-diagnostics Print a redacted Bluetooth report for a bug report.\n"<< " --accept <fingerprint> Accept a pending pairing request locally.\n"<< " --pair Send a pair_request over TCP to the daemon.\n\n"<< "Examples:\n"@@ -116,13 +127,321 @@ void print_help() {<< " tether --accept 9a4f21...\n";}+static int print_bt_status(tether::Client& client) {+ nlohmann::json resp;+ try {+ resp = nlohmann::json::parse(client.send_and_wait("{\"command\":\"bt_status\"}\n"));+ } catch (const std::exception&) {+ debug::log(ERR, "Could not read Bluetooth status from the daemon.\n");+ return 1;+ }++ if (!resp.value("available", false)) {+ fprintf(stdout, "Bluetooth: unavailable (is bluetoothd running?)\n");+ return 1;+ }++ const auto& cap = resp["capability"];+ fprintf(stdout, "Mode: %s\n", cap.value("mode", "unknown").c_str());+ fprintf(stdout, "Bearer API: %s\n", cap.value("bearer_api", "unknown").c_str());+ fprintf(stdout,+ "Adapter: powered=%s central=%s peripheral=%s advertising=%s class=%s\n",+ cap.value("powered", false) ? "yes" : "no",+ cap.value("le_central", false) ? "yes" : "no",+ cap.value("le_peripheral", false) ? "yes" : "no",+ cap.value("advertising", false) ? "yes" : "no",+ cap.value("class_ok", false) ? "ok" : "wrong");++ for (const auto& adapter : resp["adapters"]) {+ fprintf(stdout, " %s %s\n", adapter.value("address", "").c_str(), adapter.value("name", "").c_str());+ }++ if (cap.contains("reasons") && !cap["reasons"].empty()) {+ fprintf(stdout, "\n");+ for (const auto& reason : cap["reasons"])+ fprintf(stdout, " - %s\n", reason.get<std::string>().c_str());+ }+ return 0;+}++static int print_bt_devices(tether::Client& client) {+ nlohmann::json resp;+ try {+ resp = nlohmann::json::parse(client.send_and_wait("{\"command\":\"bt_list_devices\"}\n"));+ } catch (const std::exception&) {+ debug::log(ERR, "Could not read Bluetooth devices from the daemon.\n");+ return 1;+ }++ const auto& devices = resp["devices"];+ if (devices.empty()) {+ fprintf(stdout, "No Bluetooth devices known to BlueZ.\n");+ return 0;+ }++ for (const auto& d : devices) {+ std::string flags;+ auto add = [&flags](const char* name) {+ if (!flags.empty())+ flags += ",";+ flags += name;+ };+ if (d.value("bonded", false))+ add("bonded");+ if (d.value("connected", false))+ add("connected");+ if (d.value("le_connected", false))+ add("le");+ if (d.value("map", false))+ add("map");+ if (d.value("pbap", false))+ add("pbap");+ if (d.value("ancs", false))+ add("ancs");++ fprintf(stdout,+ " %-18s %-24s %s%s\n",+ d.value("address", "").c_str(),+ d.value("name", "").c_str(),+ flags.c_str(),+ d.value("iphone", false) ? " <- iPhone" : "");+ }+ return 0;+}++// Pairing takes tens of seconds and reports progress as it goes, so this+// subscribes and streams events until the terminal result arrives.+static int run_bt_transaction(tether::Client& client, const std::string& command, const std::string& address) {+ const std::string result_command = command == "bt_pair" ? "bt_pair_result" : "bt_unpair_result";++ client.send("{\"command\":\"subscribe\"}\n");+ nlohmann::json request;+ request["command"] = command;+ request["address"] = address;+ if (!client.send(request.dump() + "\n")) {+ debug::log(ERR, "Could not reach the daemon.\n");+ return 1;+ }++ std::string buffer;+ char buf[8192];+ while (true) {+ ssize_t n = client.read(buf, sizeof(buf));+ if (n <= 0) {+ debug::log(ERR, "Daemon closed the connection before the operation finished.\n");+ return 1;+ }+ buffer.append(buf, n);++ size_t pos;+ while ((pos = buffer.find('\n')) != std::string::npos) {+ std::string line = buffer.substr(0, pos);+ buffer.erase(0, pos + 1);+ if (line.empty())+ continue;++ nlohmann::json event;+ try {+ event = nlohmann::json::parse(line);+ } catch (const std::exception&) {+ continue;+ }++ const std::string cmd = event.value("command", "");+ if (cmd == "bt_pair_progress") {+ fprintf(stdout, " %-12s %s\n", event.value("step", "").c_str(), event.value("detail", "").c_str());+ fflush(stdout);+ } else if (cmd == result_command) {+ fprintf(stdout, "\n%s\n", event.value("message", "").c_str());+ return event.value("success", false) ? 0 : 1;+ }+ }+ }+}++static int print_bt_connection(tether::Client& client) {+ nlohmann::json resp;+ try {+ resp = nlohmann::json::parse(client.send_and_wait("{\"command\":\"bt_connection\"}\n"));+ } catch (const std::exception&) {+ debug::log(ERR, "Could not read Bluetooth connection state from the daemon.\n");+ return 1;+ }++ auto yn = [](bool v) { return v ? "yes" : "no"; };+ fprintf(stdout, "Device present: %s\n", yn(resp.value("device_present", false)));+ fprintf(stdout, "BR/EDR: %s\n", yn(resp.value("classic_connected", false)));+ fprintf(stdout,+ "LE: %s%s\n",+ yn(resp.value("le_connected", false)),+ resp.value("le_available", false) ? "" : " (bearer unavailable)");+ fprintf(stdout, "Messages (MAP): %s", yn(resp.value("map_open", false)));+ if (resp.value("map_error", std::string("none")) != "none")+ fprintf(stdout, " [%s]", resp.value("map_error", "").c_str());+ fprintf(stdout, "\nContacts (PBAP): %s", yn(resp.value("pbap_open", false)));+ if (resp.value("pbap_error", std::string("none")) != "none")+ fprintf(stdout, " [%s]", resp.value("pbap_error", "").c_str());+ fprintf(stdout, "\n");++ const std::string link = resp.value("link_reason", "");+ const std::string profiles = resp.value("profile_reason", "");+ if (!link.empty())+ fprintf(stdout, "\n %s\n", link.c_str());+ if (!profiles.empty())+ fprintf(stdout, " %s\n", profiles.c_str());+ return 0;+}++// The daemon redacts; this only formats. Anything printed here is already safe+// to paste into an issue.+static int print_bt_diagnostics(tether::Client& client) {+ nlohmann::json resp;+ try {+ resp = nlohmann::json::parse(client.send_and_wait("{\"command\":\"bt_diagnostics\"}\n"));+ } catch (const std::exception&) {+ debug::log(ERR, "Could not read Bluetooth diagnostics from the daemon.\n");+ return 1;+ }++ fprintf(stdout, "%s\n", resp.dump(2).c_str());+ return 0;+}++static std::string format_time(int64_t epoch) {+ if (epoch <= 0)+ return "";+ std::time_t t = static_cast<std::time_t>(epoch);+ std::tm tm{};+ localtime_r(&t, &tm);+ char buf[32];+ std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M", &tm);+ return buf;+}++static int print_bt_threads(tether::Client& client) {+ nlohmann::json resp;+ try {+ resp = nlohmann::json::parse(client.send_and_wait("{\"command\":\"bt_list_threads\"}\n"));+ } catch (const std::exception&) {+ debug::log(ERR, "Could not read conversations from the daemon.\n");+ return 1;+ }++ const auto& threads = resp["threads"];+ if (threads.empty()) {+ fprintf(stdout, "No conversations yet. Check 'tether --bt-connection'.\n");+ return 0;+ }++ for (const auto& t : threads) {+ const int unread = t.value("unread", 0);+ std::string preview = t.value("preview", "");+ if (preview.size() > 48)+ preview = preview.substr(0, 45) + "...";+ for (char& c : preview)+ if (c == '\n' || c == '\r')+ c = ' ';++ const std::string unread_note = unread > 0 ? " (" + std::to_string(unread) + " unread)" : "";+ fprintf(stdout,+ " %-24s %-18s %s%s\n",+ t.value("name", "").c_str(),+ format_time(t.value("timestamp", (int64_t)0)).c_str(),+ preview.c_str(),+ unread_note.c_str());+ fprintf(stdout, " %s\n", t.value("thread", "").c_str());+ }+ return 0;+}++static int print_bt_messages(tether::Client& client, const std::string& thread) {+ nlohmann::json request;+ request["command"] = "bt_list_messages";+ request["thread"] = thread;++ nlohmann::json resp;+ try {+ resp = nlohmann::json::parse(client.send_and_wait(request.dump() + "\n"));+ } catch (const std::exception&) {+ debug::log(ERR, "Could not read messages from the daemon.\n");+ return 1;+ }++ const auto& messages = resp["messages"];+ if (messages.empty()) {+ fprintf(stdout, "No messages in %s\n", thread.c_str());+ return 0;+ }++ for (const auto& m : messages) {+ fprintf(stdout,+ "%s %-8s %s%s\n",+ format_time(m.value("timestamp", (int64_t)0)).c_str(),+ m.value("outgoing", false) ? "me" : "them",+ m.value("body", "").c_str(),+ m.value("read", true) ? "" : " *");+ }+ return 0;+}++static int send_bt_message(tether::Client& client, const std::string& thread, const std::string& body) {+ nlohmann::json request;+ request["command"] = "bt_send_message";+ request["thread"] = thread;+ request["body"] = body;++ // The daemon answers asynchronously once the phone has accepted or refused+ // the message, so the result arrives on the event stream rather than as a+ // reply to the request.+ client.send("{\"command\":\"subscribe\"}\n");+ if (!client.send(request.dump() + "\n")) {+ debug::log(ERR, "Could not reach the daemon.\n");+ return 1;+ }++ std::string buffer;+ char buf[8192];+ while (true) {+ ssize_t n = client.read(buf, sizeof(buf));+ if (n <= 0) {+ debug::log(ERR, "Daemon closed the connection before the message was sent.\n");+ return 1;+ }+ buffer.append(buf, n);++ size_t pos;+ while ((pos = buffer.find('\n')) != std::string::npos) {+ std::string line = buffer.substr(0, pos);+ buffer.erase(0, pos + 1);+ if (line.empty())+ continue;++ nlohmann::json event;+ try {+ event = nlohmann::json::parse(line);+ } catch (const std::exception&) {+ continue;+ }++ if (event.value("command", "") != "bt_send_result")+ continue;+ if (event.value("success", false)) {+ fprintf(stdout, "Sent to %s\n", thread.c_str());+ return 0;+ }+ debug::log(ERR, "{}\n", event.value("message", "The message was not sent."));+ return 1;+ }+ }+}+int main(int argc, char* argv[]) {if (argc < 2) {print_help();return 0;}- std::string action, arg_val, host = "";+ std::string action, arg_val, arg_val2, host = "";int port = 5134;int timeout_ms = 3000;@@ -137,6 +456,34 @@ int main(int argc, char* argv[]) {action = "discover";} else if (arg == "--list-devices") {action = "list";+ } else if (arg == "--bt-status") {+ action = "bt_status";+ } else if (arg == "--bt-devices") {+ action = "bt_devices";+ } else if (arg == "--bt-connection") {+ action = "bt_connection";+ } else if (arg == "--bt-diagnostics") {+ action = "bt_diagnostics";+ } else if (arg == "--bt-threads") {+ action = "bt_threads";+ } else if (arg == "--bt-messages") {+ action = "bt_messages";+ if (i + 1 < argc && argv[i + 1][0] != '-')+ arg_val = argv[++i];+ } else if (arg == "--bt-send") {+ action = "bt_send";+ if (i + 1 < argc && argv[i + 1][0] != '-')+ arg_val = argv[++i];+ if (i + 1 < argc)+ arg_val2 = argv[++i];+ } else if (arg == "--bt-pair") {+ action = "bt_pair";+ if (i + 1 < argc && argv[i + 1][0] != '-')+ arg_val = argv[++i];+ } else if (arg == "--bt-unpair") {+ action = "bt_unpair";+ if (i + 1 < argc && argv[i + 1][0] != '-')+ arg_val = argv[++i];} else if (arg == "--pair") {action = "pair";} else if (arg == "--accept") {@@ -255,6 +602,34 @@ int main(int argc, char* argv[]) {debug::log(INFO, "File transfer delivered.\n");} else if (action == "native") {run_native_messaging_host(client);+ } else if (action == "bt_status") {+ return print_bt_status(client);+ } else if (action == "bt_devices") {+ return print_bt_devices(client);+ } else if (action == "bt_connection") {+ return print_bt_connection(client);+ } else if (action == "bt_diagnostics") {+ return print_bt_diagnostics(client);+ } else if (action == "bt_threads") {+ return print_bt_threads(client);+ } else if (action == "bt_messages") {+ if (arg_val.empty()) {+ debug::log(ERR, "A thread key is required, e.g. --bt-messages tel:+15551234567\n");+ return 1;+ }+ return print_bt_messages(client, arg_val);+ } else if (action == "bt_send") {+ if (arg_val.empty() || arg_val2.empty()) {+ debug::log(ERR, "A conversation and a message are required, e.g. --bt-send tel:+15551234567 \"hi\"\n");+ return 1;+ }+ return send_bt_message(client, arg_val, arg_val2);+ } else if (action == "bt_pair" || action == "bt_unpair") {+ if (arg_val.empty()) {+ debug::log(ERR, "A Bluetooth address is required, e.g. --bt-pair AA:BB:CC:DD:EE:FF\n");+ return 1;+ }+ return run_bt_transaction(client, action == "bt_pair" ? "bt_pair" : "bt_unpair", arg_val);}return 0;diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txtindex 247bc47..d137478 100644--- a/src/core/CMakeLists.txt+++ b/src/core/CMakeLists.txt@@ -9,6 +9,29 @@ add_library(tether STATICsrc/crypto.cppsrc/client.cppsrc/discovery.cpp+ src/bluetooth/objects.cpp+ src/bluetooth/monitor.cpp+ src/bluetooth/config.cpp+ src/bluetooth/agent.cpp+ src/bluetooth/advert.cpp+ src/bluetooth/pairing.cpp+ src/bluetooth/bearer_supervisor.cpp+ src/bluetooth/profile_supervisor.cpp+ src/bluetooth/vcard.cpp+ src/bluetooth/bmessage.cpp+ src/bluetooth/messages.cpp+ src/bluetooth/map_session.cpp+ src/bluetooth/contacts.cpp+ src/bluetooth/journal.cpp+ src/bluetooth/pbap_session.cpp+ src/bluetooth/obex_transfer.cpp+ src/bluetooth/ancs/parser.cpp+ src/bluetooth/ancs/notifications.cpp+ src/bluetooth/ancs/sequencer.cpp+ src/bluetooth/ancs/client.cpp+ src/bluetooth/groups.cpp+ src/bluetooth/connection.cpp+ src/bluetooth/diagnostics.cppsrc/wayland.cppsrc/wayland_protocols/wayland.cppsrc/wayland_protocols/wlr-data-control-unstable-v1.cppdiff --git a/src/core/include/tether/bluetooth/advert.hpp b/src/core/include/tether/bluetooth/advert.hppnew file mode 100644index 0000000..71d6d01--- /dev/null+++ b/src/core/include/tether/bluetooth/advert.hpp@@ -0,0 +1,32 @@+#pragma once++#include <gio/gio.h>+#include <memory>+#include <string>++namespace tether::bluetooth {++ struct AdvertState;++ // Broadcasts an LE advertisement soliciting the ANCS service.+ class AncsAdvertisement {+ public:+ AncsAdvertisement(GDBusConnection* connection, std::string adapter_path);+ ~AncsAdvertisement();++ AncsAdvertisement(const AncsAdvertisement&) = delete;+ AncsAdvertisement& operator=(const AncsAdvertisement&) = delete;++ // Registration is two-phase, and the phases must run on different threads.+ bool export_object();+ bool register_with_bluez();+ void unregister_with_bluez();+ void unexport_object();++ bool active() const;++ private:+ std::unique_ptr<AdvertState> state_;+ };++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/agent.hpp b/src/core/include/tether/bluetooth/agent.hppnew file mode 100644index 0000000..460c692--- /dev/null+++ b/src/core/include/tether/bluetooth/agent.hpp@@ -0,0 +1,57 @@+#pragma once++#include <functional>+#include <gio/gio.h>+#include <memory>+#include <string>++namespace tether::bluetooth {++ // Services Tether uses. Anything else the phone asks us to authorize during+ // pairing is refused: an accessory should not be granted profiles it has no+ // reason to consume.+ // 0x112E PBAP client, 0x112F PBAP server,+ // 0x1132 MAP server, 0x1133 MAP notification server, 0x1134 MAP client+ bool is_authorized_service(const std::string& uuid);++ // BlueZ hands passkeys over as a plain integer; Apple shows six digits with+ // leading zeros, and a mismatch here reads to the user as a failed pairing.+ std::string format_passkey(uint32_t passkey);++ struct AgentState;++ // Implements org.bluez.Agent1 for exactly one device.+ //+ // Numeric comparison only: this agent never invents, displays, or accepts a+ // PIN or passkey, and it refuses every request naming a device other than its+ // target. Confirmation is delegated to the out-of-process dialog so the+ // daemon never blocks on a user decision.+ class PairingAgent {+ public:+ // Called with the six-digit comparison code; returns true to accept.+ // Runs on the thread dispatching the agent's callbacks and may block+ // while the user decides, stalls BlueZ monitoring for the duration+ // of the prompt, which is harmless during a foreground pairing.+ using ConfirmHandler = std::function<bool(const std::string& code)>;++ PairingAgent(GDBusConnection* connection, std::string device_path, ConfirmHandler on_confirm);+ ~PairingAgent();++ PairingAgent(const PairingAgent&) = delete;+ PairingAgent& operator=(const PairingAgent&) = delete;++ // Two-phase, and the phases must run on different threads+ // export_object() binds callbacks to the calling thread's context+ // register_with_bluez() blocks on BlueZ and so must not run on that same thread.+ bool export_object();+ bool register_with_bluez();+ void unregister_with_bluez();+ void unexport_object();++ const std::string& path() const;++ private:+ std::unique_ptr<AgentState> state_;+ };++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/ancs/client.hpp b/src/core/include/tether/bluetooth/ancs/client.hppnew file mode 100644index 0000000..8831258--- /dev/null+++ b/src/core/include/tether/bluetooth/ancs/client.hpp@@ -0,0 +1,61 @@+#pragma once++#include "tether/bluetooth/ancs/notifications.hpp"++#include <functional>+#include <memory>+#include <string>++namespace tether::bluetooth {+ class BluezMonitor;+}++namespace tether::bluetooth::ancs {++ // How often to retry discovery, subscription and the readiness probe.+ inline constexpr int ANCS_RETRY_SECONDS = 5;++ // Defined in client.cpp.+ struct AncsClientState;++ // GATT client for Apple's notification service.+ //+ // Everything here is driven from one thread by tick(). BlueZ delivers+ // characteristic values on the GLib thread, which only buffers the bytes;+ // the sequencer and all D-Bus writes stay on the caller's thread, so no ANCS+ // state is touched from two places at once.+ class AncsClient {+ public:+ using NotificationFn = std::function<void(const Notification&)>;+ using WithdrawFn = std::function<void(uint32_t uid)>;+ // Reported when readiness changes; `reason` is shown to the user.+ using StatusFn = std::function<void(bool ready, const std::string& reason)>;++ AncsClient(BluezMonitor& monitor, NotificationFn on_notification, WithdrawFn on_withdraw, StatusFn on_status);+ ~AncsClient();++ AncsClient(const AncsClient&) = delete;+ AncsClient& operator=(const AncsClient&) = delete;++ // The BlueZ object path of the connected iPhone, or empty when LE drops.+ void set_device(const std::string& device_path);++ // Whether to ask for notification contents or only which app sent them.+ void set_content_enabled(bool enabled);++ void tick(int64_t now);++ bool ready() const;+ const std::string& status_reason() const;++ // Invokes a notification's positive or negative action. ANCS offers only+ // these two — there is no free-text reply.+ bool perform_action(uint32_t uid, ActionId action);++ const NotificationRegistry& registry() const;++ private:+ std::unique_ptr<AncsClientState> state_;+ };++} // namespace tether::bluetooth::ancsdiff --git a/src/core/include/tether/bluetooth/ancs/notifications.hpp b/src/core/include/tether/bluetooth/ancs/notifications.hppnew file mode 100644index 0000000..2c846af--- /dev/null+++ b/src/core/include/tether/bluetooth/ancs/notifications.hpp@@ -0,0 +1,74 @@+#pragma once++#include "tether/bluetooth/ancs/protocol.hpp"++#include <cstdint>+#include <map>+#include <nlohmann/json.hpp>+#include <string>+#include <vector>++namespace tether::bluetooth::ancs {++ // A mirrored notification, as far as it has been resolved.+ struct Notification {+ uint32_t uid = 0;+ std::string app_id;+ // The app's display name once resolved; falls back to the identifier.+ std::string app_name;+ std::string title;+ std::string subtitle;+ std::string body;+ CategoryId category = CategoryId::Other;+ int64_t received = 0;+ bool silent = false;+ bool has_positive_action = false;+ bool has_negative_action = false;++ bool operator==(const Notification&) const = default;+ };++ // Whether a Source event should be resolved and shown.+ enum class Decision {+ Fetch, // new or genuinely updated: ask for its attributes+ Ignore, // a replay, or something deliberately not mirrored+ Withdraw // removed on the phone: drop the desktop copy+ };++ // Applies the delivery rules that keep the desktop from being flooded.+ //+ // iOS replays every existing notification whenever the subscription comes+ // up, so the same notification arrives again after each reconnect. Dedupe is+ // on the notification UID, but a Modified event is a genuine update the user+ // should see, so it is never suppressed by having seen the UID before.+ class NotificationRegistry {+ public:+ // `initial` marks the first subscription of a session, where+ // pre-existing notifications are the phone's backlog rather than news.+ Decision classify(const SourceEvent& event, bool initial) const;++ void remember(const SourceEvent& event);+ void forget(uint32_t uid);+ void clear();++ void store(const Notification& notification);+ const Notification* find(uint32_t uid) const;+ // Newest first.+ std::vector<Notification> recent(size_t limit = 50) const;++ size_t size() const { return notifications_.size(); }++ private:+ // UIDs seen this session, to recognize a replay.+ std::map<uint32_t, int64_t> seen_;+ std::map<uint32_t, Notification> notifications_;+ std::vector<uint32_t> order_;+ };++ // Messages arrive over MAP already, with read state that stays in sync. The+ // ANCS copy is kept for correlation but must never raise a second popup.+ bool should_show_desktop_popup(const Notification& notification);++ nlohmann::json to_json(const Notification& notification);++} // namespace tether::bluetooth::ancsdiff --git a/src/core/include/tether/bluetooth/ancs/parser.hpp b/src/core/include/tether/bluetooth/ancs/parser.hppnew file mode 100644index 0000000..02f60a6--- /dev/null+++ b/src/core/include/tether/bluetooth/ancs/parser.hpp@@ -0,0 +1,55 @@+#pragma once++#include "tether/bluetooth/ancs/protocol.hpp"++#include <cstddef>+#include <cstdint>+#include <string>+#include <vector>++namespace tether::bluetooth::ancs {++ // No attribute we ask for can legitimately be this large; anything claiming+ // more is malformed or hostile and the response is dropped.+ inline constexpr uint16_t MAX_ATTRIBUTE_LENGTH = 1024;+ // Hard ceiling on one reassembled response, so a peer cannot make us buffer+ // without bound by never completing one.+ inline constexpr size_t MAX_RESPONSE_BYTES = 4096;++ // Parses one Notification Source packet. Returns false unless the packet is+ // exactly the eight bytes the specification defines — a short read here+ // would otherwise be interpreted as a different notification.+ bool parse_source_event(const uint8_t* data, size_t length, SourceEvent& out);++ // Reassembles a Data Source response.+ //+ // Data Source responses carry no total length and arrive split across GATT+ // notifications, so the only way to know a response has ended is to know+ // exactly what was asked for: the echoed command byte plus the attribute+ // sequence of the request in flight. That is why the sequencer allows only+ // one request at a time.+ class DataSourceAssembler {+ public:+ enum class Result { NeedMore, Complete, Error };++ // Declares the request whose response is now expected. Resets any+ // partial buffer, since a new request invalidates it.+ void expect(CommandId command, std::vector<uint8_t> attribute_ids);+ void reset();+ bool expecting() const { return expecting_; }++ // Feeds one fragment. On Complete, `out` holds the response and the+ // assembler is ready for the next request. On Error the buffer is+ // dropped: a response that cannot be trusted must not be half-applied.+ Result append(const uint8_t* data, size_t length, Response& out, std::string& err);++ private:+ Result parse(Response& out, std::string& err);++ bool expecting_ = false;+ CommandId command_ = CommandId::GetNotificationAttributes;+ std::vector<uint8_t> attribute_ids_;+ std::vector<uint8_t> buffer_;+ };++} // namespace tether::bluetooth::ancsdiff --git a/src/core/include/tether/bluetooth/ancs/protocol.hpp b/src/core/include/tether/bluetooth/ancs/protocol.hppnew file mode 100644index 0000000..67ede61--- /dev/null+++ b/src/core/include/tether/bluetooth/ancs/protocol.hpp@@ -0,0 +1,119 @@+#pragma once++#include <cstdint>+#include <string>+#include <vector>++// Apple Notification Center Service. Constants and wire types from Apple's+// published ANCS specification.+namespace tether::bluetooth::ancs {++ inline constexpr const char* UUID_SERVICE = "7905f431-b5ce-4e99-a40f-4b1e122d00d0";+ inline constexpr const char* UUID_NOTIFICATION_SOURCE = "9fbf120d-6301-42d9-8c58-25e699a21dbd";+ inline constexpr const char* UUID_CONTROL_POINT = "69d1d8f3-45e1-49a8-9821-9bbdfdaad9d9";+ inline constexpr const char* UUID_DATA_SOURCE = "22eac6e9-24d6-4bb5-be44-b36ace7c7bfb";++ // Messages already arrive over MAP with proper read-state sync, so ANCS+ // copies of them must never produce a second desktop popup.+ inline constexpr const char* APP_ID_MESSAGES = "com.apple.MobileSMS";++ enum class EventId : uint8_t { Added = 0, Modified = 1, Removed = 2 };++ enum EventFlags : uint8_t {+ FlagSilent = 1 << 0,+ FlagImportant = 1 << 1,+ // Set on notifications that were already on the phone when we+ // subscribed. Delivering these would replay the lock screen as a burst+ // of desktop popups.+ FlagPreExisting = 1 << 2,+ FlagPositiveAction = 1 << 3,+ FlagNegativeAction = 1 << 4,+ };++ enum class CategoryId : uint8_t {+ Other = 0,+ IncomingCall = 1,+ MissedCall = 2,+ Voicemail = 3,+ Social = 4,+ Schedule = 5,+ Email = 6,+ News = 7,+ HealthAndFitness = 8,+ BusinessAndFinance = 9,+ Location = 10,+ Entertainment = 11,+ };++ enum class CommandId : uint8_t {+ GetNotificationAttributes = 0,+ GetAppAttributes = 1,+ PerformNotificationAction = 2,+ };++ enum class NotificationAttributeId : uint8_t {+ AppIdentifier = 0,+ Title = 1,+ Subtitle = 2,+ Message = 3,+ MessageSize = 4,+ Date = 5,+ PositiveActionLabel = 6,+ NegativeActionLabel = 7,+ };++ enum class AppAttributeId : uint8_t { DisplayName = 0 };++ enum class ActionId : uint8_t { Positive = 0, Negative = 1 };++ // Title, Subtitle and Message are the only attributes that take a maximum+ // length, and it is mandatory for them.+ inline constexpr bool attribute_takes_length(NotificationAttributeId id) {+ return id == NotificationAttributeId::Title || id == NotificationAttributeId::Subtitle ||+ id == NotificationAttributeId::Message;+ }++ // Bodies are capped rather than requested whole. The cap also fixes the+ // prefix that Phase 9 correlates a group message against.+ inline constexpr uint16_t MAX_BODY_LENGTH = 256;+ inline constexpr uint16_t MAX_TITLE_LENGTH = 128;++ // One Notification Source packet, which is always exactly eight bytes.+ struct SourceEvent {+ EventId event = EventId::Added;+ uint8_t flags = 0;+ CategoryId category = CategoryId::Other;+ uint8_t category_count = 0;+ uint32_t uid = 0;++ bool pre_existing() const { return (flags & FlagPreExisting) != 0; }+ bool silent() const { return (flags & FlagSilent) != 0; }+ bool has_positive_action() const { return (flags & FlagPositiveAction) != 0; }+ bool has_negative_action() const { return (flags & FlagNegativeAction) != 0; }++ bool operator==(const SourceEvent&) const = default;+ };++ struct Attribute {+ uint8_t id = 0;+ std::string value;++ bool operator==(const Attribute&) const = default;+ };++ // A reassembled Data Source response.+ struct Response {+ CommandId command = CommandId::GetNotificationAttributes;+ // Set for GetNotificationAttributes.+ uint32_t uid = 0;+ // Set for GetAppAttributes.+ std::string app_id;+ std::vector<Attribute> attributes;++ // Empty when the attribute was absent or the phone withheld it.+ std::string attribute(uint8_t id) const;++ bool operator==(const Response&) const = default;+ };++} // namespace tether::bluetooth::ancsdiff --git a/src/core/include/tether/bluetooth/ancs/sequencer.hpp b/src/core/include/tether/bluetooth/ancs/sequencer.hppnew file mode 100644index 0000000..703fc32--- /dev/null+++ b/src/core/include/tether/bluetooth/ancs/sequencer.hpp@@ -0,0 +1,93 @@+#pragma once++#include "tether/bluetooth/ancs/parser.hpp"++#include <cstdint>+#include <deque>+#include <functional>+#include <string>+#include <vector>++namespace tether::bluetooth::ancs {++ // A response that never arrives must not wedge the queue forever.+ inline constexpr int REQUEST_TIMEOUT_SECONDS = 15;+ // Bounds how much work a burst of notifications can queue up.+ inline constexpr size_t MAX_QUEUED_REQUESTS = 64;++ struct Request {+ CommandId command = CommandId::GetNotificationAttributes;+ // The Control Point payload, already encoded.+ std::vector<uint8_t> payload;+ // The attribute sequence this request asked for, which is the only way+ // to know where its response ends.+ std::vector<uint8_t> attribute_ids;+ // Echoed back to the caller so a completion can be matched to what it+ // was for without ANCS providing any correlation of its own.+ uint32_t uid = 0;+ };++ // Serializes Control Point requests.+ //+ // ANCS responses carry no request identifier, so with two requests in flight+ // there is no way to tell which response belongs to which — the attributes+ // of one notification would be attached to another. Exactly one request is+ // outstanding at a time, and the rest wait in a queue.+ class ControlPointSequencer {+ public:+ // Returns false when the write could not be issued, which fails the+ // request rather than leaving it silently outstanding.+ using WriteFn = std::function<bool(const std::vector<uint8_t>&)>;+ using CompleteFn = std::function<void(const Request&, const Response&)>;+ using FailFn = std::function<void(const Request&, const std::string& reason)>;++ ControlPointSequencer(WriteFn write, CompleteFn on_complete, FailFn on_fail);++ // Dropped when the queue is full; a caller cannot make the daemon grow+ // without bound by generating notifications.+ bool submit(Request request);++ // Drive with a monotonic clock. Starts the next request when idle and+ // times out one that has gone unanswered.+ void tick(int64_t now);++ // Feeds a Data Source fragment.+ void on_data_source(const uint8_t* data, size_t length, int64_t now);++ // Clears everything after a disconnect: any outstanding response belongs+ // to a session that no longer exists.+ void reset();++ bool in_flight() const { return in_flight_; }+ size_t queued() const { return queue_.size(); }++ private:+ void start_next(int64_t now);++ WriteFn write_;+ CompleteFn on_complete_;+ FailFn on_fail_;++ std::deque<Request> queue_;+ Request current_;+ bool in_flight_ = false;+ int64_t deadline_ = 0;+ DataSourceAssembler assembler_;+ };++ // --- Request builders ---------------------------------------------------++ // Asks for the attributes of one notification. Title, subtitle and message+ // are length-capped; the caller chooses which attributes to request, because+ // asking for content at all is a privacy decision.+ Request build_notification_request(uint32_t uid, const std::vector<NotificationAttributeId>& attributes);++ // Asks for an app's display name.+ Request build_app_request(const std::string& app_id);++ // Performs a notification's positive or negative action. ANCS offers only+ // these two; there is no free-text reply, so no reply affordance can be+ // built on a mirrored notification.+ Request build_action_request(uint32_t uid, ActionId action);++} // namespace tether::bluetooth::ancsdiff --git a/src/core/include/tether/bluetooth/bearer_supervisor.hpp b/src/core/include/tether/bluetooth/bearer_supervisor.hppnew file mode 100644index 0000000..d379c0f--- /dev/null+++ b/src/core/include/tether/bluetooth/bearer_supervisor.hpp@@ -0,0 +1,71 @@+#pragma once++#include <cstdint>+#include <string>++namespace tether::bluetooth {++ inline constexpr int BEARER_POLL_SECONDS = 5;+ inline constexpr int BEARER_SETTLE_SECONDS = 3;+ inline constexpr int BEARER_BACKOFF_MIN_SECONDS = 5;+ inline constexpr int BEARER_BACKOFF_MAX_SECONDS = 300;++ // The BlueZ operations the supervisor performs.+ class BearerOps {+ public:+ virtual ~BearerOps() = default;++ virtual bool device_present() const = 0;+ virtual bool device_paired() const = 0;+ virtual bool classic_connected() const = 0;+ virtual bool le_bearer_available() const = 0;+ virtual bool le_connected() const = 0;++ virtual void set_preferred_bearer(const std::string& bearer) = 0;++ virtual bool connect_classic(std::string& err) = 0;+ virtual bool connect_le(std::string& err) = 0;+ };++ struct BearerStatus {+ bool device_present = false;+ bool device_paired = false;+ bool classic_connected = false;+ bool le_connected = false;+ bool le_available = false;+ int classic_backoff = 0;+ int le_backoff = 0;+ std::string reason;++ bool operator==(const BearerStatus&) const = default;+ };++ // Keeps the Classic and LE halves of one bond connected.+ //+ // Order is important: BR/EDR first, a settling interval, then LE+ class BearerSupervisor {+ public:+ BearerSupervisor(BearerOps& ops, bool ancs_enabled);++ // Drive once per BEARER_POLL_SECONDS with a monotonic clock. Returns true+ // when the reported status changed, so callers only broadcast on change.+ bool tick(int64_t now);++ // Clears connection state and backoff after a disconnect or a resume, so+ // recovery starts immediately instead of waiting out a stale backoff.+ void reset();++ void set_ancs_enabled(bool enabled);+ const BearerStatus& status() const { return status_; }++ private:+ BearerOps& ops_;+ bool ancs_enabled_ = true;++ BearerStatus status_;+ int64_t classic_connected_since_ = -1;+ int64_t next_classic_attempt_ = 0;+ int64_t next_le_attempt_ = 0;+ };++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/bmessage.hpp b/src/core/include/tether/bluetooth/bmessage.hppnew file mode 100644index 0000000..7910e13--- /dev/null+++ b/src/core/include/tether/bluetooth/bmessage.hpp@@ -0,0 +1,91 @@+#pragma once++#include <cstdint>+#include <string>+#include <vector>++namespace tether::bluetooth {++ // One party in a bMessage, decoded from its embedded vCard.+ //+ // A telephone number in TEL and an AppleID destination in EMAIL;+ // both must be saved, because contacts that exist only as an AppleID have+ // no phone number at all.+ struct VCardParty {+ // Display only.+ std::string name;+ std::string tel;+ std::string email;++ bool empty() const { return tel.empty() && email.empty(); }+ bool operator==(const VCardParty&) const = default;+ };++ struct BMessage {+ bool valid = false;+ // READ or UNREAD as reported by the phone.+ bool read = false;+ // Always SMS_GSM for both SMS and iMessage.+ std::string type;+ std::string folder;+ VCardParty originator;+ std::vector<VCardParty> recipients;+ std::string body;++ bool operator==(const BMessage&) const = default;+ };++ // Tolerant parser: accepts CRLF or LF, missing optional fields, and unknown+ // properties. Returns valid=false rather than throwing on malformed input.+ // This is untrusted data arriving from a phone.+ BMessage parse_bmessage(const std::string& text);++ // Addresses are identity; names are display. These normalizations decide+ // which messages group into one conversation, so they must be stable and+ // must not merge two different people.++ // Strips formatting from a phone number, keeping a leading '+'. Does not+ // invent a country code: "555-1234" stays national, because guessing one+ // could route a reply to a different person.+ std::string normalize_phone(const std::string& raw);++ // Lowercases and trims an email/AppleID address.+ std::string normalize_email(const std::string& raw);++ // The stable key for one conversation.+ std::string thread_key_for(const VCardParty& party);++ // Parses MAP's basic-ISO timestamp (optionally with a trailing offset) into a Unix epoch.+ // Returns 0 when unparseable.+ int64_t parse_map_timestamp(const std::string& text);++ enum class RecipientKind { Tel, Email };++ struct Recipient {+ RecipientKind kind = RecipientKind::Tel;+ std::string address;++ bool operator==(const Recipient&) const = default;+ };++ // Returns false with err_out set when the address must not be used.+ bool validate_recipient(const Recipient& recipient, std::string& err_out);++ // Parses a namespaced thread key ("tel:+15551234567", "email:[email protected]") into a+ // validated recipient. Returns false for unknown prefixes.+ bool recipient_from_thread_key(const std::string& thread_key, Recipient& out, std::string& err_out);++ // MAP byte-stuffing: a body line that would otherwise a structural+ // token is prefixed with a space. Mirrors what the parser undoes, so a body+ // does a round trip unchanged.+ std::string stuff_body(const std::string& body);++ // Builds a MAP 1.4 bMessage for PushMessage. Recipients must already be+ // validated+ //+ // TYPE is always SMS_GSM, including for AppleID recipients: iOS decides+ // between SMS and iMessage itself, and nothing here can force or observe+ // that choice.+ std::string build_bmessage(const std::vector<Recipient>& recipients, const std::string& body);++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/config.hpp b/src/core/include/tether/bluetooth/config.hppnew file mode 100644index 0000000..ebd04c4--- /dev/null+++ b/src/core/include/tether/bluetooth/config.hpp@@ -0,0 +1,47 @@+#pragma once++#include <string>++namespace tether::bluetooth {++ // Which pairing transaction to run.+ //+ // ConnectFirst calls Device1.Connect() on the unpaired device and lets iOS+ // initiate authentication. A Linux-initiated Pair() can+ // yield a BR/EDR-only bond, which can never carry ANCS.+ //+ // ExplicitPair calls Device1.Pair() directly. Some controllers cancel the+ // Connect-first transaction, and headless callers cannot show a confirmation+ // prompt, so it stays available as a workaround.+ enum class AuthStrategy { ConnectFirst, ExplicitPair };++ // Persisted at ~/.config/tether/bluetooth.json.+ struct Config {+ // Address of the selected iPhone, e.g. "81:71:C8:30:6A:F3".+ std::string device_address;+ AuthStrategy auth_strategy = AuthStrategy::ConnectFirst;+ // Cleared when pairing resolves to compatibility mode, so later runs do+ // not keep trying to bring up an LE bearer the phone will not answer.+ bool ancs_enabled = true;+ // Whether to request notification contents rather than only the app+ // they came from. Off by default.+ bool ancs_content_enabled = false;+ // Group replies are off until deliberately enabled+ bool group_messages_enabled = false;++ bool operator==(const Config&) const = default;+ };++ const char* to_string(AuthStrategy strategy);+ AuthStrategy auth_strategy_from_string(const std::string& value);++ std::string config_path();++ Config load_config();+ bool save_config(const Config& config);++ // exposed for tests without touching fs+ std::string serialize_config(const Config& config);+ Config deserialize_config(const std::string& text);++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/connection.hpp b/src/core/include/tether/bluetooth/connection.hppnew file mode 100644index 0000000..729c82c--- /dev/null+++ b/src/core/include/tether/bluetooth/connection.hpp@@ -0,0 +1,92 @@+#pragma once++#include "tether/bluetooth/ancs/notifications.hpp"+#include "tether/bluetooth/bearer_supervisor.hpp"+#include "tether/bluetooth/groups.hpp"+#include "tether/bluetooth/messages.hpp"+#include "tether/bluetooth/profile_supervisor.hpp"++#include <functional>+#include <memory>+#include <mutex>+#include <nlohmann/json.hpp>+#include <string>++namespace tether::bluetooth {++ class BluezMonitor;++ struct ConnectionState;++ // Drives the bearer and profile supervisors against the real BlueZ and obexd,+ // on its own thread, for the daemon's lifetime.+ class ConnectionManager {+ public:+ // Reports a combined status whenever it changes.+ using StatusFn = std::function<void(const nlohmann::json&)>;+ // Called once per newly seen message. `backfill` marks the first listing+ // after a MAP session opens (phone's existing inbox), so they belong in the UI but must not each do desktop+ // notification.+ using MessageFn = std::function<void(const Message& message, bool backfill)>;+ // Called once per mirrored notification, and when one is dismissed on+ // the phone.+ using NotificationFn = std::function<void(const ancs::Notification&)>;+ using WithdrawFn = std::function<void(uint32_t uid)>;++ ConnectionManager(BluezMonitor& monitor, StatusFn on_change, MessageFn on_message = {});++ // Enables notification mirroring. Without a handler the ANCS client is+ // never started, so a caller that cannot show notifications does not pay+ // for a GATT session it will not use.+ void set_notification_handlers(NotificationFn on_notification, WithdrawFn on_withdraw);++ // Invokes a mirrored notification's action.+ bool perform_notification_action(uint32_t uid, ancs::ActionId action);++ nlohmann::json notifications(size_t limit = 50) const;+ ~ConnectionManager();++ ConnectionManager(const ConnectionManager&) = delete;+ ConnectionManager& operator=(const ConnectionManager&) = delete;++ // address is the bonded iPhone; empty disables supervision until set.+ bool start(const std::string& address, bool ancs_enabled);+ void stop();++ void set_device(const std::string& address, bool ancs_enabled);++ nlohmann::json status() const;++ private:+ std::unique_ptr<ConnectionState> state_;+ };++ nlohmann::json to_json(const BearerStatus& bearer, const ProfileStatus& profiles);++ // Conversation history for the selected iPhone.+ MessageStore& message_store();+ std::mutex& message_store_mutex();++ // Marks a message read on the phone as well as locally. Returns false with+ // err_out set when MAP is not currently open.+ bool mark_message_read(const std::string& handle, bool read, std::string& err_out);++ // Sends a reply to a one-to-one conversation. Returns false with err_out set+ // when MAP is down, the thread cannot be replied to, or the phone refused.+ bool send_message(const std::string& thread_key, const std::string& body, Message& sent_out, std::string& err_out);++ // Feeds the group correlator with an Apple Messages notification.+ void observe_message_notification(const std::string& sender,+ const std::string& subtitle,+ const std::string& body,+ int64_t now);++ // Why a group thread can or cannot be replied to, for the UI to show.+ ReplyEligibility group_reply_status(const std::string& thread_key, std::string& reason);++ void set_group_replies_enabled(bool enabled);+ void reload_group_rosters();++ extern ConnectionManager* g_bt_connections;++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/contacts.hpp b/src/core/include/tether/bluetooth/contacts.hppnew file mode 100644index 0000000..f0f3fe1--- /dev/null+++ b/src/core/include/tether/bluetooth/contacts.hpp@@ -0,0 +1,45 @@+#pragma once++#include "tether/bluetooth/vcard.hpp"++#include <map>+#include <nlohmann/json.hpp>+#include <string>+#include <vector>++namespace tether::bluetooth {++ // Resolves a thread key to a display name.+ class ContactStore {+ public:+ void set(std::vector<VCard> contacts);++ // Empty when the address is unknown. Keys are the same namespaced form+ // messages use, e.g. "tel:+15551234567" or "email:[email protected]".+ std::string name_for(const std::string& thread_key) const;++ // Every address a display name maps to. Returns all matches.+ std::vector<std::string> addresses_for_name(const std::string& name) const;++ size_t size() const { return contacts_.size(); }+ size_t indexed() const { return by_key_.size(); }+ const std::vector<VCard>& contacts() const { return contacts_; }++ private:+ std::vector<VCard> contacts_;+ std::map<std::string, std::string> by_key_;+ };++ // Cached at ~/.local/share/tether/contacts.json so names survive a restart+ // and are available before PBAP reconnects.+ std::string contacts_path();+ bool save_contacts(const ContactStore& store);+ ContactStore load_contacts();++ std::string serialize_contacts(const ContactStore& store);+ ContactStore deserialize_contacts(const std::string& text);++ // Set by the daemon; command handlers read it to label threads.+ ContactStore& contact_store();++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/diagnostics.hpp b/src/core/include/tether/bluetooth/diagnostics.hppnew file mode 100644index 0000000..f4b330d--- /dev/null+++ b/src/core/include/tether/bluetooth/diagnostics.hpp@@ -0,0 +1,40 @@+#pragma once++#include <map>+#include <nlohmann/json.hpp>+#include <string>++namespace tether::bluetooth {++ // Removes identifying values from text destined for a bug report: Bluetooth+ // addresses (bare, or spelled as a D-Bus device node), phone numbers, email+ // addresses, and the user's home and runtime directories.+ class Redactor {+ public:+ std::string text(const std::string& in);++ // Recursively redacts strings+ nlohmann::json value(const nlohmann::json& in);++ private:+ std::string placeholder(const std::string& kind, const std::string& key);++ std::map<std::string, std::string> assigned_;+ };++ // True for keys whose values are personal content and must never appear in+ // a report.+ bool is_content_key(const std::string& key);++ // Appends a daemon event to the bounded diagnostic timeline, stamped with+ // milliseconds since the first recorded event.+ void record_diagnostic_event(const nlohmann::json& event);++ // Oldest first+ nlohmann::json diagnostic_timeline();+ void clear_diagnostic_timeline();++ // Assembles a redacted report from the caller's live status payloads.+ nlohmann::json build_diagnostics(const nlohmann::json& status, const nlohmann::json& connection);++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/groups.hpp b/src/core/include/tether/bluetooth/groups.hppnew file mode 100644index 0000000..9b34ae5--- /dev/null+++ b/src/core/include/tether/bluetooth/groups.hpp@@ -0,0 +1,116 @@+#pragma once++#include "tether/bluetooth/bmessage.hpp"+#include "tether/bluetooth/contacts.hpp"++#include <cstdint>+#include <map>+#include <string>+#include <vector>++namespace tether::bluetooth {++ inline constexpr int GROUP_CORRELATION_WINDOW_SECONDS = 30;++ // What the Messages notification revealed about a conversation.+ struct GroupInfo {+ bool is_group = false;+ // when the group has a name+ bool named = false;+ std::string name;+ // display names parsed from an unnamed group's subtitle, excluding the user.+ std::vector<std::string> participants;+ // Display only. Never part of thread identity or reply routing.+ std::string sender;++ bool operator==(const GroupInfo&) const = default;+ };++ // Parses a Messages notification into group information.+ //+ // An unnamed group's subtitle is like "To you & Alice", with further+ // names separated by commas or ampersands. Anything else is treated as a+ // group name. Returns false when the notification describes a one-to-one+ // conversation, which has no subtitle of either.+ bool parse_group_notification(const std::string& title, const std::string& subtitle, GroupInfo& out);++ // The local thread key for a group.+ std::string group_thread_key(const GroupInfo& info);++ // One observed Apple Messages notification+ struct MessageNotification {+ std::string sender;+ std::string subtitle;+ std::string body;+ int64_t received = 0;+ };++ enum class Correlation {+ Matched,+ NoMatch,+ Ambiguous,+ };++ // Matches arriving MAP messages against recent Messages notifications.+ class GroupCorrelator {+ public:+ void observe(const MessageNotification& notification);+ void expire(int64_t now);+ void clear();++ Correlation correlate(const std::string& body, int64_t now, GroupInfo& out) const;++ size_t size() const { return recent_.size(); }++ private:+ std::vector<MessageNotification> recent_;+ };++ // Why a group cannot be replied to+ enum class ReplyEligibility {+ Allowed,+ // Group messaging is switched off.+ Disabled,+ // A named group with no user-supplied roster.+ NeedsRoster,+ // A participant name matched no contact, or more than one.+ Unresolved,+ // A sender appeared who is not in the known member set.+ RouteInvalidated,+ };++ const char* to_string(ReplyEligibility eligibility);++ // Rosters the user supplies for named groups, keyed by thread key.+ class GroupRoster {+ public:+ void set(const std::string& thread_key, std::vector<std::string> addresses);+ const std::vector<std::string>* find(const std::string& thread_key) const;+ bool empty() const { return rosters_.empty(); }++ std::string serialize() const;+ static GroupRoster deserialize(const std::string& text);++ private:+ std::map<std::string, std::vector<std::string>> rosters_;+ };++ std::string roster_path();+ GroupRoster load_rosters();+ bool save_rosters(const GroupRoster& roster);++ // Resolves who a group reply would actually go to.+ // Every participant name must resolve to exactly one address. A name that+ // matches several contacts is refused rather than guessed.+ ReplyEligibility resolve_group_recipients(const GroupInfo& info,+ const std::string& thread_key,+ const ContactStore& contacts,+ const GroupRoster& rosters,+ bool group_replies_enabled,+ std::vector<Recipient>& out,+ std::string& reason);++ // True when `sender` is not among the addresses a reply would be sent to.+ bool sender_invalidates_route(const std::string& sender_address, const std::vector<Recipient>& recipients);++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/journal.hpp b/src/core/include/tether/bluetooth/journal.hppnew file mode 100644index 0000000..80c9c6d--- /dev/null+++ b/src/core/include/tether/bluetooth/journal.hpp@@ -0,0 +1,47 @@+#pragma once++#include "tether/bluetooth/messages.hpp"++#include <cstdint>+#include <fstream>+#include <string>+#include <vector>++namespace tether::bluetooth {++ inline constexpr size_t JOURNAL_MAX_MESSAGES = 10000;+ inline constexpr int64_t JOURNAL_MAX_AGE_SECONDS = 90LL * 24 * 3600;++ std::string journal_path();++ // Append-only newline-delimited JSON at ~/.local/share/tether/messages.ndjson.+ class MessageJournal {+ public:+ // Creates the directory and opens the file for appending, mode 0600+ bool open();+ bool is_open() const { return out_.is_open(); }+ void close();++ void append(const Message& message);++ // Malformed lines are skipped rather than aborting the load+ std::vector<Message> load(int64_t now) const;++ // Rewrites the file to exactly `messages`, atomically.+ bool compact(const std::vector<Message>& messages);++ private:+ std::ofstream out_;+ std::string path_;+ };++ std::string serialize_message_line(const Message& message);+ bool deserialize_message_line(const std::string& line, Message& out);++ // Drops anything older than max_age, then keeps the newest max_messages.+ std::vector<Message> apply_retention(std::vector<Message> messages,+ int64_t now,+ size_t max_messages = JOURNAL_MAX_MESSAGES,+ int64_t max_age = JOURNAL_MAX_AGE_SECONDS);++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/map_session.hpp b/src/core/include/tether/bluetooth/map_session.hppnew file mode 100644index 0000000..84c2fe6--- /dev/null+++ b/src/core/include/tether/bluetooth/map_session.hpp@@ -0,0 +1,73 @@+#pragma once++#include "tether/bluetooth/messages.hpp"++#include <functional>+#include <gio/gio.h>+#include <memory>+#include <string>+#include <vector>++namespace tether::bluetooth {++ // One entry from MessageAccess1.ListMessages.+ struct MapListing {+ std::string handle;+ std::string subject;+ std::string sender_address;+ std::string sender_name;+ std::string timestamp;+ std::string type;+ std::string folder;+ bool read = false;+ bool sent = false;+ };++ // Converts a listing into a Message without a bMessage round trip.+ Message message_from_listing(const MapListing& listing);++ // Extracts the stable message id from an obexd object path. The path's+ // session number changes on every reconnect, so only the id can be used to+ // recognize a message we already have.+ std::string map_handle_from_path(const std::string& object_path);++ struct MapSessionState;++ // Drives org.bluez.obex.MessageAccess1 for one open OBEX session.+ class MapSession {+ public:+ // Called for each new or updated message.+ using MessageFn = std::function<void(const Message&)>;++ MapSession(GDBusConnection* session_bus, std::string session_path);+ ~MapSession();++ MapSession(const MapSession&) = delete;+ MapSession& operator=(const MapSession&) = delete;++ // Selects a MAP folder. SetFolder walks the hierarchy from the session+ // root, so this takes a path like "telecom/msg/inbox"+ bool set_folder(const std::string& folder, std::string& err);++ // Lists the current folder. `max` bounds the transfer+ std::vector<MapListing> list_messages(const std::string& folder, int max, std::string& err);++ // Fetches and parses the full bMessage for one handle+ bool fetch_bmessage(const std::string& message_path, BMessage& out, std::string& err);++ // Writes Message1.Read, which is reflected on the phone.+ bool set_read(const std::string& message_path, bool read, std::string& err);++ // Hands a built bMessage to the phone for delivery. `folder` is a MAP+ // path such as "telecom/msg/outbox".+ //+ // Success means the phone accepted the message, not that it was delivered.+ bool push_message(const std::string& folder, const std::string& bmessage, std::string& err);++ const std::string& path() const;++ private:+ std::unique_ptr<MapSessionState> state_;+ };++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/messages.hpp b/src/core/include/tether/bluetooth/messages.hppnew file mode 100644index 0000000..46fa556--- /dev/null+++ b/src/core/include/tether/bluetooth/messages.hpp@@ -0,0 +1,79 @@+#pragma once++#include "tether/bluetooth/bmessage.hpp"++#include <cstdint>+#include <map>+#include <nlohmann/json.hpp>+#include <string>+#include <vector>++namespace tether::bluetooth {++ struct Message {+ std::string handle;+ std::string object_path;+ std::string thread_key;+ std::string peer_address;+ // display only+ std::string peer_name;+ std::string body;+ int64_t timestamp = 0;+ bool outgoing = false;+ bool read = false;+ std::string folder;++ bool operator==(const Message&) const = default;+ };++ struct Thread {+ std::string key;+ // best display name seen for this peer, falling back to the address.+ std::string display_name;+ std::string peer_address;+ std::string last_body;+ int64_t last_timestamp = 0;+ int unread = 0;+ int count = 0;+ };++ // In-memory conversation store: dedupes by handle, groups into threads, and+ // tracks read state.+ class MessageStore {+ public:+ explicit MessageStore(size_t max_messages = 10000);++ // Returns false when the handle was already known, so callers can avoid+ // re-announcing a message the phone replayed.+ bool add(const Message& message);++ // Returns false when the handle is unknown or the state already matched,+ // so an echo of our own change does not loop.+ bool set_read(const std::string& handle, bool read);++ const Message* find(const std::string& handle) const;++ // Newest activity first.+ std::vector<Thread> threads() const;+ // Oldest first within a thread, limited to the most recent `limit`.+ std::vector<Message> messages(const std::string& thread_key, size_t limit = 200) const;++ size_t size() const { return by_handle_.size(); }++ private:+ void trim();++ size_t max_messages_;+ std::map<std::string, Message> by_handle_;+ // Insertion order, used to evict the oldest when the cap is reached.+ std::vector<std::string> order_;+ };++ nlohmann::json to_json(const Message& message);+ nlohmann::json to_json(const Thread& thread);++ // Builds a Message from a parsed bMessage plus the metadata MAP supplies+ // alongside it. `handle` and `folder` come from the MAP listing.+ Message message_from_bmessage(const BMessage& parsed, const std::string& handle, int64_t timestamp);++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/monitor.hpp b/src/core/include/tether/bluetooth/monitor.hppnew file mode 100644index 0000000..e898255--- /dev/null+++ b/src/core/include/tether/bluetooth/monitor.hpp@@ -0,0 +1,48 @@+#pragma once++#include "tether/bluetooth/objects.hpp"++#include <functional>+#include <gio/gio.h>+#include <memory>++namespace tether::bluetooth {++ struct MonitorState;++ // Watches BlueZ on the system bus and keeps a current snapshot of its object tree.+ class BluezMonitor {+ public:+ BluezMonitor();+ ~BluezMonitor();++ BluezMonitor(const BluezMonitor&) = delete;+ BluezMonitor& operator=(const BluezMonitor&) = delete;++ // Connects to the system bus and starts the watcher thread. Returns false+ // if BlueZ is unreachable; the daemon runs on without Bluetooth support.+ bool start();+ void stop();+ bool running() const;++ // Level-triggered eventfd, readable whenever the snapshot has changed.+ // Register with EpollEventLoop::addFd and call drain() from the callback.+ int event_fd() const;+ void drain();++ BluezObjects snapshot() const;+ Capability capability() const;++ // Shared system-bus connection. GDBusConnection is thread-safe for call.+ GDBusConnection* connection() const;++ // Runs fn on the watcher thread and waits for it to finish.+ void invoke_sync(const std::function<void()>& fn);++ private:+ std::unique_ptr<MonitorState> impl_;+ };++ extern BluezMonitor* g_bluez;++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/obex_transfer.hpp b/src/core/include/tether/bluetooth/obex_transfer.hppnew file mode 100644index 0000000..15e63cf--- /dev/null+++ b/src/core/include/tether/bluetooth/obex_transfer.hpp@@ -0,0 +1,16 @@+#pragma once++#include <gio/gio.h>+#include <string>++namespace tether::bluetooth {++ // obexd removes a transfer object as soon as it finishes, so an object that+ // has disappeared is a normal terminal state rather than a failure.+ enum class TransferState { Active, Complete, Error, Gone };++ // Polls a transfer to completion. Returns Active only when the timeout ran+ // out with the transfer still in progress.+ TransferState wait_for_transfer(GDBusConnection* bus, const std::string& path, int timeout_seconds);++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/objects.hpp b/src/core/include/tether/bluetooth/objects.hppnew file mode 100644index 0000000..7d34149--- /dev/null+++ b/src/core/include/tether/bluetooth/objects.hpp@@ -0,0 +1,114 @@+#pragma once++#include <cstdint>+#include <glib.h>+#include <nlohmann/json.hpp>+#include <string>+#include <vector>++// Plain-data view of BlueZ's object tree, decoded from org.freedesktop.DBus+// ObjectManager payloads. Deliberately free of any bus or threading concern so+// it can be tested against recorded payloads.+namespace tether::bluetooth {++ // Services the iPhone exposes that we care about+ inline constexpr const char* UUID_MAP_MAS = "00001132-0000-1000-8000-00805f9b34fb";+ inline constexpr const char* UUID_MAP_MNS = "00001133-0000-1000-8000-00805f9b34fb";+ inline constexpr const char* UUID_PBAP_PSE = "0000112f-0000-1000-8000-00805f9b34fb";+ inline constexpr const char* UUID_ANCS = "7905f431-b5ce-4e99-a40f-4b1e122d00d0";++ inline constexpr uint32_t COD_TARGET = 0x0408;+ inline constexpr uint32_t COD_MASK = 0x1fff;++ struct Adapter {+ std::string path;+ std::string address;+ std::string name;+ uint32_t device_class = 0;+ bool powered = false;+ std::vector<std::string> roles;+ // org.bluez.LEAdvertisingManager1 is a separate interface on the same object.+ bool has_advertising_manager = false;+ uint8_t advertising_instances = 0;++ bool has_role(const std::string& role) const;+ bool class_is_handsfree() const { return (device_class & COD_MASK) == COD_TARGET; }++ bool operator==(const Adapter&) const = default;+ };++ struct Device {+ std::string path;+ std::string adapter_path;+ std::string address;+ std::string name;+ bool paired = false;+ bool bonded = false;+ bool trusted = false;+ bool connected = false;+ std::vector<std::string> uuids;++ bool has_le_bearer = false;+ bool le_paired = false;+ bool le_bonded = false;+ bool le_connected = false;++ bool has_uuid(const std::string& uuid) const;+ bool supports_map() const { return has_uuid(UUID_MAP_MAS); }+ bool supports_pbap() const { return has_uuid(UUID_PBAP_PSE); }+ bool supports_ancs() const { return has_uuid(UUID_ANCS); }+ bool looks_like_iphone() const;++ bool operator==(const Device&) const = default;+ };++ struct BluezObjects {+ std::vector<Adapter> adapters;+ std::vector<Device> devices;++ // Whether bluetoothd was started with --experimental. Bearer.LE1 exists only under that flag+ bool experimental_api = false;++ const Adapter* find_adapter(const std::string& path) const;+ const Device* find_device(const std::string& path) const;++ bool operator==(const BluezObjects&) const = default;+ };++ // Whether the machine can carry ANCS, or only MAP and PBAP.+ enum class DeliveryMode { Blocked, Compatibility, Full };++ // Bearer.LE1 cannot be observed until something is bonded, so its absence is+ // only meaningful once a bond exists.+ enum class BearerApi { Unknown, Confirmed, Absent };++ struct Capability {+ DeliveryMode mode = DeliveryMode::Blocked;+ BearerApi bearer_api = BearerApi::Unknown;+ bool adapter_present = false;+ bool powered = false;+ bool le_central = false;+ bool le_peripheral = false;+ bool advertising = false;+ bool class_ok = false;+ // Human-readable explanations for anything short of full mode, shown verbatim+ std::vector<std::string> reasons;++ bool operator==(const Capability&) const = default;+ };++ const char* to_string(DeliveryMode mode);+ const char* to_string(BearerApi api);++ // Decodes an ObjectManager.GetManagedObjects reply, a{oa{sa{sv}}}. Accepts+ // either the raw reply tuple or the unwrapped dictionary. Returns an empty+ // result for null or unexpected input rather than throwing.+ BluezObjects parse_managed_objects(GVariant* reply);++ Capability resolve_capability(const BluezObjects& objects);++ nlohmann::json to_json(const Adapter& adapter);+ nlohmann::json to_json(const Device& device);+ nlohmann::json to_json(const Capability& capability);++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/pairing.hpp b/src/core/include/tether/bluetooth/pairing.hppnew file mode 100644index 0000000..b1b086e--- /dev/null+++ b/src/core/include/tether/bluetooth/pairing.hpp@@ -0,0 +1,50 @@+#pragma once++#include "tether/bluetooth/config.hpp"++#include <functional>+#include <nlohmann/json.hpp>+#include <string>++namespace tether::bluetooth {++ class BluezMonitor;++ struct PairResult {+ bool success = false;+ // Machine-readable outcome: "paired", "already_paired", "not_found",+ // "rejected", "timeout", "busy", "error".+ std::string status;+ std::string message;+ std::string device_path;+ std::string device_address;+ // True when the resulting bond covers LE as well as BR/EDR.+ bool dual_bond = false;+ };++ // Reports progress steps so the CLI and GTK app can show what is happening+ // during a transaction that legitimately takes tens of seconds.+ using ProgressFn = std::function<void(const std::string& step, const std::string& detail)>;++ // Asks the user to confirm a six-digit numeric comparison code. Returns true+ // to accept. Runs on the monitor's GLib thread.+ using ConfirmFn = std::function<bool(const std::string& code)>;++ // Runs the full pairing transaction against `address`, blocking until it+ // resolves. Intended to be called from a worker thread: GDBusConnection is+ // thread-safe for calls, while the agent's callbacks land on the monitor's+ // GLib thread.+ PairResult pair_device(BluezMonitor& monitor,+ const std::string& address,+ AuthStrategy strategy,+ const ProgressFn& progress,+ const ConfirmFn& confirm);++ // Removes the bond so a clean pairing can be retried.+ PairResult unpair_device(BluezMonitor& monitor, const std::string& address);++ nlohmann::json to_json(const PairResult& result);++ bool confirm_with_dialog(const std::string& device_name, const std::string& code);++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/pbap_session.hpp b/src/core/include/tether/bluetooth/pbap_session.hppnew file mode 100644index 0000000..ddb1ad8--- /dev/null+++ b/src/core/include/tether/bluetooth/pbap_session.hpp@@ -0,0 +1,47 @@+#pragma once++#include "tether/bluetooth/vcard.hpp"++#include <gio/gio.h>+#include <memory>+#include <string>+#include <vector>++namespace tether::bluetooth {++ // Pulling a large phonebook is a real OBEX transfer.+ inline constexpr int PBAP_CALL_TIMEOUT_MS = 60000;+ inline constexpr int PBAP_TRANSFER_TIMEOUT_SECONDS = 60;+ inline constexpr int PBAP_FILE_GRACE_SECONDS = 3;+ inline constexpr int PBAP_MAX_CONTACTS = 5000;++ struct PbapSessionState;++ // Drives org.bluez.obex.PhonebookAccess1 for one open OBEX session.+ class PbapSession {+ public:+ PbapSession(GDBusConnection* session_bus, std::string session_path);+ ~PbapSession();++ PbapSession(const PbapSession&) = delete;+ PbapSession& operator=(const PbapSession&) = delete;++ // Selects the phonebook. This is PBAP's Select("int", "pb")+ // (not MAP's SetFolder)+ bool select_phonebook(std::string& err,+ const std::string& location = "int",+ const std::string& phonebook = "pb");++ // Pulls the selected phonebook and parses it.+ //+ // Uses PullAll's MaxCount filter. MaxListCount is MAP's option and makes a+ // PBAP transfer fail or return nothing at all.+ std::vector<VCard> pull_all(std::string& err, int max = PBAP_MAX_CONTACTS);++ const std::string& path() const;++ private:+ std::unique_ptr<PbapSessionState> state_;+ };++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/profile_supervisor.hpp b/src/core/include/tether/bluetooth/profile_supervisor.hppnew file mode 100644index 0000000..61472ad--- /dev/null+++ b/src/core/include/tether/bluetooth/profile_supervisor.hpp@@ -0,0 +1,86 @@+#pragma once++#include <cstdint>+#include <string>++namespace tether::bluetooth {++ // Poll fast until the first session opens, then slowly.+ inline constexpr int PROFILE_INITIAL_POLL_SECONDS = 5;+ inline constexpr int PROFILE_STEADY_POLL_SECONDS = 15;++ // Why an OBEX session could not be opened. Forbidden and Busy look alike from a distance, and reporting one as the+ // other sends the user off re-pairing for nothing.+ enum class ObexError {+ None,+ // OBEX Forbidden / 0x43: the iPhone's permission toggle is off. Not a pairing failure+ Forbidden,+ // Transport-level "Connection refused (111)": another computer probably+ // owns the iPhone's single MAP session. Keep polling; do not re-pair.+ Busy,+ // obexd's live SDP query found no MAS/PSE record. NOT a permissions failure. Recovers on its own once the phone+ // serves them again.+ NoRecord,+ // The phone is not reachable right now.+ Unavailable,+ Other,+ };++ const char* to_string(ObexError error);++ // Maps an obexd/D-Bus error message onto the cases above. Pure so the+ // classification can be pinned down by tests against real message text.+ ObexError classify_obex_error(const std::string& message);++ // Advice for the user, phrased so it can be shown verbatim.+ std::string obex_error_advice(ObexError error, const std::string& profile);++ // Session operations on obexd.+ class ProfileOps {+ public:+ virtual ~ProfileOps() = default;++ // Returns the new session's object path, or an empty string with err set.+ virtual std::string create_session(const std::string& target, std::string& err) = 0;+ virtual void remove_session(const std::string& path) = 0;+ };++ struct ProfileStatus {+ bool map_open = false;+ bool pbap_open = false;+ ObexError map_error = ObexError::None;+ ObexError pbap_error = ObexError::None;+ std::string reason;++ bool operator==(const ProfileStatus&) const = default;+ };++ // Keeps exactly one MAP and one PBAP session alive for the daemon's lifetime.+ class ProfileSupervisor {+ public:+ explicit ProfileSupervisor(ProfileOps& ops);++ // Drive periodically with a monotonic clock.+ bool tick(int64_t now, bool link_ready);++ // Drops both sessions after a disconnect so the next tick reopens them.+ void reset();++ const ProfileStatus& status() const { return status_; }+ const std::string& map_session() const { return map_path_; }+ const std::string& pbap_session() const { return pbap_path_; }++ private:+ bool open_profile(const std::string& target, std::string& path, ObexError& error, bool& retried);++ ProfileOps& ops_;+ ProfileStatus status_;+ std::string map_path_;+ std::string pbap_path_;+ bool map_retried_ = false;+ bool pbap_retried_ = false;+ int64_t next_attempt_ = 0;+ bool opened_once_ = false;+ };++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/bluetooth/vcard.hpp b/src/core/include/tether/bluetooth/vcard.hppnew file mode 100644index 0000000..30b8eb1--- /dev/null+++ b/src/core/include/tether/bluetooth/vcard.hpp@@ -0,0 +1,36 @@+#pragma once++#include <string>+#include <vector>++namespace tether::bluetooth {++ // One contact as PBAP delivers it.+ //+ // Name is display data. The tel and email lists are the identity keys, and a contact routinely has several of each.+ struct VCard {+ std::string name;+ std::vector<std::string> tels;+ std::vector<std::string> emails;++ bool empty() const { return name.empty() && tels.empty() && emails.empty(); }+ };++ // Parses a vCard 3.0 document containing any number of cards.+ std::vector<VCard> parse_vcards(const std::string& text);++ // Undoes RFC 2425 line folding: a line beginning with a space or tab+ // continues the previous one. Also normalizes CRLF to LF.+ std::vector<std::string> vcard_unfold(const std::string& text);++ // "TEL;TYPE=CELL:+15551234567" -> name "TEL", value "+15551234567".+ // Parameters after ';' are discarded; only the property name matters.+ bool vcard_split_property(const std::string& line, std::string& name, std::string& value);++ // vCard N is structured "Family;Given;Middle;Prefix;Suffix".+ std::string vcard_name_from_n(const std::string& value);++ // vCard 3.0 escapes \, \; \n and \\ in values.+ std::string vcard_unescape(const std::string& value);++} // namespace tether::bluetoothdiff --git a/src/core/include/tether/net.hpp b/src/core/include/tether/net.hppindex 644d110..fd1d616 100644--- a/src/core/include/tether/net.hpp+++ b/src/core/include/tether/net.hpp@@ -3,6 +3,7 @@#include "tether/event_loop.hpp"#include <filesystem>#include <map>+#include <nlohmann/json.hpp>#include <openssl/ssl.h>#include <string>#include <sys/types.h>@@ -27,6 +28,10 @@ namespace tether {void record_received_file(const std::filesystem::path& path, size_t bytes_written);size_t broadcast_tcp_message(const std::string& msg, int exclude_fd = -1);+ // Bluetooth state, read from the BluezMonitor snapshot.+ nlohmann::json build_bt_status();+ nlohmann::json build_bt_devices();+class UnixServer {public:UnixServer(EpollEventLoop& loop);diff --git a/src/core/src/bluetooth/advert.cpp b/src/core/src/bluetooth/advert.cppnew file mode 100644index 0000000..9075401--- /dev/null+++ b/src/core/src/bluetooth/advert.cpp@@ -0,0 +1,203 @@+#include "tether/bluetooth/advert.hpp"+#include "tether/bluetooth/objects.hpp"+#include "tether/log.hpp"++namespace tether::bluetooth {++ namespace {++ constexpr const char* BLUEZ_NAME = "org.bluez";+ constexpr const char* ADVERT_PATH = "/org/tether/bt_advert";+ constexpr const char* ADVERT_MANAGER = "org.bluez.LEAdvertisingManager1";++ // Private/test identifiers that claim no Apple or hardware-vendor+ // identity, following the convention ancs4linux established. No meaning; they exist because the advert iOS+ // responds to carries them.+ constexpr guint16 INERT_MANUFACTURER_ID = 0xffff;+ constexpr const char* INERT_SERVICE_UUID = "00009999-0000-1000-8000-00805f9b34fb";++ // iOS needs the it running long enough to notice+ constexpr guint16 ADVERT_TIMEOUT_SECONDS = 180;++ constexpr const char* ADVERT_XML = R"XML(+<node>+ <interface name='org.bluez.LEAdvertisement1'>+ <method name='Release'/>+ <property name='Type' type='s' access='read'/>+ <property name='SolicitUUIDs' type='as' access='read'/>+ <property name='ManufacturerData' type='a{qv}' access='read'/>+ <property name='ServiceData' type='a{sv}' access='read'/>+ <property name='Discoverable' type='b' access='read'/>+ <property name='Timeout' type='q' access='read'/>+ <property name='LocalName' type='s' access='read'/>+ </interface>+</node>)XML";++ GVariant* inert_bytes() {+ const guint8 payload[] = {0x00};+ return g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, payload, sizeof(payload), sizeof(guint8));+ }++ void handle_method(GDBusConnection*,+ const gchar*,+ const gchar*,+ const gchar*,+ const gchar* method,+ GVariant*,+ GDBusMethodInvocation* invocation,+ gpointer) {+ // BlueZ calls Release when it drops the advertisement on its own.+ if (g_strcmp0(method, "Release") == 0)+ debug::log(INFO, "bluetooth: ANCS advertisement released by BlueZ");+ g_dbus_method_invocation_return_value(invocation, nullptr);+ }++ GVariant* handle_get_property(+ GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar* name, GError**, gpointer) {+ const std::string prop = name ? name : "";++ if (prop == "Type")+ return g_variant_new_string("peripheral");++ if (prop == "SolicitUUIDs") {+ GVariantBuilder builder;+ g_variant_builder_init(&builder, G_VARIANT_TYPE("as"));+ g_variant_builder_add(&builder, "s", UUID_ANCS);+ return g_variant_builder_end(&builder);+ }++ if (prop == "ManufacturerData") {+ GVariantBuilder builder;+ g_variant_builder_init(&builder, G_VARIANT_TYPE("a{qv}"));+ g_variant_builder_add(&builder, "{qv}", INERT_MANUFACTURER_ID, inert_bytes());+ return g_variant_builder_end(&builder);+ }++ if (prop == "ServiceData") {+ GVariantBuilder builder;+ g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}"));+ g_variant_builder_add(&builder, "{sv}", INERT_SERVICE_UUID, inert_bytes());+ return g_variant_builder_end(&builder);+ }++ if (prop == "Discoverable")+ return g_variant_new_boolean(TRUE);++ if (prop == "Timeout")+ return g_variant_new_uint16(ADVERT_TIMEOUT_SECONDS);++ if (prop == "LocalName")+ return g_variant_new_string("Tether");++ return nullptr;+ }++ const GDBusInterfaceVTable ADVERT_VTABLE = {handle_method, handle_get_property, nullptr, {nullptr}};++ } // namespace++ struct AdvertState {+ GDBusConnection* conn = nullptr;+ std::string adapter_path;+ guint registration_id = 0;+ bool registered_with_bluez = false;+ };++ AncsAdvertisement::AncsAdvertisement(GDBusConnection* connection, std::string adapter_path)+ : state_(std::make_unique<AdvertState>()) {+ state_->conn = connection;+ state_->adapter_path = std::move(adapter_path);+ }++ AncsAdvertisement::~AncsAdvertisement() {+ unregister_with_bluez();+ unexport_object();+ }++ bool AncsAdvertisement::active() const { return state_->registered_with_bluez; }++ bool AncsAdvertisement::export_object() {+ if (state_->registration_id != 0)+ return true;++ GError* error = nullptr;+ GDBusNodeInfo* info = g_dbus_node_info_new_for_xml(ADVERT_XML, &error);+ if (!info) {+ debug::log(ERR, "bluetooth: bad advertisement introspection: {}", error ? error->message : "unknown");+ g_clear_error(&error);+ return false;+ }++ state_->registration_id = g_dbus_connection_register_object(+ state_->conn, ADVERT_PATH, info->interfaces[0], &ADVERT_VTABLE, state_.get(), nullptr, &error);+ g_dbus_node_info_unref(info);++ if (state_->registration_id == 0) {+ debug::log(ERR, "bluetooth: cannot export advertisement: {}", error ? error->message : "unknown");+ g_clear_error(&error);+ return false;+ }+ return true;+ }++ bool AncsAdvertisement::register_with_bluez() {+ if (state_->registered_with_bluez)+ return true;+ if (state_->registration_id == 0)+ return false;++ GError* error = nullptr;+ GVariantBuilder options;+ g_variant_builder_init(&options, G_VARIANT_TYPE("a{sv}"));+ GVariant* reply = g_dbus_connection_call_sync(state_->conn,+ BLUEZ_NAME,+ state_->adapter_path.c_str(),+ ADVERT_MANAGER,+ "RegisterAdvertisement",+ g_variant_new("(oa{sv})", ADVERT_PATH, &options),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ 10000,+ nullptr,+ &error);+ if (!reply) {+ debug::log(ERR, "bluetooth: RegisterAdvertisement failed: {}", error ? error->message : "unknown");+ g_clear_error(&error);+ return false;+ }+ g_variant_unref(reply);++ state_->registered_with_bluez = true;+ debug::log(INFO, "bluetooth: soliciting ANCS for {}s", ADVERT_TIMEOUT_SECONDS);+ return true;+ }++ void AncsAdvertisement::unregister_with_bluez() {+ if (state_->registered_with_bluez) {+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(state_->conn,+ BLUEZ_NAME,+ state_->adapter_path.c_str(),+ ADVERT_MANAGER,+ "UnregisterAdvertisement",+ g_variant_new("(o)", ADVERT_PATH),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ 5000,+ nullptr,+ &error);+ if (reply)+ g_variant_unref(reply);+ g_clear_error(&error);+ state_->registered_with_bluez = false;+ }+ }++ void AncsAdvertisement::unexport_object() {+ if (state_->registration_id != 0) {+ g_dbus_connection_unregister_object(state_->conn, state_->registration_id);+ state_->registration_id = 0;+ }+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/agent.cpp b/src/core/src/bluetooth/agent.cppnew file mode 100644index 0000000..2e94afa--- /dev/null+++ b/src/core/src/bluetooth/agent.cpp@@ -0,0 +1,286 @@+#include "tether/bluetooth/agent.hpp"+#include "tether/log.hpp"++#include <algorithm>+#include <array>++namespace tether::bluetooth {++ namespace {++ constexpr const char* BLUEZ_NAME = "org.bluez";+ constexpr const char* AGENT_PATH = "/org/tether/bt_agent";+ constexpr const char* AGENT_MANAGER = "org.bluez.AgentManager1";+ // DisplayYesNo yields numeric comparison, the only method Tether supports.+ constexpr const char* AGENT_CAPABILITY = "DisplayYesNo";++ constexpr const char* AGENT_XML = R"XML(+<node>+ <interface name='org.bluez.Agent1'>+ <method name='Release'/>+ <method name='RequestPinCode'>+ <arg type='o' name='device' direction='in'/>+ <arg type='s' name='pincode' direction='out'/>+ </method>+ <method name='DisplayPinCode'>+ <arg type='o' name='device' direction='in'/>+ <arg type='s' name='pincode' direction='in'/>+ </method>+ <method name='RequestPasskey'>+ <arg type='o' name='device' direction='in'/>+ <arg type='u' name='passkey' direction='out'/>+ </method>+ <method name='DisplayPasskey'>+ <arg type='o' name='device' direction='in'/>+ <arg type='u' name='passkey' direction='in'/>+ <arg type='q' name='entered' direction='in'/>+ </method>+ <method name='RequestConfirmation'>+ <arg type='o' name='device' direction='in'/>+ <arg type='u' name='passkey' direction='in'/>+ </method>+ <method name='RequestAuthorization'>+ <arg type='o' name='device' direction='in'/>+ </method>+ <method name='AuthorizeService'>+ <arg type='o' name='device' direction='in'/>+ <arg type='s' name='uuid' direction='in'/>+ </method>+ <method name='Cancel'/>+ </interface>+</node>)XML";++ constexpr const char* ERROR_REJECTED = "org.bluez.Error.Rejected";++ bool iequals(const std::string& a, const std::string& b) {+ return a.size() == b.size() &&+ std::equal(a.begin(), a.end(), b.begin(), [](unsigned char x, unsigned char y) {+ return std::tolower(x) == std::tolower(y);+ });+ }++ } // namespace++ bool is_authorized_service(const std::string& uuid) {+ static const std::array<const char*, 5> allowed = {+ "0000112e-0000-1000-8000-00805f9b34fb", // PBAP client+ "0000112f-0000-1000-8000-00805f9b34fb", // PBAP server+ "00001132-0000-1000-8000-00805f9b34fb", // MAP server+ "00001133-0000-1000-8000-00805f9b34fb", // MAP notification server+ "00001134-0000-1000-8000-00805f9b34fb", // MAP client+ };+ return std::any_of(allowed.begin(), allowed.end(), [&](const char* u) { return iequals(uuid, u); });+ }++ std::string format_passkey(uint32_t passkey) {+ std::string digits = std::to_string(passkey % 1000000u);+ return std::string(6 - digits.size(), '0') + digits;+ }++ struct AgentState {+ GDBusConnection* conn = nullptr;+ std::string device_path;+ PairingAgent::ConfirmHandler on_confirm;+ std::string path = AGENT_PATH;+ guint registration_id = 0;+ bool registered_with_bluez = false;+ };++ namespace {++ void reject(GDBusMethodInvocation* invocation, const char* why) {+ g_dbus_method_invocation_return_dbus_error(invocation, ERROR_REJECTED, why);+ }++ void handle_method(GDBusConnection*,+ const gchar*,+ const gchar*,+ const gchar*,+ const gchar* method,+ GVariant* params,+ GDBusMethodInvocation* invocation,+ gpointer user_data) {+ auto* state = static_cast<AgentState*>(user_data);+ std::string name = method ? method : "";++ if (name == "Release") {+ g_dbus_method_invocation_return_value(invocation, nullptr);+ return;+ }++ if (name == "Cancel") {+ g_dbus_method_invocation_return_value(invocation, nullptr);+ return;+ }++ // Every remaining method names a device first. Refuse anything that is+ // not the device this agent was created for, so an unrelated phone or+ // headset cannot ride along on a pairing the user started.+ const gchar* device = nullptr;+ g_variant_get_child(params, 0, "&o", &device);+ const std::string device_path = device ? device : "";+ if (device_path != state->device_path) {+ debug::log(WARN, "bluetooth: agent refused {} for unexpected device {}", name, device_path);+ reject(invocation, "Not the device being paired");+ return;+ }++ if (name == "RequestPinCode" || name == "DisplayPinCode" || name == "RequestPasskey" ||+ name == "DisplayPasskey") {+ debug::log(WARN, "bluetooth: agent refused unsupported pairing method {}", name);+ reject(invocation, "Only numeric comparison pairing is supported");+ return;+ }++ if (name == "AuthorizeService") {+ const gchar* uuid = nullptr;+ g_variant_get_child(params, 1, "&s", &uuid);+ const std::string service = uuid ? uuid : "";+ if (!is_authorized_service(service)) {+ debug::log(INFO, "bluetooth: agent refused service {}", service);+ reject(invocation, "Service not used by Tether");+ return;+ }+ g_dbus_method_invocation_return_value(invocation, nullptr);+ return;+ }++ if (name == "RequestAuthorization") {+ // Pairing with no comparison to show the user. Accepting silently+ // would defeat the confirmation this agent exists to provide.+ reject(invocation, "Numeric comparison is required");+ return;+ }++ if (name == "RequestConfirmation") {+ guint32 passkey = 0;+ g_variant_get_child(params, 1, "u", &passkey);++ if (state->on_confirm && state->on_confirm(format_passkey(passkey)))+ g_dbus_method_invocation_return_value(invocation, nullptr);+ else+ reject(invocation, "Rejected by the user");+ return;+ }++ reject(invocation, "Unsupported method");+ }++ const GDBusInterfaceVTable AGENT_VTABLE = {handle_method, nullptr, nullptr, {nullptr}};++ } // namespace++ PairingAgent::PairingAgent(GDBusConnection* connection, std::string device_path, ConfirmHandler on_confirm)+ : state_(std::make_unique<AgentState>()) {+ state_->conn = connection;+ state_->device_path = std::move(device_path);+ state_->on_confirm = std::move(on_confirm);+ }++ PairingAgent::~PairingAgent() {+ unregister_with_bluez();+ unexport_object();+ }++ const std::string& PairingAgent::path() const { return state_->path; }++ bool PairingAgent::export_object() {+ if (state_->registration_id != 0)+ return true;++ GError* error = nullptr;+ GDBusNodeInfo* info = g_dbus_node_info_new_for_xml(AGENT_XML, &error);+ if (!info) {+ debug::log(ERR, "bluetooth: bad agent introspection: {}", error ? error->message : "unknown");+ g_clear_error(&error);+ return false;+ }++ state_->registration_id = g_dbus_connection_register_object(+ state_->conn, state_->path.c_str(), info->interfaces[0], &AGENT_VTABLE, state_.get(), nullptr, &error);+ g_dbus_node_info_unref(info);++ if (state_->registration_id == 0) {+ debug::log(ERR, "bluetooth: cannot export agent: {}", error ? error->message : "unknown");+ g_clear_error(&error);+ return false;+ }+ return true;+ }++ bool PairingAgent::register_with_bluez() {+ if (state_->registered_with_bluez)+ return true;+ if (state_->registration_id == 0)+ return false;++ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(state_->conn,+ BLUEZ_NAME,+ "/org/bluez",+ AGENT_MANAGER,+ "RegisterAgent",+ g_variant_new("(os)", state_->path.c_str(), AGENT_CAPABILITY),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ 5000,+ nullptr,+ &error);+ if (!reply) {+ debug::log(ERR, "bluetooth: RegisterAgent failed: {}", error ? error->message : "unknown");+ g_clear_error(&error);+ return false;+ }+ g_variant_unref(reply);+ state_->registered_with_bluez = true;++ reply = g_dbus_connection_call_sync(state_->conn,+ BLUEZ_NAME,+ "/org/bluez",+ AGENT_MANAGER,+ "RequestDefaultAgent",+ g_variant_new("(o)", state_->path.c_str()),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ 5000,+ nullptr,+ &error);+ if (!reply) {+ debug::log(WARN, "bluetooth: RequestDefaultAgent failed: {}", error ? error->message : "unknown");+ g_clear_error(&error);+ // Keep going: pairing can still succeed if no other agent competes.+ } else {+ g_variant_unref(reply);+ }+ return true;+ }++ void PairingAgent::unregister_with_bluez() {+ if (state_->registered_with_bluez) {+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(state_->conn,+ BLUEZ_NAME,+ "/org/bluez",+ AGENT_MANAGER,+ "UnregisterAgent",+ g_variant_new("(o)", state_->path.c_str()),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ 5000,+ nullptr,+ &error);+ if (reply)+ g_variant_unref(reply);+ g_clear_error(&error);+ state_->registered_with_bluez = false;+ }+ }++ void PairingAgent::unexport_object() {+ if (state_->registration_id != 0) {+ g_dbus_connection_unregister_object(state_->conn, state_->registration_id);+ state_->registration_id = 0;+ }+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/ancs/client.cpp b/src/core/src/bluetooth/ancs/client.cppnew file mode 100644index 0000000..9e195f1--- /dev/null+++ b/src/core/src/bluetooth/ancs/client.cpp@@ -0,0 +1,492 @@+#include "tether/bluetooth/ancs/client.hpp"+#include "tether/bluetooth/ancs/sequencer.hpp"+#include "tether/bluetooth/monitor.hpp"+#include "tether/log.hpp"++#include <ctime>+#include <deque>+#include <gio/gio.h>+#include <mutex>++namespace tether::bluetooth::ancs {++ namespace {++ constexpr const char* BLUEZ_NAME = "org.bluez";+ constexpr const char* IFACE_CHARACTERISTIC = "org.bluez.GattCharacteristic1";+ constexpr const char* IFACE_PROPS = "org.freedesktop.DBus.Properties";+ constexpr const char* OBJECT_MANAGER = "org.freedesktop.DBus.ObjectManager";++ constexpr int CALL_TIMEOUT_MS = 10000;++ } // namespace++ struct AncsClientState {+ BluezMonitor* monitor = nullptr;+ AncsClient::NotificationFn on_notification;+ AncsClient::WithdrawFn on_withdraw;+ AncsClient::StatusFn on_status;++ std::string device_path;+ std::string notification_source_path;+ std::string control_point_path;+ std::string data_source_path;++ bool subscribed = false;+ bool ready = false;+ bool initial_sync = true;+ bool content_enabled = false;+ std::string reason = "Waiting for the iPhone's notification service.";++ int64_t next_discover = 0;+ int64_t next_subscribe = 0;+ int64_t next_probe = 0;++ // Filled on the GLib thread, drained on the caller's thread. Only these+ // two buffers cross the boundary.+ std::mutex inbox;+ std::deque<std::vector<uint8_t>> pending_source;+ std::deque<std::vector<uint8_t>> pending_data;++ guint source_signal = 0;+ guint data_signal = 0;++ NotificationRegistry registry;+ std::unique_ptr<ControlPointSequencer> sequencer;++ // UIDs whose attributes are being fetched, so a notification can be+ // rebuilt when its response lands.+ std::map<uint32_t, SourceEvent> in_progress;++ bool write_control_point(const std::vector<uint8_t>& payload);+ void set_status(bool now_ready, const std::string& text);+ bool discover();+ bool subscribe();+ void unsubscribe();+ void handle_source_event(const SourceEvent& event, int64_t now);+ void handle_response(const Request& request, const Response& response, int64_t now);+ };++ namespace {++ void on_properties_changed(GDBusConnection*,+ const gchar*,+ const gchar* object_path,+ const gchar*,+ const gchar*,+ GVariant* parameters,+ gpointer user_data) {+ auto* state = static_cast<AncsClientState*>(user_data);+ if (!state || !object_path)+ return;++ const gchar* iface = nullptr;+ GVariant* changed = nullptr;+ GVariantIter* invalidated = nullptr;+ g_variant_get(parameters, "(&s@a{sv}as)", &iface, &changed, &invalidated);+ if (invalidated)+ g_variant_iter_free(invalidated);+ if (!changed)+ return;++ GVariant* value = g_variant_lookup_value(changed, "Value", G_VARIANT_TYPE("ay"));+ g_variant_unref(changed);+ if (!value)+ return;++ gsize length = 0;+ const guchar* bytes = static_cast<const guchar*>(g_variant_get_fixed_array(value, &length, 1));+ if (bytes && length) {+ std::vector<uint8_t> copy(bytes, bytes + length);+ std::lock_guard<std::mutex> lock(state->inbox);+ if (state->notification_source_path == object_path)+ state->pending_source.push_back(std::move(copy));+ else if (state->data_source_path == object_path)+ state->pending_data.push_back(std::move(copy));+ }+ g_variant_unref(value);+ }++ } // namespace++ void AncsClientState::set_status(bool now_ready, const std::string& text) {+ if (ready == now_ready && reason == text)+ return;+ ready = now_ready;+ reason = text;+ if (on_status)+ on_status(ready, reason);+ }++ bool AncsClientState::write_control_point(const std::vector<uint8_t>& payload) {+ if (control_point_path.empty() || !monitor || !monitor->connection())+ return false;++ GVariantBuilder options;+ g_variant_builder_init(&options, G_VARIANT_TYPE("a{sv}"));++ GVariant* value =+ g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, payload.data(), payload.size(), sizeof(uint8_t));++ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(monitor->connection(),+ BLUEZ_NAME,+ control_point_path.c_str(),+ IFACE_CHARACTERISTIC,+ "WriteValue",+ g_variant_new("(@aya{sv})", value, &options),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ CALL_TIMEOUT_MS,+ nullptr,+ &error);+ if (!reply) {+ const std::string message = error ? error->message : "unknown error";+ g_clear_error(&error);+ // Until the user approves the phone's prompt, the control point+ // refuses every write. That is a pending permission, not a fault.+ debug::log(WARN, "ancs: control point write failed: {}", message);+ return false;+ }+ g_variant_unref(reply);+ return true;+ }++ bool AncsClientState::discover() {+ if (!monitor || !monitor->connection() || device_path.empty())+ return false;++ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(monitor->connection(),+ BLUEZ_NAME,+ "/",+ OBJECT_MANAGER,+ "GetManagedObjects",+ nullptr,+ G_VARIANT_TYPE("(a{oa{sa{sv}}})"),+ G_DBUS_CALL_FLAGS_NONE,+ CALL_TIMEOUT_MS,+ nullptr,+ &error);+ if (!reply) {+ g_clear_error(&error);+ return false;+ }++ notification_source_path.clear();+ control_point_path.clear();+ data_source_path.clear();++ GVariant* objects = g_variant_get_child_value(reply, 0);+ GVariantIter iter;+ const gchar* path = nullptr;+ GVariant* interfaces = nullptr;+ g_variant_iter_init(&iter, objects);+ while (g_variant_iter_loop(&iter, "{&o@a{sa{sv}}}", &path, &interfaces)) {+ const std::string object_path = path ? path : "";+ // Characteristics live under the device that owns them.+ if (object_path.rfind(device_path + "/", 0) != 0)+ continue;++ GVariant* props = g_variant_lookup_value(interfaces, IFACE_CHARACTERISTIC, G_VARIANT_TYPE("a{sv}"));+ if (!props)+ continue;++ GVariant* uuid_value = g_variant_lookup_value(props, "UUID", G_VARIANT_TYPE_STRING);+ if (uuid_value) {+ const std::string uuid = g_variant_get_string(uuid_value, nullptr);+ if (uuid == UUID_NOTIFICATION_SOURCE)+ notification_source_path = object_path;+ else if (uuid == UUID_CONTROL_POINT)+ control_point_path = object_path;+ else if (uuid == UUID_DATA_SOURCE)+ data_source_path = object_path;+ g_variant_unref(uuid_value);+ }+ g_variant_unref(props);+ }+ g_variant_unref(objects);+ g_variant_unref(reply);++ // All three are needed. A partial tree means BlueZ is still enumerating.+ return !notification_source_path.empty() && !control_point_path.empty() && !data_source_path.empty();+ }++ bool AncsClientState::subscribe() {+ if (!monitor || !monitor->connection())+ return false;++ GDBusConnection* conn = monitor->connection();+ auto start_notify = [&](const std::string& path) {+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(conn,+ BLUEZ_NAME,+ path.c_str(),+ IFACE_CHARACTERISTIC,+ "StartNotify",+ nullptr,+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ CALL_TIMEOUT_MS,+ nullptr,+ &error);+ if (!reply) {+ // StartNotify can race GATT readiness even after the+ // characteristics appear, so this is retried rather than treated+ // as a reason to rediscover.+ const std::string message = error ? error->message : "unknown";+ g_clear_error(&error);+ debug::log(INFO, "ancs: StartNotify not ready yet ({})", message);+ return false;+ }+ g_variant_unref(reply);+ return true;+ };++ if (!start_notify(data_source_path))+ return false;+ if (!start_notify(notification_source_path))+ return false;++ monitor->invoke_sync([this] {+ GDBusConnection* bus = monitor->connection();+ if (!source_signal) {+ source_signal = g_dbus_connection_signal_subscribe(bus,+ BLUEZ_NAME,+ IFACE_PROPS,+ "PropertiesChanged",+ notification_source_path.c_str(),+ nullptr,+ G_DBUS_SIGNAL_FLAGS_NONE,+ on_properties_changed,+ this,+ nullptr);+ }+ if (!data_signal) {+ data_signal = g_dbus_connection_signal_subscribe(bus,+ BLUEZ_NAME,+ IFACE_PROPS,+ "PropertiesChanged",+ data_source_path.c_str(),+ nullptr,+ G_DBUS_SIGNAL_FLAGS_NONE,+ on_properties_changed,+ this,+ nullptr);+ }+ });+ return true;+ }++ void AncsClientState::unsubscribe() {+ if (!monitor || !monitor->connection())+ return;+ GDBusConnection* conn = monitor->connection();+ if (source_signal) {+ g_dbus_connection_signal_unsubscribe(conn, source_signal);+ source_signal = 0;+ }+ if (data_signal) {+ g_dbus_connection_signal_unsubscribe(conn, data_signal);+ data_signal = 0;+ }+ }++ void AncsClientState::handle_source_event(const SourceEvent& event, int64_t now) {+ (void)now;+ switch (registry.classify(event, initial_sync)) {+ case Decision::Ignore:+ registry.remember(event);+ return;+ case Decision::Withdraw:+ registry.forget(event.uid);+ if (on_withdraw)+ on_withdraw(event.uid);+ return;+ case Decision::Fetch:+ break;+ }++ std::vector<NotificationAttributeId> attributes{NotificationAttributeId::AppIdentifier};+ if (content_enabled) {+ attributes.push_back(NotificationAttributeId::Title);+ attributes.push_back(NotificationAttributeId::Subtitle);+ attributes.push_back(NotificationAttributeId::Message);+ }++ in_progress[event.uid] = event;+ registry.remember(event);+ if (!sequencer->submit(build_notification_request(event.uid, attributes)))+ in_progress.erase(event.uid);+ }++ void AncsClientState::handle_response(const Request& request, const Response& response, int64_t now) {+ if (response.command == CommandId::GetAppAttributes) {+ // The readiness probe: a Data Source answer proves the phone has+ // authorized notification access, which StartNotify alone does not.+ if (!ready)+ set_status(true, "Notification mirroring is active.");+ return;+ }+ if (response.command != CommandId::GetNotificationAttributes)+ return;++ auto found = in_progress.find(request.uid);+ if (found == in_progress.end())+ return;+ const SourceEvent event = found->second;+ in_progress.erase(found);++ Notification notification;+ notification.uid = request.uid;+ notification.app_id = response.attribute(static_cast<uint8_t>(NotificationAttributeId::AppIdentifier));+ notification.app_name = notification.app_id;+ notification.title = response.attribute(static_cast<uint8_t>(NotificationAttributeId::Title));+ notification.subtitle = response.attribute(static_cast<uint8_t>(NotificationAttributeId::Subtitle));+ notification.body = response.attribute(static_cast<uint8_t>(NotificationAttributeId::Message));+ notification.category = event.category;+ notification.silent = event.silent();+ notification.has_positive_action = event.has_positive_action();+ notification.has_negative_action = event.has_negative_action();+ notification.received = now;++ registry.store(notification);+ if (on_notification)+ on_notification(notification);+ }++ AncsClient::AncsClient(BluezMonitor& monitor,+ NotificationFn on_notification,+ WithdrawFn on_withdraw,+ StatusFn on_status)+ : state_(std::make_unique<AncsClientState>()) {+ state_->monitor = &monitor;+ state_->on_notification = std::move(on_notification);+ state_->on_withdraw = std::move(on_withdraw);+ state_->on_status = std::move(on_status);++ AncsClientState* raw = state_.get();+ state_->sequencer = std::make_unique<ControlPointSequencer>(+ [raw](const std::vector<uint8_t>& payload) { return raw->write_control_point(payload); },+ [raw](const Request& request, const Response& response) {+ raw->handle_response(request, response, static_cast<int64_t>(std::time(nullptr)));+ },+ [raw](const Request& request, const std::string& reason) {+ raw->in_progress.erase(request.uid);+ debug::log(WARN, "ancs: request failed: {}", reason);+ });+ }++ AncsClient::~AncsClient() {+ if (state_)+ state_->unsubscribe();+ }++ void AncsClient::set_device(const std::string& device_path) {+ if (state_->device_path == device_path)+ return;++ state_->unsubscribe();+ state_->device_path = device_path;+ state_->subscribed = false;+ state_->notification_source_path.clear();+ state_->control_point_path.clear();+ state_->data_source_path.clear();+ state_->next_discover = 0;+ state_->next_subscribe = 0;+ state_->next_probe = 0;+ state_->sequencer->reset();+ state_->in_progress.clear();+ // A new LE session replays the phone's backlog, so the next batch of+ // pre-existing notifications is a sync rather than news.+ state_->initial_sync = true;+ state_->registry.clear();+ {+ std::lock_guard<std::mutex> lock(state_->inbox);+ state_->pending_source.clear();+ state_->pending_data.clear();+ }++ if (device_path.empty())+ state_->set_status(false, "The iPhone is not connected over LE.");+ else+ state_->set_status(false, "Waiting for the iPhone's notification service.");+ }++ void AncsClient::set_content_enabled(bool enabled) { state_->content_enabled = enabled; }++ bool AncsClient::ready() const { return state_->ready; }++ const std::string& AncsClient::status_reason() const { return state_->reason; }++ const NotificationRegistry& AncsClient::registry() const { return state_->registry; }++ bool AncsClient::perform_action(uint32_t uid, ActionId action) {+ if (!state_->ready)+ return false;+ return state_->sequencer->submit(build_action_request(uid, action));+ }++ void AncsClient::tick(int64_t now) {+ auto* s = state_.get();+ if (s->device_path.empty())+ return;++ if (s->notification_source_path.empty()) {+ if (now < s->next_discover)+ return;+ s->next_discover = now + ANCS_RETRY_SECONDS;+ if (!s->discover()) {+ s->set_status(false, "Waiting for the iPhone's notification service.");+ return;+ }+ }++ if (!s->subscribed) {+ if (now < s->next_subscribe)+ return;+ s->next_subscribe = now + ANCS_RETRY_SECONDS;+ if (!s->subscribe()) {+ s->set_status(false, "Subscribing to the iPhone's notifications...");+ return;+ }+ s->subscribed = true;+ }++ // Drain what the GLib thread buffered.+ std::deque<std::vector<uint8_t>> source, data;+ {+ std::lock_guard<std::mutex> lock(s->inbox);+ source.swap(s->pending_source);+ data.swap(s->pending_data);+ }++ for (const auto& packet : data)+ s->sequencer->on_data_source(packet.data(), packet.size(), now);++ for (const auto& packet : source) {+ SourceEvent event;+ if (!parse_source_event(packet.data(), packet.size(), event)) {+ debug::log(WARN, "ancs: discarding a malformed notification packet");+ continue;+ }+ s->handle_source_event(event, now);+ }++ // The phone's backlog arrives immediately after subscribing, so once a+ // batch has been processed anything later is genuinely new.+ if (!source.empty())+ s->initial_sync = false;++ s->sequencer->tick(now);++ // A successful StartNotify proves only that the subscription exists, not+ // that iOS authorized notification access.+ if (!s->ready && now >= s->next_probe) {+ s->next_probe = now + ANCS_RETRY_SECONDS;+ s->set_status(false, "Waiting for notification access to be allowed on the iPhone.");+ s->sequencer->submit(build_app_request(APP_ID_MESSAGES));+ }+ }++} // namespace tether::bluetooth::ancsdiff --git a/src/core/src/bluetooth/ancs/notifications.cpp b/src/core/src/bluetooth/ancs/notifications.cppnew file mode 100644index 0000000..edaf418--- /dev/null+++ b/src/core/src/bluetooth/ancs/notifications.cpp@@ -0,0 +1,87 @@+#include "tether/bluetooth/ancs/notifications.hpp"++#include <algorithm>++namespace tether::bluetooth::ancs {++ namespace {+ constexpr size_t MAX_RETAINED = 200;+ } // namespace++ Decision NotificationRegistry::classify(const SourceEvent& event, bool initial) const {+ if (event.event == EventId::Removed)+ return Decision::Withdraw;++ if (initial && event.pre_existing())+ return Decision::Ignore;++ if (event.event == EventId::Modified)+ return Decision::Fetch;++ return seen_.count(event.uid) ? Decision::Ignore : Decision::Fetch;+ }++ void NotificationRegistry::remember(const SourceEvent& event) { seen_[event.uid] = 0; }++ void NotificationRegistry::forget(uint32_t uid) {+ seen_.erase(uid);+ notifications_.erase(uid);+ order_.erase(std::remove(order_.begin(), order_.end(), uid), order_.end());+ }++ void NotificationRegistry::clear() {+ seen_.clear();+ notifications_.clear();+ order_.clear();+ }++ void NotificationRegistry::store(const Notification& notification) {+ if (!notifications_.count(notification.uid))+ order_.push_back(notification.uid);+ notifications_[notification.uid] = notification;++ while (order_.size() > MAX_RETAINED) {+ const uint32_t oldest = order_.front();+ order_.erase(order_.begin());+ notifications_.erase(oldest);+ }+ }++ const Notification* NotificationRegistry::find(uint32_t uid) const {+ auto it = notifications_.find(uid);+ return it == notifications_.end() ? nullptr : &it->second;+ }++ std::vector<Notification> NotificationRegistry::recent(size_t limit) const {+ std::vector<Notification> out;+ for (auto it = order_.rbegin(); it != order_.rend() && out.size() < limit; ++it) {+ auto found = notifications_.find(*it);+ if (found != notifications_.end())+ out.push_back(found->second);+ }+ return out;+ }++ bool should_show_desktop_popup(const Notification& notification) {+ if (notification.app_id == APP_ID_MESSAGES)+ return false;+ return !notification.silent;+ }++ nlohmann::json to_json(const Notification& notification) {+ return {+ {"uid", notification.uid},+ {"app_id", notification.app_id},+ {"app_name", notification.app_name},+ {"title", notification.title},+ {"subtitle", notification.subtitle},+ {"body", notification.body},+ {"category", static_cast<int>(notification.category)},+ {"timestamp", notification.received},+ {"silent", notification.silent},+ {"positive_action", notification.has_positive_action},+ {"negative_action", notification.has_negative_action},+ };+ }++} // namespace tether::bluetooth::ancsdiff --git a/src/core/src/bluetooth/ancs/parser.cpp b/src/core/src/bluetooth/ancs/parser.cppnew file mode 100644index 0000000..c5a661a--- /dev/null+++ b/src/core/src/bluetooth/ancs/parser.cpp@@ -0,0 +1,144 @@+#include "tether/bluetooth/ancs/parser.hpp"++namespace tether::bluetooth::ancs {++ std::string Response::attribute(uint8_t id) const {+ for (const auto& attribute : attributes) {+ if (attribute.id == id)+ return attribute.value;+ }+ return {};+ }++ bool parse_source_event(const uint8_t* data, size_t length, SourceEvent& out) {+ // exactly eight bytes+ if (!data || length != 8)+ return false;++ if (data[0] > static_cast<uint8_t>(EventId::Removed))+ return false;++ out.event = static_cast<EventId>(data[0]);+ out.flags = data[1];+ out.category = static_cast<CategoryId>(data[2]);+ out.category_count = data[3];+ out.uid = static_cast<uint32_t>(data[4]) | (static_cast<uint32_t>(data[5]) << 8) |+ (static_cast<uint32_t>(data[6]) << 16) | (static_cast<uint32_t>(data[7]) << 24);+ return true;+ }++ void DataSourceAssembler::expect(CommandId command, std::vector<uint8_t> attribute_ids) {+ expecting_ = true;+ command_ = command;+ attribute_ids_ = std::move(attribute_ids);+ buffer_.clear();+ }++ void DataSourceAssembler::reset() {+ expecting_ = false;+ attribute_ids_.clear();+ buffer_.clear();+ }++ DataSourceAssembler::Result+ DataSourceAssembler::append(const uint8_t* data, size_t length, Response& out, std::string& err) {+ if (!expecting_) {+ err = "Data Source fragment arrived with no request in flight.";+ return Result::Error;+ }+ if (data && length)+ buffer_.insert(buffer_.end(), data, data + length);++ if (buffer_.size() > MAX_RESPONSE_BYTES) {+ err = "Data Source response exceeded the size limit.";+ reset();+ return Result::Error;+ }++ Result result = parse(out, err);+ if (result == Result::Complete) {+ expecting_ = false;+ attribute_ids_.clear();+ buffer_.clear();+ } else if (result == Result::Error) {+ reset();+ }+ return result;+ }++ DataSourceAssembler::Result DataSourceAssembler::parse(Response& out, std::string& err) {+ size_t at = 0;+ const size_t size = buffer_.size();++ if (size < 1)+ return Result::NeedMore;+ if (buffer_[0] != static_cast<uint8_t>(command_)) {+ err = "Data Source response does not echo the requested command.";+ return Result::Error;+ }+ at = 1;++ Response response;+ response.command = command_;++ if (command_ == CommandId::GetNotificationAttributes) {+ if (size < at + 4)+ return Result::NeedMore;+ response.uid = static_cast<uint32_t>(buffer_[at]) | (static_cast<uint32_t>(buffer_[at + 1]) << 8) |+ (static_cast<uint32_t>(buffer_[at + 2]) << 16) |+ (static_cast<uint32_t>(buffer_[at + 3]) << 24);+ at += 4;+ } else if (command_ == CommandId::GetAppAttributes) {+ // A NUL-terminated identifier, which may still be arriving.+ size_t nul = at;+ while (nul < size && buffer_[nul] != 0)+ ++nul;+ if (nul >= size)+ return Result::NeedMore;+ response.app_id.assign(buffer_.begin() + static_cast<long>(at), buffer_.begin() + static_cast<long>(nul));+ at = nul + 1;+ } else {+ err = "Data Source response for a command that returns none.";+ return Result::Error;+ }++ // Attributes come back in the order they were requested, so the count is+ // what marks the end of a response that declares no length.+ for (uint8_t expected_id : attribute_ids_) {+ if (size < at + 3)+ return Result::NeedMore;++ const uint8_t id = buffer_[at];+ const uint16_t declared =+ static_cast<uint16_t>(buffer_[at + 1]) | static_cast<uint16_t>(buffer_[at + 2] << 8);+ at += 3;++ if (id != expected_id) {+ err = "Data Source returned attributes out of order.";+ return Result::Error;+ }+ if (declared > MAX_ATTRIBUTE_LENGTH) {+ err = "Data Source attribute claimed an implausible length.";+ return Result::Error;+ }+ if (size < at + declared)+ return Result::NeedMore;++ Attribute attribute;+ attribute.id = id;+ attribute.value.assign(buffer_.begin() + static_cast<long>(at),+ buffer_.begin() + static_cast<long>(at + declared));+ response.attributes.push_back(std::move(attribute));+ at += declared;+ }++ if (at != size) {+ err = "Data Source response had unexpected trailing bytes.";+ return Result::Error;+ }++ out = std::move(response);+ return Result::Complete;+ }++} // namespace tether::bluetooth::ancsdiff --git a/src/core/src/bluetooth/ancs/sequencer.cpp b/src/core/src/bluetooth/ancs/sequencer.cppnew file mode 100644index 0000000..c22aa22--- /dev/null+++ b/src/core/src/bluetooth/ancs/sequencer.cpp@@ -0,0 +1,153 @@+#include "tether/bluetooth/ancs/sequencer.hpp"++namespace tether::bluetooth::ancs {++ namespace {++ void append_u32_le(std::vector<uint8_t>& out, uint32_t value) {+ out.push_back(static_cast<uint8_t>(value & 0xff));+ out.push_back(static_cast<uint8_t>((value >> 8) & 0xff));+ out.push_back(static_cast<uint8_t>((value >> 16) & 0xff));+ out.push_back(static_cast<uint8_t>((value >> 24) & 0xff));+ }++ void append_u16_le(std::vector<uint8_t>& out, uint16_t value) {+ out.push_back(static_cast<uint8_t>(value & 0xff));+ out.push_back(static_cast<uint8_t>((value >> 8) & 0xff));+ }++ uint16_t cap_for(NotificationAttributeId id) {+ return id == NotificationAttributeId::Message ? MAX_BODY_LENGTH : MAX_TITLE_LENGTH;+ }++ } // namespace++ ControlPointSequencer::ControlPointSequencer(WriteFn write, CompleteFn on_complete, FailFn on_fail)+ : write_(std::move(write)), on_complete_(std::move(on_complete)), on_fail_(std::move(on_fail)) {}++ bool ControlPointSequencer::submit(Request request) {+ if (queue_.size() >= MAX_QUEUED_REQUESTS)+ return false;+ queue_.push_back(std::move(request));+ return true;+ }++ void ControlPointSequencer::start_next(int64_t now) {+ while (!in_flight_ && !queue_.empty()) {+ current_ = std::move(queue_.front());+ queue_.pop_front();++ const bool expects_response = !current_.attribute_ids.empty();+ if (expects_response) {+ assembler_.expect(current_.command, current_.attribute_ids);+ in_flight_ = true;+ deadline_ = now + REQUEST_TIMEOUT_SECONDS;+ }++ if (!write_ || !write_(current_.payload)) {+ in_flight_ = false;+ assembler_.reset();+ if (on_fail_)+ on_fail_(current_, "Could not write to the ANCS control point.");+ continue;+ }++ if (expects_response)+ return;++ if (on_complete_) {+ Response acknowledged;+ acknowledged.command = current_.command;+ acknowledged.uid = current_.uid;+ on_complete_(current_, acknowledged);+ }+ }+ }++ void ControlPointSequencer::tick(int64_t now) {+ if (in_flight_ && now >= deadline_) {+ Request timed_out = current_;+ in_flight_ = false;+ assembler_.reset();+ if (on_fail_)+ on_fail_(timed_out, "The phone did not answer within the timeout.");+ }+ start_next(now);+ }++ void ControlPointSequencer::on_data_source(const uint8_t* data, size_t length, int64_t now) {+ if (!in_flight_)+ return;++ Response response;+ std::string err;+ switch (assembler_.append(data, length, response, err)) {+ case DataSourceAssembler::Result::NeedMore:+ return;+ case DataSourceAssembler::Result::Complete: {+ Request done = current_;+ in_flight_ = false;+ if (on_complete_)+ on_complete_(done, response);+ break;+ }+ case DataSourceAssembler::Result::Error: {+ Request failed = current_;+ in_flight_ = false;+ if (on_fail_)+ on_fail_(failed, err);+ break;+ }+ }+ start_next(now);+ }++ void ControlPointSequencer::reset() {+ queue_.clear();+ in_flight_ = false;+ assembler_.reset();+ }++ Request build_notification_request(uint32_t uid, const std::vector<NotificationAttributeId>& attributes) {+ Request request;+ request.command = CommandId::GetNotificationAttributes;+ request.uid = uid;++ request.payload.push_back(static_cast<uint8_t>(CommandId::GetNotificationAttributes));+ append_u32_le(request.payload, uid);+ for (NotificationAttributeId id : attributes) {+ request.payload.push_back(static_cast<uint8_t>(id));+ // Only the three text attributes take a length, and for them it is+ // mandatory; sending one for the others corrupts the request.+ if (attribute_takes_length(id))+ append_u16_le(request.payload, cap_for(id));+ request.attribute_ids.push_back(static_cast<uint8_t>(id));+ }+ return request;+ }++ Request build_app_request(const std::string& app_id) {+ Request request;+ request.command = CommandId::GetAppAttributes;++ request.payload.push_back(static_cast<uint8_t>(CommandId::GetAppAttributes));+ request.payload.insert(request.payload.end(), app_id.begin(), app_id.end());+ request.payload.push_back(0);+ request.payload.push_back(static_cast<uint8_t>(AppAttributeId::DisplayName));+ request.attribute_ids.push_back(static_cast<uint8_t>(AppAttributeId::DisplayName));+ return request;+ }++ Request build_action_request(uint32_t uid, ActionId action) {+ Request request;+ request.command = CommandId::PerformNotificationAction;+ request.uid = uid;++ request.payload.push_back(static_cast<uint8_t>(CommandId::PerformNotificationAction));+ append_u32_le(request.payload, uid);+ request.payload.push_back(static_cast<uint8_t>(action));++ return request;+ }++} // namespace tether::bluetooth::ancsdiff --git a/src/core/src/bluetooth/bearer_supervisor.cpp b/src/core/src/bluetooth/bearer_supervisor.cppnew file mode 100644index 0000000..cc6ed77--- /dev/null+++ b/src/core/src/bluetooth/bearer_supervisor.cpp@@ -0,0 +1,129 @@+#include "tether/bluetooth/bearer_supervisor.hpp"+#include "tether/log.hpp"++#include <algorithm>++namespace tether::bluetooth {++ namespace {++ int grow_backoff(int current) {+ if (current <= 0)+ return BEARER_BACKOFF_MIN_SECONDS;+ return std::min(current * 2, BEARER_BACKOFF_MAX_SECONDS);+ }++ // BlueZ answers InProgress while one of its own connect operations is+ // still pending on the device. That clears on its own, unlike a refusal+ // from the phone, so backing off for minutes leaves the link down long+ // after the reason for it is gone.+ bool is_transient(const std::string& err) {+ return err.find("org.bluez.Error.InProgress") != std::string::npos;+ }++ int next_backoff(int current, const std::string& err) {+ return is_transient(err) ? BEARER_BACKOFF_MIN_SECONDS : grow_backoff(current);+ }++ } // namespace++ BearerSupervisor::BearerSupervisor(BearerOps& ops, bool ancs_enabled) : ops_(ops), ancs_enabled_(ancs_enabled) {}++ void BearerSupervisor::set_ancs_enabled(bool enabled) { ancs_enabled_ = enabled; }++ void BearerSupervisor::reset() {+ classic_connected_since_ = -1;+ next_classic_attempt_ = 0;+ next_le_attempt_ = 0;+ status_.classic_backoff = 0;+ status_.le_backoff = 0;+ }++ bool BearerSupervisor::tick(int64_t now) {+ BearerStatus previous = status_;++ status_.device_present = ops_.device_present();+ status_.device_paired = status_.device_present && ops_.device_paired();+ if (!status_.device_present || !status_.device_paired) {+ status_.classic_connected = false;+ status_.le_connected = false;+ status_.le_available = false;+ classic_connected_since_ = -1;+ status_.reason = status_.device_present ? "iPhone is not paired." : "iPhone not known to BlueZ.";+ return !(status_ == previous);+ }++ status_.classic_connected = ops_.classic_connected();+ status_.le_available = ops_.le_bearer_available();+ status_.le_connected = status_.le_available && ops_.le_connected();++ if (status_.classic_connected) {+ if (classic_connected_since_ < 0)+ classic_connected_since_ = now;+ status_.classic_backoff = 0;+ } else {+ // A dropped link invalidates the settle window and any LE state that+ // depended on it.+ classic_connected_since_ = -1;+ status_.le_connected = false;++ if (now >= next_classic_attempt_) {+ ops_.set_preferred_bearer("bredr");+ std::string err;+ if (ops_.connect_classic(err)) {+ status_.classic_backoff = 0;+ next_classic_attempt_ = 0;+ } else {+ status_.classic_backoff = next_backoff(status_.classic_backoff, err);+ next_classic_attempt_ = now + status_.classic_backoff;+ debug::log(+ WARN, "bluetooth: BR/EDR connect failed ({}), retrying in {}s", err, status_.classic_backoff);+ }+ }+ status_.reason = "Connecting to the iPhone over Bluetooth...";+ return !(status_ == previous);+ }++ // Classic is up. LE is only worth attempting once the ACL has settled.+ if (!ancs_enabled_) {+ status_.reason = "Connected. Notification mirroring is disabled.";+ return !(status_ == previous);+ }++ if (!status_.le_available) {+ status_.reason = "Connected. BlueZ is not exposing an LE bearer, so notifications are unavailable.";+ return !(status_ == previous);+ }++ if (!status_.le_connected) {+ const bool settled =+ classic_connected_since_ >= 0 && now - classic_connected_since_ >= BEARER_SETTLE_SECONDS;+ if (settled && now >= next_le_attempt_) {+ // Select LE only for this attempt, then hand the preference back+ // so LE is never left preferred while idle.+ ops_.set_preferred_bearer("le");+ std::string err;+ const bool ok = ops_.connect_le(err);+ ops_.set_preferred_bearer("bredr");++ if (ok) {+ status_.le_backoff = 0;+ next_le_attempt_ = 0;+ status_.le_connected = true;+ } else {+ status_.le_backoff = next_backoff(status_.le_backoff, err);+ next_le_attempt_ = now + status_.le_backoff;+ debug::log(WARN, "bluetooth: LE connect failed ({}), retrying in {}s", err, status_.le_backoff);+ }+ }+ if (!status_.le_connected) {+ status_.reason = "Connected. Bringing up the LE link for notifications...";+ return !(status_ == previous);+ }+ }++ status_.reason = "Connected over BR/EDR and LE.";+ return !(status_ == previous);+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/bmessage.cpp b/src/core/src/bluetooth/bmessage.cppnew file mode 100644index 0000000..3cdd221--- /dev/null+++ b/src/core/src/bluetooth/bmessage.cpp@@ -0,0 +1,440 @@+#include "tether/bluetooth/bmessage.hpp"+#include "tether/bluetooth/vcard.hpp"++#include <algorithm>+#include <cctype>+#include <cstdio>+#include <ctime>++namespace tether::bluetooth {++ namespace {++ std::string trim(const std::string& text) {+ size_t begin = text.find_first_not_of(" \t\r\n");+ if (begin == std::string::npos)+ return {};+ size_t end = text.find_last_not_of(" \t\r\n");+ return text.substr(begin, end - begin + 1);+ }++ std::string upper(std::string text) {+ std::transform(text.begin(), text.end(), text.begin(), [](unsigned char c) {+ return static_cast<char>(std::toupper(c));+ });+ return text;+ }++ // Splits on LF and drops a trailing CR, so CRLF and LF payloads parse the+ // same way.+ std::vector<std::string> split_lines(const std::string& text) {+ std::vector<std::string> lines;+ size_t start = 0;+ while (start <= text.size()) {+ size_t nl = text.find('\n', start);+ if (nl == std::string::npos) {+ lines.push_back(text.substr(start));+ break;+ }+ std::string line = text.substr(start, nl - start);+ if (!line.empty() && line.back() == '\r')+ line.pop_back();+ lines.push_back(std::move(line));+ start = nl + 1;+ }+ return lines;+ }++ // The vCards embedded in a bMessage are the same grammar PBAP delivers,+ // so both share one implementation.+ using tether::bluetooth::vcard_name_from_n;+ using tether::bluetooth::vcard_split_property;++ // Reads one BEGIN:VCARD..END:VCARD block starting at `index`, which must+ // point at the BEGIN line. Leaves `index` on the END line.+ VCardParty read_vcard(const std::vector<std::string>& lines, size_t& index) {+ VCardParty party;+ std::string structured_name;++ for (++index; index < lines.size(); ++index) {+ const std::string line = trim(lines[index]);+ if (upper(line) == "END:VCARD")+ break;++ std::string name, value;+ if (!vcard_split_property(line, name, value) || value.empty())+ continue;++ if (name == "TEL" && party.tel.empty())+ party.tel = value;+ else if (name == "EMAIL" && party.email.empty())+ party.email = value;+ else if (name == "FN")+ party.name = value;+ else if (name == "N")+ structured_name = vcard_name_from_n(value);+ }++ if (party.name.empty())+ party.name = structured_name;+ return party;+ }++ // True when the line is a structural token possibly already behind some+ // stuffing spaces. Looking past every leading space, rather than just+ // one, is what makes stuffing and unstuffing exact inverses: a body line+ // of " BEGIN:MSG" is stuffed to " BEGIN:MSG" and has to come back with+ // its own space intact.+ bool is_stuffable_token(const std::string& line) {+ size_t at = line.find_first_not_of(' ');+ if (at == std::string::npos)+ return false;+ const std::string token = upper(line.substr(at));+ return token.rfind("BEGIN:", 0) == 0 || token.rfind("END:", 0) == 0;+ }++ // MAP byte-stuffing: a body line that would otherwise look like a+ // structural token is prefixed with a space by the sender.+ std::string unstuff(const std::string& line) {+ if (!line.empty() && line[0] == ' ' && is_stuffable_token(line))+ return line.substr(1);+ return line;+ }++ } // namespace++ BMessage parse_bmessage(const std::string& text) {+ BMessage message;+ if (text.empty())+ return message;++ const std::vector<std::string> lines = split_lines(text);++ bool seen_begin = false;+ int envelope_depth = 0;+ bool in_body = false;+ bool in_msg = false;+ std::vector<std::string> body_lines;++ for (size_t i = 0; i < lines.size(); ++i) {+ const std::string raw = lines[i];+ const std::string line = trim(raw);+ const std::string token = upper(line);++ // Inside MSG everything is payload until the closing token, so the+ // body is captured before any structural interpretation.+ //+ // The terminator must be matched against the *raw* line: byte-stuffing+ // marks a literal "END:MSG" in the body with a leading space, and+ // trimming first would make it end the body instead.+ if (in_msg) {+ const bool stuffed = !raw.empty() && raw[0] == ' ';+ if (!stuffed && token == "END:MSG") {+ in_msg = false;+ continue;+ }+ body_lines.push_back(unstuff(raw));+ continue;+ }++ if (token == "BEGIN:BMSG") {+ seen_begin = true;+ continue;+ }+ if (token == "END:BMSG")+ break;+ if (token == "BEGIN:BENV") {+ ++envelope_depth;+ continue;+ }+ if (token == "END:BENV") {+ if (envelope_depth > 0)+ --envelope_depth;+ continue;+ }+ if (token == "BEGIN:BBODY") {+ in_body = true;+ continue;+ }+ if (token == "END:BBODY") {+ in_body = false;+ continue;+ }+ if (token == "BEGIN:MSG") {+ in_msg = true;+ continue;+ }++ if (token == "BEGIN:VCARD") {+ VCardParty party = read_vcard(lines, i);+ // The originator sits outside BENV; recipients sit inside it.+ if (envelope_depth == 0) {+ if (message.originator.empty())+ message.originator = party;+ } else if (!party.empty()) {+ message.recipients.push_back(std::move(party));+ }+ continue;+ }++ if (in_body)+ continue;++ std::string name, value;+ if (!vcard_split_property(line, name, value))+ continue;+ if (name == "STATUS")+ message.read = upper(value) == "READ";+ else if (name == "TYPE")+ message.type = value;+ else if (name == "FOLDER")+ message.folder = value;+ }++ // Join without a trailing newline; the body is displayed, not re-emitted.+ for (size_t i = 0; i < body_lines.size(); ++i) {+ if (i)+ message.body += "\n";+ message.body += body_lines[i];+ }+ // Trailing blank lines are an artifact of the container, not content.+ while (!message.body.empty() && (message.body.back() == '\n' || message.body.back() == '\r'))+ message.body.pop_back();++ message.valid = seen_begin;+ return message;+ }++ std::string normalize_phone(const std::string& raw) {+ std::string out;+ bool first = true;+ for (char c : raw) {+ if (std::isdigit(static_cast<unsigned char>(c))) {+ out += c;+ } else if (c == '+' && first && out.empty()) {+ out += c;+ }+ if (!std::isspace(static_cast<unsigned char>(c)))+ first = false;+ }+ return out;+ }++ std::string normalize_email(const std::string& raw) {+ std::string out = trim(raw);+ std::transform(+ out.begin(), out.end(), out.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); });+ return out;+ }++ std::string thread_key_for(const VCardParty& party) {+ // A phone number wins when both are present: it is what the phone routes+ // SMS on, and it is the more stable of the two.+ if (!party.tel.empty()) {+ std::string tel = normalize_phone(party.tel);+ if (!tel.empty())+ return "tel:" + tel;+ }+ if (!party.email.empty()) {+ std::string email = normalize_email(party.email);+ if (!email.empty())+ return "email:" + email;+ }+ return {};+ }++ namespace {++ // Anything below 0x20, plus DEL. CR and LF are the injection vector, but+ // no control character has a legitimate place in an address.+ bool has_control_character(const std::string& text) {+ for (unsigned char c : text) {+ if (c < 0x20 || c == 0x7f)+ return true;+ }+ return false;+ }++ // ';' separates vCard parameters, ':' ends the property name, ',' and '\'+ // are value delimiters and the escape character.+ bool has_vcard_delimiter(const std::string& text) { return text.find_first_of(";:,\\") != std::string::npos; }++ // Longer than any real address; a bound keeps a pathological value from+ // reaching the phone at all.+ constexpr size_t MAX_ADDRESS_LENGTH = 254;++ // A line already beginning with spaces is stuffed again, so a body+ // containing " BEGIN:X" survives the receiver's unstuffing instead of+ // silently losing its leading space.+ bool line_needs_stuffing(const std::string& line) { return is_stuffable_token(line); }++ } // namespace++ bool validate_recipient(const Recipient& recipient, std::string& err_out) {+ const std::string& address = recipient.address;++ if (address.empty()) {+ err_out = "Recipient address is empty.";+ return false;+ }+ if (address.size() > MAX_ADDRESS_LENGTH) {+ err_out = "Recipient address is too long.";+ return false;+ }+ if (has_control_character(address)) {+ err_out = "Recipient address contains a control character.";+ return false;+ }+ if (has_vcard_delimiter(address)) {+ err_out = "Recipient address contains a vCard delimiter.";+ return false;+ }++ if (recipient.kind == RecipientKind::Tel) {+ bool digit = false;+ for (char c : address) {+ if (std::isdigit(static_cast<unsigned char>(c))) {+ digit = true;+ continue;+ }+ // The punctuation people actually write numbers with, and nothing+ // else. '+' is only meaningful leading, but it is harmless+ // anywhere and the phone is the authority on the rest.+ if (c == '+' || c == '-' || c == '(' || c == ')' || c == ' ' || c == '.')+ continue;+ err_out = "Phone number contains an unexpected character.";+ return false;+ }+ if (!digit) {+ err_out = "Phone number contains no digits.";+ return false;+ }+ return true;+ }++ const size_t at = address.find('@');+ if (at == std::string::npos || address.find('@', at + 1) != std::string::npos) {+ err_out = "Email address must contain exactly one '@'.";+ return false;+ }+ if (at == 0 || at + 1 >= address.size()) {+ err_out = "Email address is missing a local part or a domain.";+ return false;+ }+ if (address.find(' ') != std::string::npos) {+ err_out = "Email address contains a space.";+ return false;+ }+ return true;+ }++ bool recipient_from_thread_key(const std::string& thread_key, Recipient& out, std::string& err_out) {+ if (thread_key.rfind("tel:", 0) == 0) {+ out.kind = RecipientKind::Tel;+ out.address = thread_key.substr(4);+ } else if (thread_key.rfind("email:", 0) == 0) {+ out.kind = RecipientKind::Email;+ out.address = thread_key.substr(6);+ } else {+ err_out = "Unsupported conversation type; only one-to-one threads can be replied to.";+ return false;+ }+ return validate_recipient(out, err_out);+ }++ std::string stuff_body(const std::string& body) {+ std::string out;+ for (const std::string& line : split_lines(body)) {+ if (line_needs_stuffing(line))+ out += ' ';+ out += line;+ out += "\r\n";+ }+ // split_lines yields a trailing empty element for a body ending in a+ // newline; drop the extra break it would introduce.+ if (!body.empty() && body.back() != '\n' && out.size() >= 2)+ out.erase(out.size() - 2);+ return out;+ }++ std::string build_bmessage(const std::vector<Recipient>& recipients, const std::string& body) {+ if (recipients.empty())+ return {};+ for (const auto& recipient : recipients) {+ std::string err;+ if (!validate_recipient(recipient, err))+ return {};+ }++ const std::string stuffed = stuff_body(body);+ std::string message_block = "BEGIN:MSG\r\n";+ message_block += stuffed;+ if (!stuffed.empty())+ message_block += "\r\n";+ message_block += "END:MSG\r\n";++ std::string out;+ out += "BEGIN:BMSG\r\n";+ out += "VERSION:1.0\r\n";+ out += "STATUS:UNREAD\r\n";+ // Always SMS_GSM, even for an Apple-ID recipient; iOS picks the transport.+ out += "TYPE:SMS_GSM\r\n";+ out += "FOLDER:telecom/msg/outbox\r\n";++ // The originator vCard is empty and sits outside the envelope: the phone+ // fills in its own identity.+ out += "BEGIN:VCARD\r\n";+ out += "VERSION:3.0\r\n";+ out += "N:\r\n";+ out += "END:VCARD\r\n";++ out += "BEGIN:BENV\r\n";+ for (const auto& recipient : recipients) {+ out += "BEGIN:VCARD\r\n";+ out += "VERSION:3.0\r\n";+ out += "N:\r\n";+ out += (recipient.kind == RecipientKind::Tel ? "TEL:" : "EMAIL:");+ out += recipient.address;+ out += "\r\n";+ out += "END:VCARD\r\n";+ }++ out += "BEGIN:BBODY\r\n";+ out += "CHARSET:UTF-8\r\n";+ // LENGTH counts the whole message block, delimiters included.+ out += "LENGTH:" + std::to_string(message_block.size()) + "\r\n";+ out += message_block;+ out += "END:BBODY\r\n";+ out += "END:BENV\r\n";+ out += "END:BMSG\r\n";+ return out;+ }++ int64_t parse_map_timestamp(const std::string& text) {+ // Basic ISO 8601: YYYYMMDDTHHMMSS, optionally followed by Z or an offset.+ if (text.size() < 15 || text[8] != 'T')+ return 0;++ std::tm tm{};+ int year = 0, month = 0, day = 0, hour = 0, minute = 0, second = 0;+ if (std::sscanf(text.c_str(), "%4d%2d%2dT%2d%2d%2d", &year, &month, &day, &hour, &minute, &second) != 6)+ return 0;+ if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 23 || minute > 59 || second > 60)+ return 0;++ tm.tm_year = year - 1900;+ tm.tm_mon = month - 1;+ tm.tm_mday = day;+ tm.tm_hour = hour;+ tm.tm_min = minute;+ tm.tm_sec = second;+ tm.tm_isdst = -1;++ // A trailing Z means UTC; anything else is local time on the phone, which+ // is the same zone as the desktop in every case worth supporting.+ const bool utc = text.size() > 15 && (text[15] == 'Z' || text[15] == 'z');+ const std::time_t epoch = utc ? timegm(&tm) : std::mktime(&tm);+ return epoch == static_cast<std::time_t>(-1) ? 0 : static_cast<int64_t>(epoch);+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/config.cpp b/src/core/src/bluetooth/config.cppnew file mode 100644index 0000000..4919d31--- /dev/null+++ b/src/core/src/bluetooth/config.cpp@@ -0,0 +1,115 @@+#include "tether/bluetooth/config.hpp"+#include "tether/log.hpp"++#include <cstdlib>+#include <filesystem>+#include <fstream>+#include <nlohmann/json.hpp>+#include <pwd.h>+#include <unistd.h>++namespace tether::bluetooth {++ namespace {++ std::string home_dir() {+ if (const char* home = getenv("HOME"); home && *home)+ return home;+ if (const passwd* pw = getpwuid(getuid()); pw && pw->pw_dir)+ return pw->pw_dir;+ return {};+ }++ } // namespace++ const char* to_string(AuthStrategy strategy) {+ return strategy == AuthStrategy::ExplicitPair ? "explicit-pair" : "connect-first";+ }++ AuthStrategy auth_strategy_from_string(const std::string& value) {+ return value == "explicit-pair" ? AuthStrategy::ExplicitPair : AuthStrategy::ConnectFirst;+ }++ std::string config_path() {+ std::string home = home_dir();+ if (home.empty())+ return {};+ return (std::filesystem::path(home) / ".config" / "tether" / "bluetooth.json").string();+ }++ std::string serialize_config(const Config& config) {+ nlohmann::json j;+ j["device_address"] = config.device_address;+ j["auth_strategy"] = to_string(config.auth_strategy);+ j["ancs_enabled"] = config.ancs_enabled;+ j["ancs_content_enabled"] = config.ancs_content_enabled;+ j["group_messages_enabled"] = config.group_messages_enabled;+ return j.dump(2);+ }++ Config deserialize_config(const std::string& text) {+ Config config;+ try {+ auto j = nlohmann::json::parse(text);+ if (!j.is_object())+ return config;+ config.device_address = j.value("device_address", "");+ config.auth_strategy = auth_strategy_from_string(j.value("auth_strategy", ""));+ config.ancs_enabled = j.value("ancs_enabled", true);+ config.ancs_content_enabled = j.value("ancs_content_enabled", false);+ config.group_messages_enabled = j.value("group_messages_enabled", false);+ } catch (const std::exception&) {+ // A corrupt file must not stop the daemon; defaults are safe.+ }+ return config;+ }++ Config load_config() {+ std::string path = config_path();+ if (path.empty())+ return {};+ std::ifstream in(path);+ if (!in.is_open())+ return {};+ std::string text((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());+ return deserialize_config(text);+ }++ bool save_config(const Config& config) {+ std::string path = config_path();+ if (path.empty())+ return false;++ std::error_code ec;+ std::filesystem::create_directories(std::filesystem::path(path).parent_path(), ec);++ // Write-then-rename so a crash mid-write cannot leave a truncated config,+ // matching how Crypto persists known_hosts.json.+ std::string tmp = path + ".tmp";+ {+ std::ofstream out(tmp, std::ios::trunc);+ if (!out.is_open()) {+ debug::log(ERR, "bluetooth: cannot write {}", tmp);+ return false;+ }+ out << serialize_config(config);+ if (!out) {+ debug::log(ERR, "bluetooth: failed writing {}", tmp);+ return false;+ }+ }++ std::filesystem::permissions(tmp,+ std::filesystem::perms::owner_read | std::filesystem::perms::owner_write,+ std::filesystem::perm_options::replace,+ ec);+ std::filesystem::rename(tmp, path, ec);+ if (ec) {+ debug::log(ERR, "bluetooth: cannot replace {}: {}", path, ec.message());+ std::filesystem::remove(tmp, ec);+ return false;+ }+ return true;+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/connection.cpp b/src/core/src/bluetooth/connection.cppnew file mode 100644index 0000000..c06b6bc--- /dev/null+++ b/src/core/src/bluetooth/connection.cpp@@ -0,0 +1,792 @@+#include "tether/bluetooth/connection.hpp"+#include "tether/bluetooth/ancs/client.hpp"+#include "tether/bluetooth/config.hpp"+#include "tether/bluetooth/contacts.hpp"+#include "tether/bluetooth/groups.hpp"+#include "tether/bluetooth/journal.hpp"+#include "tether/bluetooth/map_session.hpp"+#include "tether/bluetooth/monitor.hpp"+#include "tether/bluetooth/pbap_session.hpp"+#include "tether/log.hpp"++#include <atomic>+#include <chrono>+#include <condition_variable>+#include <ctime>+#include <gio/gio.h>+#include <mutex>+#include <thread>++namespace tether::bluetooth {++ ConnectionManager* g_bt_connections = nullptr;++ namespace {+ MessageStore g_messages;+ std::mutex g_messages_mutex;+ MessageJournal g_journal;+ std::mutex g_map_mutex;+ std::shared_ptr<MapSession> g_map_session;++ std::mutex g_group_mutex;+ GroupCorrelator g_correlator;+ GroupRoster g_rosters;+ std::map<std::string, GroupInfo> g_group_info;+ std::atomic<bool> g_group_replies_enabled{false};++ // MAP folders are navigated from the session root one level at a time.+ constexpr const char* MAP_INBOX = "telecom/msg/inbox";+ constexpr const char* MAP_OUTBOX = "telecom/msg/outbox";+ } // namespace++ MessageStore& message_store() { return g_messages; }+ std::mutex& message_store_mutex() { return g_messages_mutex; }++ bool send_message(const std::string& thread_key, const std::string& body, Message& sent_out, std::string& err_out) {+ if (body.empty()) {+ err_out = "Nothing to send.";+ return false;+ }++ std::vector<Recipient> recipients;+ if (thread_key.rfind("group:", 0) == 0) {+ GroupInfo info;+ GroupRoster rosters;+ {+ std::lock_guard<std::mutex> lock(g_group_mutex);+ auto found = g_group_info.find(thread_key);+ if (found != g_group_info.end())+ info = found->second;+ rosters = g_rosters;+ }+ const ReplyEligibility eligibility = resolve_group_recipients(+ info, thread_key, contact_store(), rosters, g_group_replies_enabled, recipients, err_out);+ if (eligibility != ReplyEligibility::Allowed)+ return false;+ } else {+ Recipient recipient;+ if (!recipient_from_thread_key(thread_key, recipient, err_out))+ return false;+ recipients.push_back(recipient);+ }++ std::shared_ptr<MapSession> session;+ {+ std::lock_guard<std::mutex> lock(g_map_mutex);+ session = g_map_session;+ }+ if (!session) {+ err_out = "Messages are not connected.";+ return false;+ }++ const std::string bmessage = build_bmessage(recipients, body);+ if (bmessage.empty()) {+ err_out = "Could not build a message for this conversation.";+ return false;+ }++ if (!session->push_message(MAP_OUTBOX, bmessage, err_out))+ return false;++ Message sent;+ sent.handle = "local-" + std::to_string(std::time(nullptr)) + "-" + std::to_string(g_messages.size());+ sent.thread_key = thread_key;+ sent.peer_address = recipients.size() == 1 ? recipients.front().address : std::string{};+ sent.body = body;+ sent.timestamp = static_cast<int64_t>(std::time(nullptr));+ sent.outgoing = true;+ sent.read = true;+ sent.folder = "outbox";++ {+ std::lock_guard<std::mutex> lock(g_messages_mutex);+ g_messages.add(sent);+ g_journal.append(sent);+ }+ sent_out = sent;+ return true;+ }++ void observe_message_notification(const std::string& sender,+ const std::string& subtitle,+ const std::string& body,+ int64_t now) {+ std::lock_guard<std::mutex> lock(g_group_mutex);+ g_correlator.observe({sender, subtitle, body, now});+ g_correlator.expire(now);+ }++ ReplyEligibility group_reply_status(const std::string& thread_key, std::string& reason) {+ GroupInfo info;+ GroupRoster rosters;+ {+ std::lock_guard<std::mutex> lock(g_group_mutex);+ auto found = g_group_info.find(thread_key);+ if (found != g_group_info.end())+ info = found->second;+ rosters = g_rosters;+ }+ std::vector<Recipient> recipients;+ return resolve_group_recipients(+ info, thread_key, contact_store(), rosters, g_group_replies_enabled, recipients, reason);+ }++ void set_group_replies_enabled(bool enabled) {+ std::lock_guard<std::mutex> lock(g_group_mutex);+ g_group_replies_enabled = enabled;+ }++ void reload_group_rosters() {+ std::lock_guard<std::mutex> lock(g_group_mutex);+ g_rosters = load_rosters();+ }++ bool mark_message_read(const std::string& handle, bool read, std::string& err_out) {+ std::shared_ptr<MapSession> session;+ {+ std::lock_guard<std::mutex> lock(g_map_mutex);+ session = g_map_session;+ }+ if (!session) {+ err_out = "Messages are not connected.";+ return false;+ }++ // The stored path is what obexd currently answers on. A message replayed+ // from the journal has none until the phone lists it again this session.+ std::string object_path;+ {+ std::lock_guard<std::mutex> lock(g_messages_mutex);+ if (const Message* message = g_messages.find(handle))+ object_path = message->object_path;+ }+ if (object_path.empty()) {+ err_out = "That message is not available in the current session yet.";+ return false;+ }++ // write through to the phone first; only mirror locally once it took.+ if (!session->set_read(object_path, read, err_out))+ return false;+ std::lock_guard<std::mutex> lock(g_messages_mutex);+ g_messages.set_read(handle, read);+ return true;+ }++ namespace {++ constexpr const char* BLUEZ_NAME = "org.bluez";+ constexpr const char* IFACE_DEVICE = "org.bluez.Device1";+ constexpr const char* IFACE_BEARER_LE = "org.bluez.Bearer.LE1";+ constexpr const char* IFACE_PROPS = "org.freedesktop.DBus.Properties";++ constexpr const char* OBEX_NAME = "org.bluez.obex";+ constexpr const char* OBEX_ROOT = "/org/bluez/obex";+ constexpr const char* OBEX_CLIENT = "org.bluez.obex.Client1";++ constexpr int CONNECT_TIMEOUT_MS = 30000;++ constexpr int MESSAGE_POLL_SECONDS = 15;+ constexpr int MESSAGE_LIST_MAX = 200;+ constexpr int SUPERVISOR_TICK_SECONDS = 1;++ std::string normalize_address(std::string address) {+ for (char& c : address)+ c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));+ return address;+ }++ // Bearer operations backed by BlueZ on the system bus.+ class BluezBearerOps : public BearerOps {+ public:+ BluezBearerOps(BluezMonitor& monitor, std::string address)+ : monitor_(monitor), address_(normalize_address(std::move(address))) {}++ void set_address(const std::string& address) { address_ = normalize_address(address); }++ bool device_present() const override { return lookup().has_value(); }++ bool device_paired() const override {+ auto device = lookup();+ return device && device->paired;+ }++ bool classic_connected() const override {+ auto device = lookup();+ return device && device->connected;+ }++ bool le_bearer_available() const override {+ auto device = lookup();+ return device && device->has_le_bearer;+ }++ bool le_connected() const override {+ auto device = lookup();+ return device && device->le_connected;+ }++ void set_preferred_bearer(const std::string& bearer) override {+ auto device = lookup();+ if (!device)+ return;+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(+ monitor_.connection(),+ BLUEZ_NAME,+ device->path.c_str(),+ IFACE_PROPS,+ "Set",+ g_variant_new("(ssv)", IFACE_DEVICE, "PreferredBearer", g_variant_new_string(bearer.c_str())),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ 5000,+ nullptr,+ &error);+ if (reply)+ g_variant_unref(reply);+ // Absent on older BlueZ; not having it is not an error.+ g_clear_error(&error);+ }++ bool connect_classic(std::string& err) override {+ auto device = lookup();+ if (!device) {+ err = "device not present";+ return false;+ }+ return call(device->path, IFACE_DEVICE, "Connect", err);+ }++ bool connect_le(std::string& err) override {+ auto device = lookup();+ if (!device) {+ err = "device not present";+ return false;+ }+ if (!device->has_le_bearer) {+ err = "no LE bearer";+ return false;+ }+ return call(device->path, IFACE_BEARER_LE, "Connect", err);+ }++ private:+ std::optional<Device> lookup() const {+ for (const auto& device : monitor_.snapshot().devices) {+ if (normalize_address(device.address) == address_)+ return device;+ }+ return std::nullopt;+ }++ bool call(const std::string& path, const char* iface, const char* method, std::string& err) {+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(monitor_.connection(),+ BLUEZ_NAME,+ path.c_str(),+ iface,+ method,+ nullptr,+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ CONNECT_TIMEOUT_MS,+ nullptr,+ &error);+ if (!reply) {+ err = error ? error->message : "unknown error";+ g_clear_error(&error);+ return false;+ }+ g_variant_unref(reply);+ return true;+ }++ BluezMonitor& monitor_;+ std::string address_;+ };++ // OBEX sessions live on the session bus, not the system bus.+ class ObexProfileOps : public ProfileOps {+ public:+ explicit ObexProfileOps(std::string address) : address_(normalize_address(std::move(address))) {}++ ~ObexProfileOps() override { g_clear_object(&conn_); }++ void set_address(const std::string& address) { address_ = normalize_address(address); }++ // The MAP session driver reuses this connection rather than opening a+ // second one to the same bus.+ GDBusConnection* bus() const { return conn_; }++ std::string create_session(const std::string& target, std::string& err) override {+ if (!ensure_connection(err))+ return {};++ GVariantBuilder args;+ g_variant_builder_init(&args, G_VARIANT_TYPE("a{sv}"));+ g_variant_builder_add(&args, "{sv}", "Target", g_variant_new_string(target.c_str()));++ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(conn_,+ OBEX_NAME,+ OBEX_ROOT,+ OBEX_CLIENT,+ "CreateSession",+ g_variant_new("(sa{sv})", address_.c_str(), &args),+ G_VARIANT_TYPE("(o)"),+ G_DBUS_CALL_FLAGS_NONE,+ CONNECT_TIMEOUT_MS,+ nullptr,+ &error);+ if (!reply) {+ err = error ? error->message : "unknown error";+ g_clear_error(&error);+ return {};+ }++ const gchar* path = nullptr;+ g_variant_get(reply, "(&o)", &path);+ std::string session = path ? path : "";+ g_variant_unref(reply);+ return session;+ }++ void remove_session(const std::string& path) override {+ if (path.empty() || !conn_)+ return;+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(conn_,+ OBEX_NAME,+ OBEX_ROOT,+ OBEX_CLIENT,+ "RemoveSession",+ g_variant_new("(o)", path.c_str()),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ 5000,+ nullptr,+ &error);+ if (reply)+ g_variant_unref(reply);+ g_clear_error(&error);+ }++ private:+ bool ensure_connection(std::string& err) {+ if (conn_)+ return true;+ GError* error = nullptr;+ conn_ = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, &error);+ if (!conn_) {+ err = std::string("session bus unavailable: ") + (error ? error->message : "unknown");+ g_clear_error(&error);+ return false;+ }+ return true;+ }++ GDBusConnection* conn_ = nullptr;+ std::string address_;+ };++ } // namespace++ struct ConnectionState {+ BluezMonitor* monitor = nullptr;+ ConnectionManager::StatusFn on_change;+ ConnectionManager::MessageFn on_message;++ std::unique_ptr<BluezBearerOps> bearer_ops;+ std::unique_ptr<ObexProfileOps> profile_ops;+ std::unique_ptr<BearerSupervisor> bearers;+ std::unique_ptr<ProfileSupervisor> profiles;++ std::thread thread;+ std::atomic<bool> running{false};+ std::mutex mutex;+ std::condition_variable wake;++ std::string address;+ bool ancs_enabled = true;+ bool link_was_ready = false;+ int64_t next_message_poll = 0;+ std::string open_map_path;+ // The first listing on a new MAP session returns the phone's existing+ // inbox, which on a first run is every message it holds.+ bool map_session_backfill = true;+ std::string pulled_pbap_path;++ std::unique_ptr<ancs::AncsClient> ancs_client;+ ConnectionManager::NotificationFn on_notification;+ ConnectionManager::WithdrawFn on_withdraw;+ bool ancs_ready = false;+ std::string ancs_reason;++ void run();+ void sync_messages(int64_t now);+ void sync_contacts();+ void sync_ancs(int64_t now);+ nlohmann::json status_payload() const;+ // Hands the status to the subscriber only when it differs from the last+ // one published. The supervisors report their own internal transitions+ // as changes, and most of those are invisible in the payload, so without+ // this a subscriber receives the same status every few seconds.+ void publish();++ // Guards last_published: publish() is reached from the supervisor thread+ // and from the ANCS readiness callback on the GLib thread.+ std::mutex publish_mutex;+ nlohmann::json last_published;+ };++ void ConnectionState::publish() {+ if (!on_change)+ return;++ nlohmann::json payload = status_payload();+ {+ std::lock_guard<std::mutex> lock(publish_mutex);+ if (payload == last_published)+ return;+ last_published = payload;+ }+ on_change(payload);+ }++ nlohmann::json ConnectionState::status_payload() const {+ nlohmann::json payload = to_json(bearers->status(), profiles->status());+ payload["ancs_ready"] = ancs_ready;+ payload["ancs_reason"] = ancs_reason;+ return payload;+ }++ nlohmann::json to_json(const BearerStatus& bearer, const ProfileStatus& profiles) {+ return {+ {"command", "bt_connection_changed"},+ {"device_present", bearer.device_present},+ {"device_paired", bearer.device_paired},+ {"classic_connected", bearer.classic_connected},+ {"le_available", bearer.le_available},+ {"le_connected", bearer.le_connected},+ {"map_open", profiles.map_open},+ {"pbap_open", profiles.pbap_open},+ {"map_error", to_string(profiles.map_error)},+ {"pbap_error", to_string(profiles.pbap_error)},+ // Two independent halves, so both reasons are reported; the UI shows+ // whichever is actionable.+ {"link_reason", bearer.reason},+ {"profile_reason", profiles.reason},+ };+ }++ // Pulls the inbox and folds it into the store, announcing anything new.+ //+ // ponytail: polling only. MAP's notification service would push new mail+ // instead, but obexd surfaces it as ObjectManager signals on the session bus,+ // which is a second watcher to build and maintain. Dedupe by handle makes+ // polling correct either way; add MNS if the poll latency proves annoying.+ void ConnectionState::sync_messages(int64_t now) {+ if (!profiles->status().map_open) {+ if (!open_map_path.empty()) {+ std::lock_guard<std::mutex> lock(g_map_mutex);+ g_map_session.reset();+ open_map_path.clear();+ }+ return;+ }++ if (open_map_path != profiles->map_session()) {+ open_map_path = profiles->map_session();+ auto session = std::make_shared<MapSession>(profile_ops->bus(), open_map_path);+ {+ std::lock_guard<std::mutex> lock(g_map_mutex);+ g_map_session = session;+ }+ // A freshly opened session starts at the root, and SetFolder walks the+ // MAP hierarchy from there — "inbox" on its own is not a valid step.+ std::string err;+ if (!session->set_folder(MAP_INBOX, err))+ debug::log(WARN, "bluetooth: SetFolder({}) failed: {}", MAP_INBOX, err);+ next_message_poll = 0;+ map_session_backfill = true;+ }++ if (now < next_message_poll)+ return;+ next_message_poll = now + MESSAGE_POLL_SECONDS;++ std::shared_ptr<MapSession> session;+ {+ std::lock_guard<std::mutex> lock(g_map_mutex);+ session = g_map_session;+ }+ if (!session)+ return;++ std::string err;+ // Empty means the current folder, which SetFolder already selected.+ auto listings = session->list_messages("", MESSAGE_LIST_MAX, err);+ if (!err.empty()) {+ debug::log(WARN, "bluetooth: ListMessages failed: {}", err);+ return;+ }++ std::vector<Message> fresh;+ {+ std::lock_guard<std::mutex> lock(g_messages_mutex);+ for (const auto& listing : listings) {+ Message message = message_from_listing(listing);+ if (message.thread_key.empty())+ continue;++ // MAP gives a group message one sender and no conversation+ // identifier. The correlated Messages notification is the only+ // side channel, and an ambiguous match is refused rather than+ // guessed: filing it wrongly would also aim a reply wrongly.+ if (g_group_replies_enabled) {+ GroupInfo info;+ std::lock_guard<std::mutex> group_lock(g_group_mutex);+ if (g_correlator.correlate(message.body, now, info) == Correlation::Matched) {+ const std::string key = group_thread_key(info);+ if (!key.empty()) {+ // The sender label is display only and never becomes+ // part of the thread identity or the reply route.+ message.peer_name = info.sender;+ message.thread_key = key;+ g_group_info[key] = info;+ }+ }+ }+ if (g_messages.add(message))+ fresh.push_back(message);+ else+ g_messages.set_read(message.handle, message.read);+ }+ }++ const bool backfill = map_session_backfill;+ map_session_backfill = false;++ for (const auto& message : fresh) {+ {+ std::lock_guard<std::mutex> lock(g_messages_mutex);+ g_journal.append(message);+ }+ if (on_message)+ on_message(message, backfill);+ }+ }++ // Pulls the phonebook once per PBAP session. Contacts change far more slowly+ // than messages, and a full pull is an expensive transfer to repeat.+ void ConnectionState::sync_contacts() {+ if (!profiles->status().pbap_open) {+ pulled_pbap_path.clear();+ return;+ }+ if (pulled_pbap_path == profiles->pbap_session())+ return;+ pulled_pbap_path = profiles->pbap_session();++ PbapSession session(profile_ops->bus(), pulled_pbap_path);+ std::string err;+ if (!session.select_phonebook(err)) {+ debug::log(WARN, "bluetooth: PBAP Select failed: {}", err);+ return;+ }++ auto contacts = session.pull_all(err);+ if (!err.empty()) {+ debug::log(WARN, "bluetooth: PBAP PullAll failed: {}", err);+ return;+ }++ {+ std::lock_guard<std::mutex> lock(g_messages_mutex);+ contact_store().set(std::move(contacts));+ }+ save_contacts(contact_store());+ debug::log(INFO, "bluetooth: pulled {} contacts", contact_store().size());+ }++ // Keeps the ANCS client pointed at the LE session and drains its work.+ void ConnectionState::sync_ancs(int64_t now) {+ if (!ancs_client)+ return;++ // ANCS rides the LE bearer. Without it there is nothing to talk to, and+ // pointing the client at an empty path is what makes it forget a session+ // that no longer exists.+ std::string device_path;+ if (bearers->status().le_connected) {+ auto objects = monitor->snapshot();+ for (const auto& device : objects.devices) {+ if (device.address == address || normalize_address(device.address) == normalize_address(address)) {+ device_path = device.path;+ break;+ }+ }+ }++ ancs_client->set_device(device_path);+ ancs_client->tick(now);+ }++ void ConnectionState::run() {+ using namespace std::chrono;+ const auto started = steady_clock::now();++ while (running) {+ const int64_t now = duration_cast<seconds>(steady_clock::now() - started).count();++ bool changed = bearers->tick(now);+ const bool link_ready = bearers->status().classic_connected;++ // A dropped Classic link invalidates every OBEX session on top of it.+ if (link_was_ready && !link_ready) {+ profiles->reset();+ changed = true;+ }+ link_was_ready = link_ready;++ changed = profiles->tick(now, link_ready) || changed;++ if (changed)+ publish();++ sync_contacts();+ sync_messages(now);+ sync_ancs(now);++ std::unique_lock<std::mutex> lock(mutex);+ wake.wait_for(lock, seconds(SUPERVISOR_TICK_SECONDS), [this] { return !running; });+ }+ }++ ConnectionManager::ConnectionManager(BluezMonitor& monitor, StatusFn on_change, MessageFn on_message)+ : state_(std::make_unique<ConnectionState>()) {+ state_->monitor = &monitor;+ state_->on_change = std::move(on_change);+ state_->on_message = std::move(on_message);+ }++ ConnectionManager::~ConnectionManager() { stop(); }++ bool ConnectionManager::start(const std::string& address, bool ancs_enabled) {+ if (state_->running)+ return true;+ if (address.empty()) {+ debug::log(INFO, "bluetooth: no paired iPhone selected; supervision idle");+ return false;+ }++ state_->address = address;+ state_->ancs_enabled = ancs_enabled;++ // Replay history before the first poll so the store is never briefly+ // empty, and so previously seen handles dedupe instead of re-announcing.+ {+ std::lock_guard<std::mutex> lock(g_messages_mutex);+ contact_store() = load_contacts();+ if (g_journal.open()) {+ const int64_t now = static_cast<int64_t>(std::time(nullptr));+ auto history = g_journal.load(now);+ for (const auto& message : history)+ g_messages.add(message);+ // load() already applied retention, so writing back what survived+ // is what actually trims the file. Idempotent when nothing aged out.+ g_journal.compact(history);+ debug::log(INFO, "bluetooth: replayed {} message(s) from the journal", history.size());+ }+ }+ state_->bearer_ops = std::make_unique<BluezBearerOps>(*state_->monitor, address);+ state_->profile_ops = std::make_unique<ObexProfileOps>(address);+ state_->bearers = std::make_unique<BearerSupervisor>(*state_->bearer_ops, ancs_enabled);+ state_->profiles = std::make_unique<ProfileSupervisor>(*state_->profile_ops);++ // Only built when the caller can actually show notifications and the+ // bond can carry them.+ if (ancs_enabled && state_->on_notification) {+ auto* raw = state_.get();+ state_->ancs_client = std::make_unique<ancs::AncsClient>(+ *state_->monitor,+ [raw](const ancs::Notification& notification) {+ if (raw->on_notification)+ raw->on_notification(notification);+ },+ [raw](uint32_t uid) {+ if (raw->on_withdraw)+ raw->on_withdraw(uid);+ },+ [raw](bool ready, const std::string& reason) {+ raw->ancs_ready = ready;+ raw->ancs_reason = reason;+ debug::log(INFO, "ancs: {}", reason);+ raw->publish();+ });+ state_->ancs_client->set_content_enabled(load_config().ancs_content_enabled);+ }++ state_->running = true;+ state_->thread = std::thread([this] { state_->run(); });+ debug::log(INFO, "bluetooth: supervising {} (ANCS {})", address, ancs_enabled ? "enabled" : "disabled");+ return true;+ }++ void ConnectionManager::stop() {+ if (!state_->running && !state_->thread.joinable())+ return;+ {+ std::lock_guard<std::mutex> lock(state_->mutex);+ state_->running = false;+ }+ state_->wake.notify_all();+ if (state_->thread.joinable())+ state_->thread.join();+ }++ void ConnectionManager::set_notification_handlers(NotificationFn on_notification, WithdrawFn on_withdraw) {+ state_->on_notification = std::move(on_notification);+ state_->on_withdraw = std::move(on_withdraw);+ }++ bool ConnectionManager::perform_notification_action(uint32_t uid, ancs::ActionId action) {+ return state_->ancs_client && state_->ancs_client->perform_action(uid, action);+ }++ nlohmann::json ConnectionManager::notifications(size_t limit) const {+ nlohmann::json out = nlohmann::json::array();+ if (!state_->ancs_client)+ return out;+ for (const auto& notification : state_->ancs_client->registry().recent(limit))+ out.push_back(ancs::to_json(notification));+ return out;+ }++ void ConnectionManager::set_device(const std::string& address, bool ancs_enabled) {+ // Restarting is simpler than mutating supervisor state under the worker,+ // and selecting a device is rare.+ stop();+ state_->running = false;+ start(address, ancs_enabled);+ }++ nlohmann::json ConnectionManager::status() const {+ if (!state_->bearers || !state_->profiles) {+ nlohmann::json idle;+ idle["command"] = "bt_connection_changed";+ idle["device_present"] = false;+ idle["device_paired"] = false;+ idle["link_reason"] = "No paired iPhone selected.";+ idle["profile_reason"] = "";+ return idle;+ }+ nlohmann::json payload = to_json(state_->bearers->status(), state_->profiles->status());+ payload["ancs_ready"] = state_->ancs_ready;+ payload["ancs_reason"] = state_->ancs_reason;+ return payload;+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/contacts.cpp b/src/core/src/bluetooth/contacts.cppnew file mode 100644index 0000000..6a599af--- /dev/null+++ b/src/core/src/bluetooth/contacts.cpp@@ -0,0 +1,181 @@+#include "tether/bluetooth/contacts.hpp"+#include "tether/bluetooth/bmessage.hpp"+#include "tether/log.hpp"++#include <algorithm>+#include <cctype>+#include <cstdlib>+#include <filesystem>+#include <fstream>+#include <pwd.h>+#include <unistd.h>++namespace tether::bluetooth {++ namespace {++ std::string home_dir() {+ if (const char* home = getenv("HOME"); home && *home)+ return home;+ if (const passwd* pw = getpwuid(getuid()); pw && pw->pw_dir)+ return pw->pw_dir;+ return {};+ }++ } // namespace++ void ContactStore::set(std::vector<VCard> contacts) {+ contacts_ = std::move(contacts);+ by_key_.clear();++ for (const auto& card : contacts_) {+ if (card.name.empty())+ continue;+ for (const auto& tel : card.tels) {+ std::string normalized = normalize_phone(tel);+ if (!normalized.empty())+ by_key_.emplace("tel:" + normalized, card.name);+ }+ for (const auto& email : card.emails) {+ std::string normalized = normalize_email(email);+ if (!normalized.empty())+ by_key_.emplace("email:" + normalized, card.name);+ }+ }+ }++ std::string ContactStore::name_for(const std::string& thread_key) const {+ auto it = by_key_.find(thread_key);+ return it == by_key_.end() ? std::string{} : it->second;+ }++ std::vector<std::string> ContactStore::addresses_for_name(const std::string& name) const {+ std::vector<std::string> out;+ if (name.empty())+ return out;++ std::string wanted = name;+ std::transform(wanted.begin(), wanted.end(), wanted.begin(), [](unsigned char c) {+ return static_cast<char>(std::tolower(c));+ });++ for (const auto& card : contacts_) {+ std::string candidate = card.name;+ std::transform(candidate.begin(), candidate.end(), candidate.begin(), [](unsigned char c) {+ return static_cast<char>(std::tolower(c));+ });+ if (candidate != wanted)+ continue;++ // A phone number is what Messages routes on, so it wins when a+ // contact has both.+ for (const auto& tel : card.tels) {+ std::string normalized = normalize_phone(tel);+ if (!normalized.empty())+ out.push_back("tel:" + normalized);+ }+ for (const auto& email : card.emails) {+ std::string normalized = normalize_email(email);+ if (!normalized.empty())+ out.push_back("email:" + normalized);+ }+ }+ return out;+ }++ std::string contacts_path() {+ std::string home = home_dir();+ if (home.empty())+ return {};+ return (std::filesystem::path(home) / ".local" / "share" / "tether" / "contacts.json").string();+ }++ std::string serialize_contacts(const ContactStore& store) {+ nlohmann::json j;+ j["contacts"] = nlohmann::json::array();+ for (const auto& card : store.contacts()) {+ nlohmann::json c;+ c["name"] = card.name;+ c["tels"] = card.tels;+ c["emails"] = card.emails;+ j["contacts"].push_back(std::move(c));+ }+ return j.dump(2);+ }++ ContactStore deserialize_contacts(const std::string& text) {+ ContactStore store;+ std::vector<VCard> cards;+ try {+ auto j = nlohmann::json::parse(text);+ for (const auto& c : j.value("contacts", nlohmann::json::array())) {+ VCard card;+ card.name = c.value("name", "");+ card.tels = c.value("tels", std::vector<std::string>{});+ card.emails = c.value("emails", std::vector<std::string>{});+ if (!card.empty())+ cards.push_back(std::move(card));+ }+ } catch (const std::exception&) {+ // A corrupt cache costs display names, not correctness. Threads fall+ // back to raw addresses until PBAP refreshes.+ return store;+ }+ store.set(std::move(cards));+ return store;+ }++ ContactStore load_contacts() {+ std::string path = contacts_path();+ if (path.empty())+ return {};+ std::ifstream in(path);+ if (!in.is_open())+ return {};+ std::string text((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());+ return deserialize_contacts(text);+ }++ bool save_contacts(const ContactStore& store) {+ std::string path = contacts_path();+ if (path.empty())+ return false;++ std::error_code ec;+ std::filesystem::create_directories(std::filesystem::path(path).parent_path(), ec);++ // Write-then-rename, matching how the Bluetooth config is persisted.+ std::string tmp = path + ".tmp";+ {+ std::ofstream out(tmp, std::ios::trunc);+ if (!out.is_open()) {+ debug::log(ERR, "bluetooth: cannot write {}", tmp);+ return false;+ }+ out << serialize_contacts(store);+ if (!out) {+ debug::log(ERR, "bluetooth: failed writing {}", tmp);+ return false;+ }+ }++ // The phonebook is personal data, so it gets the same mode as the key.+ std::filesystem::permissions(tmp,+ std::filesystem::perms::owner_read | std::filesystem::perms::owner_write,+ std::filesystem::perm_options::replace,+ ec);+ std::filesystem::rename(tmp, path, ec);+ if (ec) {+ debug::log(ERR, "bluetooth: cannot replace {}: {}", path, ec.message());+ std::filesystem::remove(tmp, ec);+ return false;+ }+ return true;+ }++ ContactStore& contact_store() {+ static ContactStore store;+ return store;+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/diagnostics.cpp b/src/core/src/bluetooth/diagnostics.cppnew file mode 100644index 0000000..eebccb2--- /dev/null+++ b/src/core/src/bluetooth/diagnostics.cpp@@ -0,0 +1,199 @@+#include "tether/bluetooth/diagnostics.hpp"++#include "tether/bluetooth/config.hpp"+#include "tether/version.hpp"++#include <algorithm>+#include <chrono>+#include <cstdlib>+#include <deque>+#include <functional>+#include <mutex>+#include <regex>++namespace tether::bluetooth {++ namespace {++ // A pairing attempt is a few dozen events; this holds several attempts+ // without letting a long-running daemon accumulate a report nobody reads.+ constexpr size_t TIMELINE_CAPACITY = 200;++ const std::regex kDevNode(R"(dev_[0-9A-Fa-f]{2}(?:_[0-9A-Fa-f]{2}){5})");+ const std::regex kAddress(R"([0-9A-Fa-f]{2}(?::[0-9A-Fa-f]{2}){5})");+ const std::regex kEmail(R"([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,})");+ const std::regex kNumber(R"(\+[0-9]{7,15})");+ const std::regex kRuntimeDir(R"(/run/user/[0-9]+)");++ std::string upper(std::string s) {+ std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::toupper(c); });+ return s;+ }++ std::string lower(std::string s) {+ std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });+ return s;+ }++ std::string replace_all(const std::string& in,+ const std::regex& re,+ const std::function<std::string(const std::string&)>& fn) {+ std::string out;+ size_t last = 0;+ for (auto it = std::sregex_iterator(in.begin(), in.end(), re); it != std::sregex_iterator(); ++it) {+ out.append(in, last, static_cast<size_t>(it->position()) - last);+ out += fn(it->str());+ last = static_cast<size_t>(it->position()) + static_cast<size_t>(it->length());+ }+ out.append(in, last, std::string::npos);+ return out;+ }++ std::string replace_literal(std::string in, const std::string& needle, const std::string& with) {+ if (needle.empty())+ return in;+ for (size_t at = in.find(needle); at != std::string::npos; at = in.find(needle, at + with.size()))+ in.replace(at, needle.size(), with);+ return in;+ }++ // Events describing link and pairing state. Everything else the daemon+ // broadcasts carries message or notification content.+ bool is_state_event(const std::string& command) {+ return command == "bt_pair_progress" || command == "bt_pair_result" || command == "bt_unpair_result" ||+ command == "bt_connection_changed" || command == "bt_send_result" || command == "bt_message_read";+ }++ std::mutex g_timeline_mutex;+ std::deque<nlohmann::json> g_timeline;+ std::chrono::steady_clock::time_point g_timeline_origin;+ bool g_timeline_started = false;++ } // namespace++ bool is_content_key(const std::string& key) {+ return key == "body" || key == "sender" || key == "subject" || key == "name" || key == "title" ||+ key == "preview" || key == "alias";+ }++ std::string Redactor::placeholder(const std::string& kind, const std::string& key) {+ const std::string prefix = "<" + kind + "-";+ if (auto it = assigned_.find(key); it != assigned_.end())+ return it->second;++ size_t n = 1;+ for (const auto& [existing, token] : assigned_)+ if (token.rfind(prefix, 0) == 0)+ ++n;++ std::string token = prefix + std::to_string(n) + ">";+ assigned_.emplace(key, token);+ return token;+ }++ std::string Redactor::text(const std::string& in) {+ std::string out = in;++ // Directories first: a path under $HOME can contain anything below.+ if (const char* runtime = std::getenv("XDG_RUNTIME_DIR"); runtime && *runtime)+ out = replace_literal(out, runtime, "<runtime>");+ out = replace_all(out, kRuntimeDir, [](const std::string&) { return "<runtime>"; });+ if (const char* home = std::getenv("HOME"); home && *home)+ out = replace_literal(out, home, "<home>");++ // Normalized to the colon form so one device gets one placeholder+ // however the address was spelled.+ out = replace_all(out, kDevNode, [this](const std::string& match) {+ std::string address = match.substr(4);+ std::replace(address.begin(), address.end(), '_', ':');+ return "dev_" + placeholder("address", upper(address));+ });+ out = replace_all(+ out, kAddress, [this](const std::string& match) { return placeholder("address", upper(match)); });+ out = replace_all(out, kEmail, [this](const std::string& match) { return placeholder("email", lower(match)); });+ out = replace_all(out, kNumber, [this](const std::string& match) { return placeholder("number", match); });+ return out;+ }++ nlohmann::json Redactor::value(const nlohmann::json& in) {+ if (in.is_string())+ return text(in.get<std::string>());++ if (in.is_array()) {+ nlohmann::json out = nlohmann::json::array();+ for (const auto& element : in)+ out.push_back(value(element));+ return out;+ }++ if (in.is_object()) {+ nlohmann::json out = nlohmann::json::object();+ for (const auto& [key, element] : in.items()) {+ if (is_content_key(key))+ continue;+ out[key] = value(element);+ }+ return out;+ }++ return in;+ }++ void record_diagnostic_event(const nlohmann::json& event) {+ if (!event.is_object() || !is_state_event(event.value("command", "")))+ return;++ nlohmann::json entry = nlohmann::json::object();+ for (const auto& [key, value] : event.items()) {+ if (!is_content_key(key))+ entry[key] = value;+ }++ std::lock_guard<std::mutex> lock(g_timeline_mutex);+ const auto now = std::chrono::steady_clock::now();+ if (!g_timeline_started) {+ g_timeline_origin = now;+ g_timeline_started = true;+ }+ entry["at_ms"] = std::chrono::duration_cast<std::chrono::milliseconds>(now - g_timeline_origin).count();++ g_timeline.push_back(std::move(entry));+ if (g_timeline.size() > TIMELINE_CAPACITY)+ g_timeline.pop_front();+ }++ nlohmann::json diagnostic_timeline() {+ std::lock_guard<std::mutex> lock(g_timeline_mutex);+ nlohmann::json out = nlohmann::json::array();+ for (const auto& entry : g_timeline)+ out.push_back(entry);+ return out;+ }++ void clear_diagnostic_timeline() {+ std::lock_guard<std::mutex> lock(g_timeline_mutex);+ g_timeline.clear();+ g_timeline_started = false;+ }++ nlohmann::json build_diagnostics(const nlohmann::json& status, const nlohmann::json& connection) {+ const Config config = load_config();+ Redactor redactor;++ nlohmann::json report;+ report["command"] = "bt_diagnostics";+ report["version"] = TETHER_VERSION;+ report["auth_strategy"] = to_string(config.auth_strategy);+ // The address itself is never reported; whether one is selected is what+ // matters for reading the rest.+ report["device_selected"] = !config.device_address.empty();+ report["ancs_enabled"] = config.ancs_enabled;+ report["ancs_content_enabled"] = config.ancs_content_enabled;+ report["group_messages_enabled"] = config.group_messages_enabled;+ report["status"] = redactor.value(status);+ report["connection"] = redactor.value(connection);+ report["timeline"] = redactor.value(diagnostic_timeline());+ return report;+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/groups.cpp b/src/core/src/bluetooth/groups.cppnew file mode 100644index 0000000..38bad64--- /dev/null+++ b/src/core/src/bluetooth/groups.cpp@@ -0,0 +1,357 @@+#include "tether/bluetooth/groups.hpp"++#include <algorithm>+#include <cctype>+#include <cstdlib>+#include <filesystem>+#include <fstream>+#include <nlohmann/json.hpp>+#include <pwd.h>+#include <unistd.h>++namespace tether::bluetooth {++ namespace {++ std::string home_dir() {+ if (const char* home = getenv("HOME"); home && *home)+ return home;+ if (const passwd* pw = getpwuid(getuid()); pw && pw->pw_dir)+ return pw->pw_dir;+ return {};+ }++ std::string trim(const std::string& text) {+ size_t begin = text.find_first_not_of(" \t\r\n");+ if (begin == std::string::npos)+ return {};+ size_t end = text.find_last_not_of(" \t\r\n");+ return text.substr(begin, end - begin + 1);+ }++ std::string lower(std::string text) {+ std::transform(text.begin(), text.end(), text.begin(), [](unsigned char c) {+ return static_cast<char>(std::tolower(c));+ });+ return text;+ }++ // Collapses case and whitespace so a group name is a stable key.+ std::string normalize_name(const std::string& text) {+ std::string out;+ bool space = false;+ for (char c : lower(trim(text))) {+ if (std::isspace(static_cast<unsigned char>(c))) {+ space = true;+ continue;+ }+ if (space && !out.empty())+ out += '-';+ space = false;+ out += c;+ }+ return out;+ }++ // Splits "you, Alice & Bob" on commas and ampersands.+ std::vector<std::string> split_participants(const std::string& text) {+ std::vector<std::string> parts;+ std::string current;+ for (size_t i = 0; i < text.size(); ++i) {+ if (text[i] == ',' || text[i] == '&') {+ parts.push_back(trim(current));+ current.clear();+ continue;+ }+ current += text[i];+ }+ parts.push_back(trim(current));++ std::vector<std::string> out;+ for (auto& part : parts) {+ if (part.empty())+ continue;+ // The user is always a member and is never a reply recipient.+ if (lower(part) == "you")+ continue;+ out.push_back(std::move(part));+ }+ return out;+ }++ } // namespace++ bool parse_group_notification(const std::string& title, const std::string& subtitle, GroupInfo& out) {+ const std::string clean_subtitle = trim(subtitle);+ if (clean_subtitle.empty())+ return false;++ out = GroupInfo{};+ out.sender = trim(title);+ out.is_group = true;++ // "To you & Alice" marks an unnamed group. Anything else is a name.+ const std::string lowered = lower(clean_subtitle);+ if (lowered.rfind("to ", 0) == 0) {+ out.named = false;+ out.participants = split_participants(clean_subtitle.substr(3));+ // "To Alice" with nobody else is a one-to-one conversation.+ if (out.participants.empty())+ return false;+ return true;+ }++ out.named = true;+ out.name = clean_subtitle;+ return true;+ }++ std::string group_thread_key(const GroupInfo& info) {+ if (!info.is_group)+ return {};+ if (info.named)+ return "group:name:" + normalize_name(info.name);++ std::vector<std::string> slugs;+ slugs.reserve(info.participants.size());+ for (const auto& participant : info.participants)+ slugs.push_back(normalize_name(participant));+ std::sort(slugs.begin(), slugs.end());++ std::string key = "group:members:";+ for (size_t i = 0; i < slugs.size(); ++i) {+ if (i)+ key += "+";+ key += slugs[i];+ }+ return key;+ }++ void GroupCorrelator::observe(const MessageNotification& notification) { recent_.push_back(notification); }++ void GroupCorrelator::expire(int64_t now) {+ std::erase_if(+ recent_, [&](const MessageNotification& n) { return now - n.received > GROUP_CORRELATION_WINDOW_SECONDS; });+ }++ void GroupCorrelator::clear() { recent_.clear(); }++ Correlation GroupCorrelator::correlate(const std::string& body, int64_t now, GroupInfo& out) const {+ const MessageNotification* match = nullptr;+ size_t matches = 0;++ for (const auto& candidate : recent_) {+ if (now - candidate.received > GROUP_CORRELATION_WINDOW_SECONDS)+ continue;+ if (candidate.body.empty())+ continue;+ // ANCS bodies are capped at what was requested, so a longer MAP body+ // matches the notification as a prefix rather than exactly.+ if (body.rfind(candidate.body, 0) != 0)+ continue;++ ++matches;+ match = &candidate;+ }++ if (matches == 0)+ return Correlation::NoMatch;++ // two notifications with same text cannot be told apart+ if (matches > 1)+ return Correlation::Ambiguous;++ GroupInfo info;+ if (!parse_group_notification(match->sender, match->subtitle, info))+ return Correlation::NoMatch;+ out = info;+ return Correlation::Matched;+ }++ const char* to_string(ReplyEligibility eligibility) {+ switch (eligibility) {+ case ReplyEligibility::Allowed:+ return "allowed";+ case ReplyEligibility::Disabled:+ return "disabled";+ case ReplyEligibility::NeedsRoster:+ return "needs-roster";+ case ReplyEligibility::Unresolved:+ return "unresolved";+ case ReplyEligibility::RouteInvalidated:+ return "route-invalidated";+ }+ return "unknown";+ }++ void GroupRoster::set(const std::string& thread_key, std::vector<std::string> addresses) {+ rosters_[thread_key] = std::move(addresses);+ }++ const std::vector<std::string>* GroupRoster::find(const std::string& thread_key) const {+ auto it = rosters_.find(thread_key);+ return it == rosters_.end() ? nullptr : &it->second;+ }++ std::string GroupRoster::serialize() const {+ nlohmann::json j;+ for (const auto& [key, addresses] : rosters_)+ j[key] = addresses;+ return j.dump(2);+ }++ GroupRoster GroupRoster::deserialize(const std::string& text) {+ GroupRoster roster;+ try {+ auto j = nlohmann::json::parse(text);+ if (!j.is_object())+ return roster;+ for (auto& [key, value] : j.items()) {+ if (value.is_array())+ roster.set(key, value.get<std::vector<std::string>>());+ }+ } catch (const std::exception&) {+ // A corrupt roster must leave groups read-only rather than routing a+ // reply to whatever survived parsing.+ return GroupRoster{};+ }+ return roster;+ }++ std::string roster_path() {+ std::string home = home_dir();+ if (home.empty())+ return {};+ return (std::filesystem::path(home) / ".config" / "tether" / "groups.json").string();+ }++ GroupRoster load_rosters() {+ std::string path = roster_path();+ if (path.empty())+ return {};+ std::ifstream in(path);+ if (!in.is_open())+ return {};+ std::string text((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());+ return GroupRoster::deserialize(text);+ }++ bool save_rosters(const GroupRoster& roster) {+ std::string path = roster_path();+ if (path.empty())+ return false;++ std::error_code ec;+ std::filesystem::create_directories(std::filesystem::path(path).parent_path(), ec);++ std::string tmp = path + ".tmp";+ {+ std::ofstream out(tmp, std::ios::trunc);+ if (!out.is_open())+ return false;+ out << roster.serialize();+ if (!out)+ return false;+ }+ std::filesystem::permissions(tmp,+ std::filesystem::perms::owner_read | std::filesystem::perms::owner_write,+ std::filesystem::perm_options::replace,+ ec);+ std::filesystem::rename(tmp, path, ec);+ if (ec) {+ std::filesystem::remove(tmp, ec);+ return false;+ }+ return true;+ }++ ReplyEligibility resolve_group_recipients(const GroupInfo& info,+ const std::string& thread_key,+ const ContactStore& contacts,+ const GroupRoster& rosters,+ bool group_replies_enabled,+ std::vector<Recipient>& out,+ std::string& reason) {+ out.clear();+ if (!group_replies_enabled) {+ reason = "Group replies are turned off.";+ return ReplyEligibility::Disabled;+ }++ // user-supplied roster is authoritative for either kind of group+ if (const std::vector<std::string>* roster = rosters.find(thread_key)) {+ for (const auto& address : *roster) {+ Recipient recipient;+ std::string err;+ if (!recipient_from_thread_key(address, recipient, err)) {+ reason = "The roster for this group contains an unusable address: " + err;+ out.clear();+ return ReplyEligibility::Unresolved;+ }+ out.push_back(recipient);+ }+ if (out.empty()) {+ reason = "The roster for this group is empty.";+ return ReplyEligibility::NeedsRoster;+ }+ return ReplyEligibility::Allowed;+ }++ // thread with no correlated notification behind it+ if (!info.is_group) {+ reason = "This conversation has not been identified as a group yet, so there is nobody to reply to.";+ return ReplyEligibility::NeedsRoster;+ }++ if (info.named) {+ reason = "This group has a name but no member list. Add its members before replying.";+ return ReplyEligibility::NeedsRoster;+ }++ for (const auto& participant : info.participants) {+ std::vector<std::string> addresses = contacts.addresses_for_name(participant);+ if (addresses.empty()) {+ reason = "\"" + participant + "\" is not in your contacts.";+ out.clear();+ return ReplyEligibility::Unresolved;+ }+ if (addresses.size() > 1) {+ reason = "\"" + participant + "\" matches more than one contact address.";+ out.clear();+ return ReplyEligibility::Unresolved;+ }++ Recipient recipient;+ std::string err;+ if (!recipient_from_thread_key(addresses.front(), recipient, err)) {+ reason = "\"" + participant + "\" resolved to an unusable address: " + err;+ out.clear();+ return ReplyEligibility::Unresolved;+ }+ out.push_back(recipient);+ }++ if (out.empty()) {+ reason = "No recipients could be resolved for this group.";+ return ReplyEligibility::Unresolved;+ }+ return ReplyEligibility::Allowed;+ }++ bool sender_invalidates_route(const std::string& sender_address, const std::vector<Recipient>& recipients) {+ if (sender_address.empty() || recipients.empty())+ return false;++ Recipient sender;+ std::string err;+ if (!recipient_from_thread_key(sender_address, sender, err))+ return true;++ for (const auto& recipient : recipients) {+ if (recipient.kind == sender.kind && recipient.address == sender.address)+ return false;+ }+ return true;+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/journal.cpp b/src/core/src/bluetooth/journal.cppnew file mode 100644index 0000000..fbf0232--- /dev/null+++ b/src/core/src/bluetooth/journal.cpp@@ -0,0 +1,197 @@+#include "tether/bluetooth/journal.hpp"+#include "tether/log.hpp"++#include <algorithm>+#include <cstdlib>+#include <filesystem>+#include <map>+#include <nlohmann/json.hpp>+#include <pwd.h>+#include <unistd.h>++namespace tether::bluetooth {++ namespace {++ std::string home_dir() {+ if (const char* home = getenv("HOME"); home && *home)+ return home;+ if (const passwd* pw = getpwuid(getuid()); pw && pw->pw_dir)+ return pw->pw_dir;+ return {};+ }++ void restrict_permissions(const std::string& path) {+ std::error_code ec;+ std::filesystem::permissions(path,+ std::filesystem::perms::owner_read | std::filesystem::perms::owner_write,+ std::filesystem::perm_options::replace,+ ec);+ }++ } // namespace++ std::string journal_path() {+ std::string home = home_dir();+ if (home.empty())+ return {};+ return (std::filesystem::path(home) / ".local" / "share" / "tether" / "messages.ndjson").string();+ }++ std::string serialize_message_line(const Message& message) {+ return to_json(message).dump(-1, ' ', false, nlohmann::json::error_handler_t::replace);+ }++ bool deserialize_message_line(const std::string& line, Message& out) {+ try {+ auto j = nlohmann::json::parse(line);+ if (!j.is_object())+ return false;+ Message message;+ message.handle = j.value("handle", "");+ message.thread_key = j.value("thread", "");+ message.peer_address = j.value("address", "");+ message.peer_name = j.value("name", "");+ message.body = j.value("body", "");+ message.timestamp = j.value("timestamp", static_cast<int64_t>(0));+ message.outgoing = j.value("outgoing", false);+ message.read = j.value("read", false);+ message.folder = j.value("folder", "");+ // A message with no handle cannot be deduped and would replay forever.+ if (message.handle.empty() || message.thread_key.empty())+ return false;+ out = std::move(message);+ return true;+ } catch (const std::exception&) {+ return false;+ }+ }++ std::vector<Message>+ apply_retention(std::vector<Message> messages, int64_t now, size_t max_messages, int64_t max_age) {+ {+ std::map<std::string, size_t> newest;+ for (size_t i = 0; i < messages.size(); ++i)+ newest[messages[i].handle] = i;+ std::vector<Message> unique;+ unique.reserve(newest.size());+ for (size_t i = 0; i < messages.size(); ++i) {+ if (newest[messages[i].handle] == i)+ unique.push_back(std::move(messages[i]));+ }+ messages = std::move(unique);+ }++ if (max_age > 0) {+ const int64_t cutoff = now - max_age;+ // zero timestamp means the phone gave us nothing usable+ std::erase_if(messages, [&](const Message& m) { return m.timestamp > 0 && m.timestamp < cutoff; });+ }++ if (messages.size() > max_messages) {+ std::stable_sort(messages.begin(), messages.end(), [](const Message& a, const Message& b) {+ return a.timestamp < b.timestamp;+ });+ messages.erase(messages.begin(), messages.begin() + static_cast<long>(messages.size() - max_messages));+ }+ return messages;+ }++ bool MessageJournal::open() {+ path_ = journal_path();+ if (path_.empty())+ return false;++ std::error_code ec;+ std::filesystem::create_directories(std::filesystem::path(path_).parent_path(), ec);++ out_.open(path_, std::ios::app);+ if (!out_.is_open()) {+ debug::log(ERR, "bluetooth: cannot open journal {}", path_);+ return false;+ }+ restrict_permissions(path_);+ return true;+ }++ void MessageJournal::close() {+ if (out_.is_open())+ out_.close();+ }++ void MessageJournal::append(const Message& message) {+ if (!out_.is_open())+ return;+ out_ << serialize_message_line(message) << "\n";+ out_.flush();+ }++ std::vector<Message> MessageJournal::load(int64_t now) const {+ std::vector<Message> messages;+ const std::string path = path_.empty() ? journal_path() : path_;+ if (path.empty())+ return messages;++ std::ifstream in(path);+ if (!in.is_open())+ return messages;++ std::string line;+ size_t skipped = 0;+ while (std::getline(in, line)) {+ if (line.empty())+ continue;+ Message message;+ if (deserialize_message_line(line, message))+ messages.push_back(std::move(message));+ else+ ++skipped;+ }+ if (skipped)+ debug::log(WARN, "bluetooth: skipped {} unreadable journal line(s)", skipped);++ return apply_retention(std::move(messages), now);+ }++ bool MessageJournal::compact(const std::vector<Message>& messages) {+ const std::string path = path_.empty() ? journal_path() : path_;+ if (path.empty())+ return false;++ std::error_code ec;+ std::filesystem::create_directories(std::filesystem::path(path).parent_path(), ec);++ const std::string tmp = path + ".tmp";+ {+ std::ofstream out(tmp, std::ios::trunc);+ if (!out.is_open()) {+ debug::log(ERR, "bluetooth: cannot write {}", tmp);+ return false;+ }+ for (const auto& message : messages)+ out << serialize_message_line(message) << "\n";+ if (!out) {+ debug::log(ERR, "bluetooth: failed writing {}", tmp);+ return false;+ }+ }+ restrict_permissions(tmp);++ const bool was_open = out_.is_open();+ if (was_open)+ out_.close();++ std::filesystem::rename(tmp, path, ec);+ if (ec) {+ debug::log(ERR, "bluetooth: cannot replace {}: {}", path, ec.message());+ std::filesystem::remove(tmp, ec);+ }++ if (was_open) {+ out_.open(path, std::ios::app);+ restrict_permissions(path);+ }+ return !ec;+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/map_session.cpp b/src/core/src/bluetooth/map_session.cppnew file mode 100644index 0000000..b957b9f--- /dev/null+++ b/src/core/src/bluetooth/map_session.cpp@@ -0,0 +1,335 @@+#include "tether/bluetooth/map_session.hpp"+#include "tether/bluetooth/obex_transfer.hpp"++#include <cstdlib>+#include <filesystem>+#include <fstream>+#include <unistd.h>++namespace tether::bluetooth {++ namespace {++ constexpr const char* OBEX_NAME = "org.bluez.obex";+ constexpr const char* IFACE_MAP = "org.bluez.obex.MessageAccess1";+ constexpr const char* IFACE_MESSAGE = "org.bluez.obex.Message1";+ constexpr const char* IFACE_PROPS = "org.freedesktop.DBus.Properties";++ // Listing a large mailbox is a real OBEX transfer; give it room.+ constexpr int MAP_CALL_TIMEOUT_MS = 60000;+ // Sending is interactive; the user is waiting on the answer.+ constexpr int MAP_PUSH_TIMEOUT_SECONDS = 30;++ std::string variant_string(GVariant* value) {+ if (!value)+ return {};+ if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING))+ return g_variant_get_string(value, nullptr);+ return {};+ }++ bool variant_bool(GVariant* value) {+ return value && g_variant_is_of_type(value, G_VARIANT_TYPE_BOOLEAN) && g_variant_get_boolean(value);+ }++ bool take_error(GError*& error, std::string& err_out) {+ err_out = error ? error->message : "unknown error";+ g_clear_error(&error);+ return false;+ }++ } // namespace++ struct MapSessionState {+ GDBusConnection* bus = nullptr;+ std::string path;+ };++ MapSession::MapSession(GDBusConnection* session_bus, std::string session_path)+ : state_(std::make_unique<MapSessionState>()) {+ state_->bus = session_bus;+ state_->path = std::move(session_path);+ }++ MapSession::~MapSession() = default;++ const std::string& MapSession::path() const { return state_->path; }++ bool MapSession::set_folder(const std::string& folder, std::string& err) {+ GError* error = nullptr;+ // MessageAccess1.SetFolder, deliberately not PBAP's Select.+ GVariant* reply = g_dbus_connection_call_sync(state_->bus,+ OBEX_NAME,+ state_->path.c_str(),+ IFACE_MAP,+ "SetFolder",+ g_variant_new("(s)", folder.c_str()),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ MAP_CALL_TIMEOUT_MS,+ nullptr,+ &error);+ if (!reply)+ return take_error(error, err);+ g_variant_unref(reply);+ return true;+ }++ std::vector<MapListing> MapSession::list_messages(const std::string& folder, int max, std::string& err) {+ std::vector<MapListing> listings;++ GVariantBuilder filter;+ g_variant_builder_init(&filter, G_VARIANT_TYPE("a{sv}"));+ g_variant_builder_add(&filter, "{sv}", "MaxCount", g_variant_new_uint16(static_cast<guint16>(max)));++ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(state_->bus,+ OBEX_NAME,+ state_->path.c_str(),+ IFACE_MAP,+ "ListMessages",+ g_variant_new("(sa{sv})", folder.c_str(), &filter),+ // obexd returns a dict of object path -> properties,+ // not an array of (path, properties) structs.+ G_VARIANT_TYPE("(a{oa{sv}})"),+ G_DBUS_CALL_FLAGS_NONE,+ MAP_CALL_TIMEOUT_MS,+ nullptr,+ &error);+ if (!reply) {+ take_error(error, err);+ return listings;+ }++ GVariant* array = g_variant_get_child_value(reply, 0);+ GVariantIter iter;+ const gchar* object_path = nullptr;+ GVariant* props = nullptr;+ g_variant_iter_init(&iter, array);+ while (g_variant_iter_loop(&iter, "{&o@a{sv}}", &object_path, &props)) {+ MapListing listing;+ listing.handle = object_path ? object_path : "";++ GVariantIter prop_iter;+ const gchar* key = nullptr;+ GVariant* value = nullptr;+ g_variant_iter_init(&prop_iter, props);+ while (g_variant_iter_loop(&prop_iter, "{&sv}", &key, &value)) {+ const std::string name = key ? key : "";+ // The message text lives in Subject for a listing; a full+ // bMessage download is only needed when this is truncated.+ if (name == "Subject")+ listing.subject = variant_string(value);+ else if (name == "Sender")+ listing.sender_name = variant_string(value);+ else if (name == "SenderAddress")+ listing.sender_address = variant_string(value);+ else if (name == "Timestamp")+ listing.timestamp = variant_string(value);+ else if (name == "Type")+ listing.type = variant_string(value);+ else if (name == "Folder")+ listing.folder = variant_string(value);+ else if (name == "Read")+ listing.read = variant_bool(value);+ else if (name == "Sent")+ listing.sent = variant_bool(value);+ }++ if (listing.folder.empty())+ listing.folder = folder;+ listings.push_back(std::move(listing));+ }++ g_variant_unref(array);+ g_variant_unref(reply);+ return listings;+ }++ bool MapSession::fetch_bmessage(const std::string& message_path, BMessage& out, std::string& err) {+ // Message1.Get writes the bMessage to a file and returns the transfer+ // object plus its properties.+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(state_->bus,+ OBEX_NAME,+ message_path.c_str(),+ IFACE_MESSAGE,+ "Get",+ g_variant_new("(sb)", "", TRUE),+ G_VARIANT_TYPE("(oa{sv})"),+ G_DBUS_CALL_FLAGS_NONE,+ MAP_CALL_TIMEOUT_MS,+ nullptr,+ &error);+ if (!reply)+ return take_error(error, err);++ GVariant* props = g_variant_get_child_value(reply, 1);+ GVariant* filename = g_variant_lookup_value(props, "Filename", G_VARIANT_TYPE_STRING);+ const std::string path = filename ? g_variant_get_string(filename, nullptr) : "";+ if (filename)+ g_variant_unref(filename);+ g_variant_unref(props);+ g_variant_unref(reply);++ if (path.empty()) {+ err = "transfer returned no filename";+ return false;+ }++ std::ifstream in(path, std::ios::binary);+ if (!in.is_open()) {+ err = "cannot read " + path;+ return false;+ }+ std::string text((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());+ out = parse_bmessage(text);+ if (!out.valid) {+ err = "unparseable bMessage";+ return false;+ }+ return true;+ }++ bool MapSession::set_read(const std::string& message_path, bool read, std::string& err) {+ GError* error = nullptr;+ GVariant* reply =+ g_dbus_connection_call_sync(state_->bus,+ OBEX_NAME,+ message_path.c_str(),+ IFACE_PROPS,+ "Set",+ g_variant_new("(ssv)", IFACE_MESSAGE, "Read", g_variant_new_boolean(read)),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ MAP_CALL_TIMEOUT_MS,+ nullptr,+ &error);+ if (!reply)+ return take_error(error, err);+ g_variant_unref(reply);+ return true;+ }++ bool MapSession::push_message(const std::string& folder, const std::string& bmessage, std::string& err) {+ if (bmessage.empty()) {+ err = "Refusing to send an empty message.";+ return false;+ }++ // obexd reads the message from a file. It is staged in the per-user+ // runtime directory rather than a shared temp directory, since it holds+ // the message text and the recipient.+ const char* runtime = getenv("XDG_RUNTIME_DIR");+ std::filesystem::path source =+ (runtime && *runtime ? std::filesystem::path(runtime) : std::filesystem::temp_directory_path()) /+ ("tether-send-" + std::to_string(getpid()) + ".bmsg");++ std::error_code ec;+ {+ std::ofstream out(source, std::ios::binary | std::ios::trunc);+ if (!out.is_open()) {+ err = "Cannot stage the message for sending.";+ return false;+ }+ out << bmessage;+ if (!out) {+ err = "Failed writing the staged message.";+ std::filesystem::remove(source, ec);+ return false;+ }+ }+ std::filesystem::permissions(source,+ std::filesystem::perms::owner_read | std::filesystem::perms::owner_write,+ std::filesystem::perm_options::replace,+ ec);++ GVariantBuilder args;+ g_variant_builder_init(&args, G_VARIANT_TYPE("a{sv}"));+ // The body is UTF-8; letting obexd transcode to the native charset would+ // mangle anything outside the phone's default encoding.+ g_variant_builder_add(&args, "{sv}", "Charset", g_variant_new_string("utf8"));++ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(state_->bus,+ OBEX_NAME,+ state_->path.c_str(),+ IFACE_MAP,+ "PushMessage",+ g_variant_new("(ssa{sv})", source.c_str(), folder.c_str(), &args),+ G_VARIANT_TYPE("(oa{sv})"),+ G_DBUS_CALL_FLAGS_NONE,+ MAP_CALL_TIMEOUT_MS,+ nullptr,+ &error);+ if (!reply) {+ take_error(error, err);+ std::filesystem::remove(source, ec);+ return false;+ }++ const gchar* transfer_path = nullptr;+ GVariant* props = nullptr;+ g_variant_get(reply, "(&o@a{sv})", &transfer_path, &props);+ const std::string transfer = transfer_path ? transfer_path : "";+ if (props)+ g_variant_unref(props);+ g_variant_unref(reply);++ if (transfer.empty()) {+ err = "obexd returned no transfer object.";+ std::filesystem::remove(source, ec);+ return false;+ }++ const TransferState state = wait_for_transfer(state_->bus, transfer, MAP_PUSH_TIMEOUT_SECONDS);+ std::filesystem::remove(source, ec);++ if (state == TransferState::Error) {+ err = "The phone rejected the message.";+ return false;+ }+ if (state == TransferState::Active) {+ // The transfer is still running, so the message may yet be sent.+ err = "Timed out waiting for the phone to accept the message; it may still be sent.";+ return false;+ }+ return true;+ }++ std::string map_handle_from_path(const std::string& object_path) {+ // "/org/bluez/obex/client/session5/message1086086778701665313" -> the+ // trailing id. The session number in the prefix changes on every+ // reconnect; the id does not.+ size_t slash = object_path.rfind('/');+ std::string tail = slash == std::string::npos ? object_path : object_path.substr(slash + 1);+ if (tail.rfind("message", 0) == 0)+ tail = tail.substr(7);+ return tail.empty() ? object_path : tail;+ }++ Message message_from_listing(const MapListing& listing) {+ VCardParty peer;+ peer.name = listing.sender_name;+ // MAP reports the address in one field without saying which kind it is;+ // an '@' is the only available discriminator.+ if (listing.sender_address.find('@') != std::string::npos)+ peer.email = listing.sender_address;+ else+ peer.tel = listing.sender_address;++ Message message;+ message.handle = map_handle_from_path(listing.handle);+ message.object_path = listing.handle;+ message.body = listing.subject;+ message.timestamp = parse_map_timestamp(listing.timestamp);+ message.read = listing.read;+ message.outgoing = listing.sent;+ message.folder = listing.folder;+ message.thread_key = thread_key_for(peer);+ message.peer_address = peer.tel.empty() ? normalize_email(peer.email) : normalize_phone(peer.tel);+ message.peer_name = peer.name;+ return message;+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/messages.cpp b/src/core/src/bluetooth/messages.cppnew file mode 100644index 0000000..fb3d7d8--- /dev/null+++ b/src/core/src/bluetooth/messages.cpp@@ -0,0 +1,162 @@+#include "tether/bluetooth/messages.hpp"++#include <algorithm>++namespace tether::bluetooth {++ namespace {++ bool is_outgoing_folder(const std::string& folder) {+ return folder.find("sent") != std::string::npos || folder.find("outbox") != std::string::npos;+ }++ std::string display_address(const VCardParty& party) {+ if (!party.tel.empty())+ return normalize_phone(party.tel);+ return normalize_email(party.email);+ }++ } // namespace++ MessageStore::MessageStore(size_t max_messages) : max_messages_(max_messages) {}++ bool MessageStore::add(const Message& message) {+ if (message.handle.empty())+ return false;+ if (auto it = by_handle_.find(message.handle); it != by_handle_.end()) {+ // re-listing after reconnect has a fresh object path for the same message+ if (!message.object_path.empty())+ it->second.object_path = message.object_path;+ return false;+ }++ by_handle_.emplace(message.handle, message);+ order_.push_back(message.handle);+ trim();+ return true;+ }++ bool MessageStore::set_read(const std::string& handle, bool read) {+ auto it = by_handle_.find(handle);+ if (it == by_handle_.end() || it->second.read == read)+ return false;+ it->second.read = read;+ return true;+ }++ const Message* MessageStore::find(const std::string& handle) const {+ auto it = by_handle_.find(handle);+ return it == by_handle_.end() ? nullptr : &it->second;+ }++ void MessageStore::trim() {+ while (order_.size() > max_messages_) {+ by_handle_.erase(order_.front());+ order_.erase(order_.begin());+ }+ }++ std::vector<Thread> MessageStore::threads() const {+ std::map<std::string, Thread> grouped;++ for (const auto& [handle, message] : by_handle_) {+ if (message.thread_key.empty())+ continue;+ Thread& thread = grouped[message.thread_key];+ thread.key = message.thread_key;+ thread.peer_address = message.peer_address;+ ++thread.count;++ if (thread.display_name.empty() ||+ (!message.peer_name.empty() && thread.display_name == thread.peer_address))+ if (!message.peer_name.empty())+ thread.display_name = message.peer_name;++ if (!message.read && !message.outgoing)+ ++thread.unread;++ if (message.timestamp >= thread.last_timestamp) {+ thread.last_timestamp = message.timestamp;+ thread.last_body = message.body;+ }+ }++ std::vector<Thread> result;+ result.reserve(grouped.size());+ for (auto& [key, thread] : grouped) {+ if (thread.display_name.empty())+ thread.display_name = thread.peer_address;+ result.push_back(thread);+ }++ std::sort(result.begin(), result.end(), [](const Thread& a, const Thread& b) {+ if (a.last_timestamp != b.last_timestamp)+ return a.last_timestamp > b.last_timestamp;+ return a.key < b.key;+ });+ return result;+ }++ std::vector<Message> MessageStore::messages(const std::string& thread_key, size_t limit) const {+ std::vector<Message> result;+ for (const auto& [handle, message] : by_handle_) {+ if (message.thread_key == thread_key)+ result.push_back(message);+ }++ std::sort(result.begin(), result.end(), [](const Message& a, const Message& b) {+ if (a.timestamp != b.timestamp)+ return a.timestamp < b.timestamp;+ return a.handle < b.handle;+ });++ if (result.size() > limit)+ result.erase(result.begin(), result.end() - static_cast<long>(limit));+ return result;+ }++ Message message_from_bmessage(const BMessage& parsed, const std::string& handle, int64_t timestamp) {+ Message message;+ message.handle = handle;+ message.timestamp = timestamp;+ message.read = parsed.read;+ message.folder = parsed.folder;+ message.body = parsed.body;+ message.outgoing = is_outgoing_folder(parsed.folder);++ const VCardParty& peer =+ message.outgoing && !parsed.recipients.empty() ? parsed.recipients.front() : parsed.originator;++ message.thread_key = thread_key_for(peer);+ message.peer_address = display_address(peer);+ message.peer_name = peer.name;+ return message;+ }++ nlohmann::json to_json(const Message& message) {+ return {+ {"handle", message.handle},+ {"thread", message.thread_key},+ {"address", message.peer_address},+ {"name", message.peer_name},+ {"body", message.body},+ {"timestamp", message.timestamp},+ {"outgoing", message.outgoing},+ {"read", message.read},+ {"folder", message.folder},+ };+ }++ nlohmann::json to_json(const Thread& thread) {+ return {+ {"thread", thread.key},+ {"name", thread.display_name},+ {"address", thread.peer_address},+ {"preview", thread.last_body},+ {"timestamp", thread.last_timestamp},+ {"unread", thread.unread},+ {"count", thread.count},+ };+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/monitor.cpp b/src/core/src/bluetooth/monitor.cppnew file mode 100644index 0000000..b4a0beb--- /dev/null+++ b/src/core/src/bluetooth/monitor.cpp@@ -0,0 +1,323 @@+#include "tether/bluetooth/monitor.hpp"+#include "tether/log.hpp"++#include <atomic>+#include <condition_variable>+#include <filesystem>+#include <fstream>+#include <gio/gio.h>+#include <mutex>+#include <sys/eventfd.h>+#include <thread>+#include <unistd.h>++namespace tether::bluetooth {++ BluezMonitor* g_bluez = nullptr;++ namespace {+ constexpr const char* BLUEZ_NAME = "org.bluez";+ constexpr const char* OBJECT_MANAGER = "org.freedesktop.DBus.ObjectManager";++ // BlueZ emits PropertiesChanged continuously during discovery (RSSI churn+ // above all). Coalesce bursts into one refresh instead of re-reading the+ // whole object tree per signal.+ constexpr guint REFRESH_DEBOUNCE_MS = 250;+ } // namespace++ struct MonitorState {+ std::thread thread;+ GMainContext* context = nullptr;+ GMainLoop* loop = nullptr;+ GDBusConnection* conn = nullptr;+ std::atomic<bool> running{false};++ int efd = -1;+ guint pending_refresh = 0;+ std::vector<guint> subscriptions;++ mutable std::mutex mutex;+ BluezObjects objects;+ Capability cap;++ void run();+ void refresh();+ void schedule_refresh();+ void notify();+ };++ namespace {++ gboolean on_refresh_timeout(gpointer user_data) {+ auto* impl = static_cast<MonitorState*>(user_data);+ impl->pending_refresh = 0;+ impl->refresh();+ return G_SOURCE_REMOVE;+ }++ void on_bluez_signal(+ GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant*, gpointer user_data) {+ static_cast<MonitorState*>(user_data)->schedule_refresh();+ }++ // on watcher thread once it iterates its context+ gboolean quit_loop(gpointer user_data) {+ auto* state = static_cast<MonitorState*>(user_data);+ if (state->loop)+ g_main_loop_quit(state->loop);+ return G_SOURCE_REMOVE;+ }++ } // namespace++ void MonitorState::notify() {+ if (efd < 0)+ return;+ uint64_t one = 1;+ if (write(efd, &one, sizeof(one)) < 0)+ debug::log(WARN, "bluetooth: failed to signal event fd");+ }++ void MonitorState::schedule_refresh() {+ if (pending_refresh != 0)+ return;+ GSource* source = g_timeout_source_new(REFRESH_DEBOUNCE_MS);+ g_source_set_callback(source, on_refresh_timeout, this, nullptr);+ pending_refresh = g_source_attach(source, context);+ g_source_unref(source);+ }++ // bluetoothd exposes no property for its own flags, so the argument vector is+ // the only place to read it. Accepts both spellings; Arch's unit uses -E.+ bool bluetoothd_has_experimental() {+ std::error_code ec;+ for (const auto& entry : std::filesystem::directory_iterator("/proc", ec)) {+ std::ifstream comm(entry.path() / "comm");+ std::string name;+ if (!comm || !std::getline(comm, name) || name != "bluetoothd")+ continue;++ std::ifstream cmdline(entry.path() / "cmdline", std::ios::binary);+ if (!cmdline)+ continue;+ // Arguments are NUL-separated, so each one compares exactly.+ std::string arg;+ while (std::getline(cmdline, arg, '\0')) {+ if (arg == "-E" || arg == "--experimental")+ return true;+ }+ return false;+ }+ return false;+ }++ void MonitorState::refresh() {+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(conn,+ BLUEZ_NAME,+ "/",+ OBJECT_MANAGER,+ "GetManagedObjects",+ nullptr,+ G_VARIANT_TYPE("(a{oa{sa{sv}}})"),+ G_DBUS_CALL_FLAGS_NONE,+ 5000,+ nullptr,+ &error);+ if (!reply) {+ debug::log(WARN, "bluetooth: GetManagedObjects failed: {}", error ? error->message : "unknown");+ g_clear_error(&error);+ return;+ }++ BluezObjects parsed = parse_managed_objects(reply);+ g_variant_unref(reply);+ parsed.experimental_api = bluetoothd_has_experimental();+ Capability resolved = resolve_capability(parsed);++ {+ std::lock_guard<std::mutex> lock(mutex);+ if (parsed == objects && resolved == cap)+ return;+ objects = std::move(parsed);+ cap = std::move(resolved);+ }+ notify();+ }++ void MonitorState::run() {+ g_main_context_push_thread_default(context);++ for (const char* signal : {"InterfacesAdded", "InterfacesRemoved"}) {+ subscriptions.push_back(g_dbus_connection_signal_subscribe(conn,+ BLUEZ_NAME,+ OBJECT_MANAGER,+ signal,+ "/",+ nullptr,+ G_DBUS_SIGNAL_FLAGS_NONE,+ on_bluez_signal,+ this,+ nullptr));+ }+ subscriptions.push_back(g_dbus_connection_signal_subscribe(conn,+ BLUEZ_NAME,+ "org.freedesktop.DBus.Properties",+ "PropertiesChanged",+ nullptr,+ nullptr,+ G_DBUS_SIGNAL_FLAGS_NONE,+ on_bluez_signal,+ this,+ nullptr));++ refresh();++ loop = g_main_loop_new(context, FALSE);+ g_main_loop_run(loop);+ running = false;++ for (guint id : subscriptions)+ g_dbus_connection_signal_unsubscribe(conn, id);+ subscriptions.clear();++ if (pending_refresh != 0) {+ if (GSource* s = g_main_context_find_source_by_id(context, pending_refresh))+ g_source_destroy(s);+ pending_refresh = 0;+ }++ g_main_context_pop_thread_default(context);+ }++ BluezMonitor::BluezMonitor() : impl_(std::make_unique<MonitorState>()) {}++ BluezMonitor::~BluezMonitor() { stop(); }++ bool BluezMonitor::start() {+ if (impl_->running)+ return true;++ GError* error = nullptr;+ impl_->conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, nullptr, &error);+ if (!impl_->conn) {+ debug::log(WARN, "bluetooth: cannot reach the system bus: {}", error ? error->message : "unknown");+ g_clear_error(&error);+ return false;+ }++ // fail fast when bluetoothd is not present+ GVariant* probe = g_dbus_connection_call_sync(impl_->conn,+ BLUEZ_NAME,+ "/",+ OBJECT_MANAGER,+ "GetManagedObjects",+ nullptr,+ G_VARIANT_TYPE("(a{oa{sa{sv}}})"),+ G_DBUS_CALL_FLAGS_NONE,+ 5000,+ nullptr,+ &error);+ if (!probe) {+ debug::log(WARN, "bluetooth: BlueZ unavailable: {}", error ? error->message : "unknown");+ g_clear_error(&error);+ g_clear_object(&impl_->conn);+ return false;+ }+ impl_->objects = parse_managed_objects(probe);+ impl_->objects.experimental_api = bluetoothd_has_experimental();+ impl_->cap = resolve_capability(impl_->objects);+ g_variant_unref(probe);++ impl_->efd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);+ if (impl_->efd < 0) {+ debug::log(ERR, "bluetooth: eventfd() failed");+ g_clear_object(&impl_->conn);+ return false;+ }++ impl_->context = g_main_context_new();+ impl_->running = true;+ impl_->thread = std::thread([this] { impl_->run(); });+ return true;+ }++ void BluezMonitor::stop() {+ if (impl_->thread.joinable()) {+ g_main_context_invoke(impl_->context, quit_loop, impl_.get());+ impl_->thread.join();+ }+ if (impl_->loop) {+ g_main_loop_unref(impl_->loop);+ impl_->loop = nullptr;+ }+ if (impl_->context) {+ g_main_context_unref(impl_->context);+ impl_->context = nullptr;+ }+ g_clear_object(&impl_->conn);+ if (impl_->efd >= 0) {+ close(impl_->efd);+ impl_->efd = -1;+ }+ }++ bool BluezMonitor::running() const { return impl_->running; }++ int BluezMonitor::event_fd() const { return impl_->efd; }++ void BluezMonitor::drain() {+ if (impl_->efd < 0)+ return;+ uint64_t counter = 0;+ while (read(impl_->efd, &counter, sizeof(counter)) > 0) {+ // Drain every pending wakeup; the snapshot is read separately.+ }+ }++ GDBusConnection* BluezMonitor::connection() const { return impl_->conn; }++ void BluezMonitor::invoke_sync(const std::function<void()>& fn) {+ if (!impl_->context) {+ fn();+ return;+ }++ struct Job {+ const std::function<void()>* fn;+ std::mutex mutex;+ std::condition_variable done;+ bool finished = false;+ } job{&fn, {}, {}, false};++ g_main_context_invoke_full(+ impl_->context,+ G_PRIORITY_DEFAULT,+ [](gpointer data) -> gboolean {+ auto* j = static_cast<Job*>(data);+ (*j->fn)();+ {+ std::lock_guard<std::mutex> lock(j->mutex);+ j->finished = true;+ }+ j->done.notify_all();+ return G_SOURCE_REMOVE;+ },+ &job,+ nullptr);++ std::unique_lock<std::mutex> lock(job.mutex);+ job.done.wait(lock, [&job] { return job.finished; });+ }++ BluezObjects BluezMonitor::snapshot() const {+ std::lock_guard<std::mutex> lock(impl_->mutex);+ return impl_->objects;+ }++ Capability BluezMonitor::capability() const {+ std::lock_guard<std::mutex> lock(impl_->mutex);+ return impl_->cap;+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/obex_transfer.cpp b/src/core/src/bluetooth/obex_transfer.cppnew file mode 100644index 0000000..be9805a--- /dev/null+++ b/src/core/src/bluetooth/obex_transfer.cpp@@ -0,0 +1,63 @@+#include "tether/bluetooth/obex_transfer.hpp"++#include <chrono>+#include <thread>++namespace tether::bluetooth {++ namespace {++ constexpr const char* OBEX_NAME = "org.bluez.obex";+ constexpr const char* IFACE_TRANSFER = "org.bluez.obex.Transfer1";+ constexpr const char* IFACE_PROPS = "org.freedesktop.DBus.Properties";+ constexpr int POLL_INTERVAL_MS = 200;++ TransferState poll_once(GDBusConnection* bus, const std::string& path) {+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(bus,+ OBEX_NAME,+ path.c_str(),+ IFACE_PROPS,+ "Get",+ g_variant_new("(ss)", IFACE_TRANSFER, "Status"),+ G_VARIANT_TYPE("(v)"),+ G_DBUS_CALL_FLAGS_NONE,+ 5000,+ nullptr,+ &error);+ if (!reply) {+ g_clear_error(&error);+ return TransferState::Gone;+ }++ GVariant* boxed = nullptr;+ g_variant_get(reply, "(v)", &boxed);+ std::string status;+ if (boxed && g_variant_is_of_type(boxed, G_VARIANT_TYPE_STRING))+ status = g_variant_get_string(boxed, nullptr);+ if (boxed)+ g_variant_unref(boxed);+ g_variant_unref(reply);++ if (status == "complete")+ return TransferState::Complete;+ if (status == "error")+ return TransferState::Error;+ return TransferState::Active;+ }++ } // namespace++ TransferState wait_for_transfer(GDBusConnection* bus, const std::string& path, int timeout_seconds) {+ const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(timeout_seconds);+ TransferState state = TransferState::Active;+ while (std::chrono::steady_clock::now() < deadline) {+ state = poll_once(bus, path);+ if (state != TransferState::Active)+ return state;+ std::this_thread::sleep_for(std::chrono::milliseconds(POLL_INTERVAL_MS));+ }+ return state;+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/objects.cpp b/src/core/src/bluetooth/objects.cppnew file mode 100644index 0000000..b00cf8a--- /dev/null+++ b/src/core/src/bluetooth/objects.cpp@@ -0,0 +1,358 @@+#include "tether/bluetooth/objects.hpp"++#include <algorithm>+#include <cstring>++namespace tether::bluetooth {++ namespace {++ constexpr const char* IFACE_ADAPTER = "org.bluez.Adapter1";+ constexpr const char* IFACE_DEVICE = "org.bluez.Device1";+ constexpr const char* IFACE_LE_ADV_MGR = "org.bluez.LEAdvertisingManager1";+ constexpr const char* IFACE_BEARER_LE = "org.bluez.Bearer.LE1";++ bool iequals(const std::string& a, const std::string& b) {+ return a.size() == b.size() &&+ std::equal(a.begin(), a.end(), b.begin(), [](unsigned char x, unsigned char y) {+ return std::tolower(x) == std::tolower(y);+ });+ }++ // Property lookup helpers. Every one tolerates a missing key or an+ // unexpected type.+ GVariant* lookup(GVariant* props, const char* key) {+ if (!props || !g_variant_is_of_type(props, G_VARIANT_TYPE("a{sv}")))+ return nullptr;+ return g_variant_lookup_value(props, key, nullptr);+ }++ std::string get_string(GVariant* props, const char* key) {+ GVariant* v = lookup(props, key);+ if (!v)+ return {};+ std::string out;+ if (g_variant_is_of_type(v, G_VARIANT_TYPE_STRING))+ out = g_variant_get_string(v, nullptr);+ g_variant_unref(v);+ return out;+ }++ bool get_bool(GVariant* props, const char* key, bool fallback = false) {+ GVariant* v = lookup(props, key);+ if (!v)+ return fallback;+ bool out = fallback;+ if (g_variant_is_of_type(v, G_VARIANT_TYPE_BOOLEAN))+ out = g_variant_get_boolean(v);+ g_variant_unref(v);+ return out;+ }++ uint32_t get_uint32(GVariant* props, const char* key) {+ GVariant* v = lookup(props, key);+ if (!v)+ return 0;+ uint32_t out = 0;+ if (g_variant_is_of_type(v, G_VARIANT_TYPE_UINT32))+ out = g_variant_get_uint32(v);+ g_variant_unref(v);+ return out;+ }++ uint8_t get_byte(GVariant* props, const char* key) {+ GVariant* v = lookup(props, key);+ if (!v)+ return 0;+ uint8_t out = 0;+ if (g_variant_is_of_type(v, G_VARIANT_TYPE_BYTE))+ out = g_variant_get_byte(v);+ g_variant_unref(v);+ return out;+ }++ std::vector<std::string> get_strv(GVariant* props, const char* key) {+ std::vector<std::string> out;+ GVariant* v = lookup(props, key);+ if (!v)+ return out;+ if (g_variant_is_of_type(v, G_VARIANT_TYPE_STRING_ARRAY)) {+ gsize n = 0;+ const gchar** items = g_variant_get_strv(v, &n);+ if (items) {+ out.reserve(n);+ for (gsize i = 0; i < n; ++i)+ out.emplace_back(items[i]);+ g_free(items);+ }+ }+ g_variant_unref(v);+ return out;+ }++ // BlueZ nests the object path under the adapter, e.g.+ // /org/bluez/hci0/dev_AA_BB_.. the parent path is the owning adapter.+ std::string parent_path(const std::string& path) {+ size_t slash = path.rfind('/');+ if (slash == std::string::npos || slash == 0)+ return {};+ return path.substr(0, slash);+ }++ void read_adapter(const std::string& path, GVariant* ifaces, BluezObjects& out) {+ GVariant* props = g_variant_lookup_value(ifaces, IFACE_ADAPTER, G_VARIANT_TYPE("a{sv}"));+ if (!props)+ return;++ Adapter a;+ a.path = path;+ a.address = get_string(props, "Address");+ a.name = get_string(props, "Alias");+ if (a.name.empty())+ a.name = get_string(props, "Name");+ a.device_class = get_uint32(props, "Class");+ a.powered = get_bool(props, "Powered");+ a.roles = get_strv(props, "Roles");+ g_variant_unref(props);++ if (GVariant* adv = g_variant_lookup_value(ifaces, IFACE_LE_ADV_MGR, G_VARIANT_TYPE("a{sv}"))) {+ a.has_advertising_manager = true;+ a.advertising_instances = get_byte(adv, "SupportedInstances");+ g_variant_unref(adv);+ }++ out.adapters.push_back(std::move(a));+ }++ void read_device(const std::string& path, GVariant* ifaces, BluezObjects& out) {+ GVariant* props = g_variant_lookup_value(ifaces, IFACE_DEVICE, G_VARIANT_TYPE("a{sv}"));+ if (!props)+ return;++ Device d;+ d.path = path;+ d.adapter_path = get_string(props, "Adapter");+ if (d.adapter_path.empty())+ d.adapter_path = parent_path(path);+ d.address = get_string(props, "Address");+ d.name = get_string(props, "Alias");+ if (d.name.empty())+ d.name = get_string(props, "Name");+ d.paired = get_bool(props, "Paired");+ // Older BlueZ has no Bonded property; a paired device is bonded there.+ d.bonded = get_bool(props, "Bonded", d.paired);+ d.trusted = get_bool(props, "Trusted");+ d.connected = get_bool(props, "Connected");+ d.uuids = get_strv(props, "UUIDs");+ g_variant_unref(props);++ if (GVariant* le = g_variant_lookup_value(ifaces, IFACE_BEARER_LE, G_VARIANT_TYPE("a{sv}"))) {+ d.has_le_bearer = true;+ d.le_paired = get_bool(le, "Paired");+ d.le_bonded = get_bool(le, "Bonded", d.le_paired);+ d.le_connected = get_bool(le, "Connected");+ g_variant_unref(le);+ }++ out.devices.push_back(std::move(d));+ }++ } // namespace++ bool Adapter::has_role(const std::string& role) const {+ return std::find(roles.begin(), roles.end(), role) != roles.end();+ }++ bool Device::has_uuid(const std::string& uuid) const {+ return std::any_of(uuids.begin(), uuids.end(), [&](const std::string& u) { return iequals(u, uuid); });+ }++ bool Device::looks_like_iphone() const { return supports_ancs() || (supports_map() && supports_pbap()); }++ const Adapter* BluezObjects::find_adapter(const std::string& path) const {+ auto it = std::find_if(adapters.begin(), adapters.end(), [&](const Adapter& a) { return a.path == path; });+ return it == adapters.end() ? nullptr : &*it;+ }++ const Device* BluezObjects::find_device(const std::string& path) const {+ auto it = std::find_if(devices.begin(), devices.end(), [&](const Device& d) { return d.path == path; });+ return it == devices.end() ? nullptr : &*it;+ }++ const char* to_string(DeliveryMode mode) {+ switch (mode) {+ case DeliveryMode::Full:+ return "full";+ case DeliveryMode::Compatibility:+ return "compatibility";+ default:+ return "blocked";+ }+ }++ const char* to_string(BearerApi api) {+ switch (api) {+ case BearerApi::Confirmed:+ return "confirmed";+ case BearerApi::Absent:+ return "absent";+ default:+ return "unknown";+ }+ }++ BluezObjects parse_managed_objects(GVariant* reply) {+ BluezObjects out;+ if (!reply)+ return out;++ // g_dbus_connection_call returns the reply wrapped in a single-element+ // tuple; tests and callers may pass the dictionary directly.+ GVariant* dict = nullptr;+ if (g_variant_is_of_type(reply, G_VARIANT_TYPE("(a{oa{sa{sv}}})")))+ dict = g_variant_get_child_value(reply, 0);+ else if (g_variant_is_of_type(reply, G_VARIANT_TYPE("a{oa{sa{sv}}}")))+ dict = g_variant_ref(reply);+ else+ return out;++ GVariantIter iter;+ const gchar* path = nullptr;+ GVariant* ifaces = nullptr;+ g_variant_iter_init(&iter, dict);+ while (g_variant_iter_loop(&iter, "{&o@a{sa{sv}}}", &path, &ifaces)) {+ read_adapter(path, ifaces, out);+ read_device(path, ifaces, out);+ }+ g_variant_unref(dict);++ // BlueZ enumerates in a stable but unspecified order; sorting keeps+ // snapshot comparison and UI listing deterministic.+ std::sort(out.adapters.begin(), out.adapters.end(), [](const Adapter& a, const Adapter& b) {+ return a.path < b.path;+ });+ std::sort(+ out.devices.begin(), out.devices.end(), [](const Device& a, const Device& b) { return a.path < b.path; });+ return out;+ }++ Capability resolve_capability(const BluezObjects& objects) {+ Capability cap;++ // prefer powered adapter, fall back to the first so the reasons below+ // can explain an unpowered one rather than reporting nothing at all.+ const Adapter* adapter = nullptr;+ for (const auto& a : objects.adapters) {+ if (a.powered) {+ adapter = &a;+ break;+ }+ }+ if (!adapter && !objects.adapters.empty())+ adapter = &objects.adapters.front();++ if (!adapter) {+ cap.reasons.emplace_back("No Bluetooth adapter found.");+ return cap;+ }++ cap.adapter_present = true;+ cap.powered = adapter->powered;+ cap.le_central = adapter->has_role("central");+ cap.le_peripheral = adapter->has_role("peripheral");+ cap.advertising = adapter->has_advertising_manager && adapter->advertising_instances > 0;+ cap.class_ok = adapter->class_is_handsfree();++ for (const auto& d : objects.devices) {+ if (d.has_le_bearer)+ cap.bearer_api = BearerApi::Confirmed;+ }+ if (cap.bearer_api != BearerApi::Confirmed)+ cap.bearer_api = objects.experimental_api ? BearerApi::Unknown : BearerApi::Absent;++ if (!cap.powered) {+ cap.reasons.emplace_back("Bluetooth adapter is powered off.");+ cap.mode = DeliveryMode::Blocked;+ return cap;+ }+ if (!cap.le_central) {+ cap.reasons.emplace_back("Adapter has no LE central role; ANCS is impossible.");+ cap.mode = DeliveryMode::Blocked;+ return cap;+ }++ // Past this point messages and contacts are reachable; only ANCS is at risk.+ cap.mode = DeliveryMode::Full;++ if (!cap.le_peripheral) {+ cap.reasons.emplace_back("Adapter cannot advertise as a peripheral, so ANCS cannot be solicited.");+ cap.mode = DeliveryMode::Compatibility;+ }+ if (!cap.advertising) {+ cap.reasons.emplace_back("No LE advertising instances available; the iPhone may never show its "+ "Bluetooth permission toggles.");+ cap.mode = DeliveryMode::Compatibility;+ }+ if (cap.bearer_api == BearerApi::Absent) {+ cap.reasons.emplace_back("BlueZ is not exposing org.bluez.Bearer.LE1. Run bluetoothd with "+ "--experimental to enable notification mirroring.");+ cap.mode = DeliveryMode::Compatibility;+ } else if (cap.bearer_api == BearerApi::Unknown) {+ cap.reasons.emplace_back("Bearer API support is unconfirmed until a device is bonded.");+ }+ if (!cap.class_ok) {+ cap.reasons.emplace_back("Adapter Class of Device is not A/V Hands-Free (major 4, minor 8); "+ "the iPhone will not offer its Messages and Contacts permissions.");+ }++ return cap;+ }++ nlohmann::json to_json(const Adapter& a) {+ return {+ {"path", a.path},+ {"address", a.address},+ {"name", a.name},+ {"class", a.device_class},+ {"powered", a.powered},+ {"roles", a.roles},+ {"advertising_instances", a.advertising_instances},+ {"class_ok", a.class_is_handsfree()},+ };+ }++ nlohmann::json to_json(const Device& d) {+ return {+ {"path", d.path},+ {"adapter", d.adapter_path},+ {"address", d.address},+ {"name", d.name},+ {"paired", d.paired},+ {"bonded", d.bonded},+ {"trusted", d.trusted},+ {"connected", d.connected},+ {"le_bearer", d.has_le_bearer},+ {"le_bonded", d.le_bonded},+ {"le_connected", d.le_connected},+ {"map", d.supports_map()},+ {"pbap", d.supports_pbap()},+ {"ancs", d.supports_ancs()},+ {"iphone", d.looks_like_iphone()},+ };+ }++ nlohmann::json to_json(const Capability& c) {+ return {+ {"mode", to_string(c.mode)},+ {"bearer_api", to_string(c.bearer_api)},+ {"adapter_present", c.adapter_present},+ {"powered", c.powered},+ {"le_central", c.le_central},+ {"le_peripheral", c.le_peripheral},+ {"advertising", c.advertising},+ {"class_ok", c.class_ok},+ {"reasons", c.reasons},+ };+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/pairing.cpp b/src/core/src/bluetooth/pairing.cppnew file mode 100644index 0000000..dad6994--- /dev/null+++ b/src/core/src/bluetooth/pairing.cpp@@ -0,0 +1,516 @@+#include "tether/bluetooth/pairing.hpp"+#include "tether/bluetooth/advert.hpp"+#include "tether/bluetooth/agent.hpp"+#include "tether/bluetooth/monitor.hpp"+#include "tether/log.hpp"++#include <chrono>+#include <filesystem>+#include <sys/wait.h>+#include <thread>+#include <unistd.h>++namespace tether::bluetooth {++ namespace {++ constexpr const char* BLUEZ_NAME = "org.bluez";+ constexpr const char* IFACE_DEVICE = "org.bluez.Device1";+ constexpr const char* IFACE_ADAPTER = "org.bluez.Adapter1";+ constexpr const char* IFACE_PROPS = "org.freedesktop.DBus.Properties";++ // iphone shows its confirmation prompt and waits for a slow human+ constexpr int PAIR_TIMEOUT_SECONDS = 90;+ constexpr int DIALOG_TIMEOUT_SECONDS = 60;++ constexpr int CLASSIC_SETTLE_SECONDS = 3;+ constexpr int DISCOVERY_TIMEOUT_SECONDS = 30;++ std::string normalize_address(std::string address) {+ for (char& c : address)+ c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));+ return address;+ }++ void notify(const ProgressFn& progress, const std::string& step, const std::string& detail) {+ debug::log(INFO, "bluetooth: {} {}", step, detail);+ if (progress)+ progress(step, detail);+ }++ bool set_property(GDBusConnection* conn,+ const std::string& path,+ const char* iface,+ const char* name,+ GVariant* value,+ std::string* err_out = nullptr) {+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(conn,+ BLUEZ_NAME,+ path.c_str(),+ IFACE_PROPS,+ "Set",+ g_variant_new("(ssv)", iface, name, value),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ 5000,+ nullptr,+ &error);+ if (!reply) {+ if (err_out)+ *err_out = error ? error->message : "unknown";+ g_clear_error(&error);+ return false;+ }+ g_variant_unref(reply);+ return true;+ }++ bool call_device(+ GDBusConnection* conn, const std::string& path, const char* method, int timeout_ms, std::string& err_out) {+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(conn,+ BLUEZ_NAME,+ path.c_str(),+ IFACE_DEVICE,+ method,+ nullptr,+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ timeout_ms,+ nullptr,+ &error);+ if (!reply) {+ err_out = error ? error->message : "unknown error";+ g_clear_error(&error);+ return false;+ }+ g_variant_unref(reply);+ return true;+ }++ const Device* find_by_address(const BluezObjects& objects, const std::string& address) {+ for (const auto& d : objects.devices) {+ if (normalize_address(d.address) == address)+ return &d;+ }+ return nullptr;+ }++ // Copies out the device record rather than holding a pointer into a+ // snapshot that the watcher thread replaces underneath us.+ bool lookup(BluezMonitor& monitor, const std::string& address, Device& out) {+ auto objects = monitor.snapshot();+ if (const Device* d = find_by_address(objects, address)) {+ out = *d;+ return true;+ }+ return false;+ }++ bool call_adapter(GDBusConnection* conn, const std::string& path, const char* method) {+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(conn,+ BLUEZ_NAME,+ path.c_str(),+ IFACE_ADAPTER,+ method,+ nullptr,+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ 5000,+ nullptr,+ &error);+ if (!reply) {+ debug::log(WARN, "bluetooth: {} failed: {}", method, error ? error->message : "unknown");+ g_clear_error(&error);+ return false;+ }+ g_variant_unref(reply);+ return true;+ }++ // Scans until the device shows up. Needed because an unpair makes BlueZ+ // forget the device entirely, which would otherwise leave no way to pair+ // again from inside the app.+ bool discover(BluezMonitor& monitor, GDBusConnection* conn, const std::string& address, Device& out) {+ auto objects = monitor.snapshot();+ if (objects.adapters.empty())+ return false;+ const std::string adapter = objects.adapters.front().path;++ if (!call_adapter(conn, adapter, "StartDiscovery"))+ return false;++ const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(DISCOVERY_TIMEOUT_SECONDS);+ bool found = false;+ while (std::chrono::steady_clock::now() < deadline) {+ if (lookup(monitor, address, out)) {+ found = true;+ break;+ }+ std::this_thread::sleep_for(std::chrono::milliseconds(500));+ }++ // discovery must stop before pairing+ call_adapter(conn, adapter, "StopDiscovery");+ return found;+ }++ // Connect-first makes the iPhone the authentication initiator, so BlueZ+ // must accept an inbound pairing request for the transaction to complete.+ // A desktop adapter normally sits with Pairable off, in which case iOS+ // never shows its half of the numeric comparison and the link fails with+ // br-connection-key-missing.+ //+ // Restores the previous values on every exit path, including the early+ // returns and the timeout.+ class PairableWindow {+ public:+ PairableWindow(GDBusConnection* conn, std::string adapter) : conn_(conn), adapter_(std::move(adapter)) {+ if (adapter_.empty())+ return;+ was_pairable_ = get_bool(IFACE_ADAPTER, "Pairable");+ was_discoverable_ = get_bool(IFACE_ADAPTER, "Discoverable");+ set_bool("Pairable", true);+ set_bool("Discoverable", true);+ }++ ~PairableWindow() {+ if (adapter_.empty())+ return;+ set_bool("Pairable", was_pairable_);+ set_bool("Discoverable", was_discoverable_);+ }++ PairableWindow(const PairableWindow&) = delete;+ PairableWindow& operator=(const PairableWindow&) = delete;++ private:+ bool get_bool(const char* iface, const char* name) const {+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(conn_,+ BLUEZ_NAME,+ adapter_.c_str(),+ IFACE_PROPS,+ "Get",+ g_variant_new("(ss)", iface, name),+ G_VARIANT_TYPE("(v)"),+ G_DBUS_CALL_FLAGS_NONE,+ 5000,+ nullptr,+ &error);+ if (!reply) {+ g_clear_error(&error);+ return false;+ }+ GVariant* boxed = nullptr;+ g_variant_get(reply, "(v)", &boxed);+ const bool value = boxed && g_variant_get_boolean(boxed);+ if (boxed)+ g_variant_unref(boxed);+ g_variant_unref(reply);+ return value;+ }++ void set_bool(const char* name, bool value) const {+ set_property(conn_, adapter_, IFACE_ADAPTER, name, g_variant_new_boolean(value));+ }++ GDBusConnection* conn_;+ std::string adapter_;+ bool was_pairable_ = false;+ bool was_discoverable_ = false;+ };++ std::string adapter_for(BluezMonitor& monitor, const Device& device) {+ if (!device.adapter_path.empty())+ return device.adapter_path;+ auto objects = monitor.snapshot();+ return objects.adapters.empty() ? std::string{} : objects.adapters.front().path;+ }++ // The solicitation advertise outlives the transaction that started it, so it+ // is owned here rather than on a stack frame.+ AncsAdvertisement* g_advert = nullptr;++ // An advert soliciting ANCS must never be on air while Classic pairing is in flight+ void stop_advert(BluezMonitor& monitor) {+ if (!g_advert)+ return;+ g_advert->unregister_with_bluez();+ monitor.invoke_sync([&] { g_advert->unexport_object(); });+ delete g_advert;+ g_advert = nullptr;+ }++ } // namespace++ bool confirm_with_dialog(const std::string& device_name, const std::string& code) {+ std::string body =+ device_name + " wants to pair.\n\nConfirm this code matches the one on your iPhone:\n\n" + code;++ pid_t pid = fork();+ if (pid < 0) {+ debug::log(ERR, "bluetooth: fork() for confirmation dialog failed");+ return false;+ }++ if (pid == 0) {+ std::filesystem::path self_path;+ try {+ self_path = std::filesystem::read_symlink("/proc/self/exe");+ } catch (...) {+ }+ std::string sibling = (self_path.parent_path() / "tether-dialog").string();+ std::string timeout = std::to_string(DIALOG_TIMEOUT_SECONDS);++ execl(sibling.c_str(),+ "tether-dialog",+ "--title",+ "Bluetooth Pairing",+ "--body",+ body.c_str(),+ "--accept",+ "Confirm",+ "--reject",+ "Cancel",+ "--timeout",+ timeout.c_str(),+ nullptr);+ execlp("tether-dialog",+ "tether-dialog",+ "--title",+ "Bluetooth Pairing",+ "--body",+ body.c_str(),+ "--accept",+ "Confirm",+ "--reject",+ "Cancel",+ "--timeout",+ timeout.c_str(),+ nullptr);+ _exit(3);+ }++ int status = 0;+ if (waitpid(pid, &status, 0) < 0)+ return false;+ // Exit 0 is the only acceptance. A dialog that could not be shown exits 3,+ // which must reject rather than silently bond.+ return WIFEXITED(status) && WEXITSTATUS(status) == 0;+ }++ nlohmann::json to_json(const PairResult& result) {+ return {+ {"command", "bt_pair_result"},+ {"success", result.success},+ {"status", result.status},+ {"message", result.message},+ {"address", result.device_address},+ {"dual_bond", result.dual_bond},+ };+ }++ PairResult pair_device(BluezMonitor& monitor,+ const std::string& address,+ AuthStrategy strategy,+ const ProgressFn& progress,+ const ConfirmFn& confirm) {+ PairResult result;+ result.device_address = normalize_address(address);++ GDBusConnection* conn = monitor.connection();+ if (!conn) {+ result.status = "error";+ result.message = "Bluetooth is unavailable.";+ return result;+ }++ PairableWindow pairable(conn, [&] {+ auto objects = monitor.snapshot();+ return objects.adapters.empty() ? std::string{} : objects.adapters.front().path;+ }());++ Device device;+ if (!lookup(monitor, result.device_address, device)) {+ notify(progress, "discovering", result.device_address);+ if (!discover(monitor, conn, result.device_address, device)) {+ result.status = "not_found";+ result.message = "Device " + result.device_address ++ " is not visible to BlueZ. Unlock the iPhone and open its Bluetooth settings so it "+ "is discoverable, then try again.";+ return result;+ }+ }+ result.device_path = device.path;++ const std::string adapter_path = adapter_for(monitor, device);+ const std::string display_name = device.name.empty() ? result.device_address : device.name;++ if (device.paired) {+ notify(progress, "already_paired", display_name);+ result.success = true;+ result.status = "already_paired";+ result.dual_bond = device.has_le_bearer && device.le_bonded;+ result.message = display_name + " is already paired.";+ } else {+ auto cap = monitor.capability();+ if (!cap.class_ok) {+ notify(progress,+ "warning",+ "Adapter class is not A/V Hands-Free; the iPhone may not offer its permissions. "+ "Run scripts/bt-probe.sh --set-class.");+ }++ // Silence any advert left over from an earlier pairing before+ // authentication starts.+ stop_advert(monitor);++ PairingAgent agent(conn, device.path, [&](const std::string& code) {+ notify(progress, "confirm", code);+ return confirm ? confirm(code) : confirm_with_dialog(display_name, code);+ });++ bool exported = false;+ monitor.invoke_sync([&] { exported = agent.export_object(); });+ if (!exported || !agent.register_with_bluez()) {+ monitor.invoke_sync([&] { agent.unexport_object(); });+ result.status = "error";+ result.message = "Could not register a Bluetooth pairing agent.";+ return result;+ }++ std::string err;+ bool initiated = false;+ if (strategy == AuthStrategy::ConnectFirst) {+ notify(progress, "connecting", display_name);+ initiated = call_device(conn, device.path, "Connect", PAIR_TIMEOUT_SECONDS * 1000, err);+ } else {+ notify(progress, "pairing", display_name);+ initiated = call_device(conn, device.path, "Pair", PAIR_TIMEOUT_SECONDS * 1000, err);+ }++ // Connect() can report failure while authentication still completes+ auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(PAIR_TIMEOUT_SECONDS);+ bool paired = false;+ while (std::chrono::steady_clock::now() < deadline) {+ Device current;+ if (lookup(monitor, result.device_address, current) && current.paired) {+ paired = true;+ device = current;+ break;+ }+ std::this_thread::sleep_for(std::chrono::milliseconds(500));+ }++ agent.unregister_with_bluez();+ monitor.invoke_sync([&] { agent.unexport_object(); });++ if (!paired) {+ result.status = err.find("Rejected") != std::string::npos ? "rejected" : "timeout";+ result.message = initiated ? "Pairing did not complete. Confirm the prompt on the iPhone."+ : ("Pairing failed: " + err);+ return result;+ }++ notify(progress, "paired", display_name);+ result.success = true;+ result.status = "paired";+ result.message = "Paired with " + display_name + ".";+ }++ // Trusting the bond lets BlueZ reconnect without asking again.+ std::string trust_err;+ if (!set_property(conn, device.path, IFACE_DEVICE, "Trusted", g_variant_new_boolean(TRUE), &trust_err))+ debug::log(WARN, "bluetooth: could not trust device: {}", trust_err);++ // Prefer BR/EDR for the next outbound connection, then let the Classic ACL+ // settle before anything touches LE. Older BlueZ has no such property.+ set_property(conn, device.path, IFACE_DEVICE, "PreferredBearer", g_variant_new_string("bredr"));+ notify(progress, "settling", "waiting for the Classic link to settle");+ std::this_thread::sleep_for(std::chrono::seconds(CLASSIC_SETTLE_SECONDS));++ Device settled;+ if (lookup(monitor, result.device_address, settled))+ result.dual_bond = settled.has_le_bearer && settled.le_bonded;++ // Only now solicit ANCS. This advert is what makes iOS reveal its+ // "Show Message Notifications" and "Sync Contacts" toggles, and it is safe+ // to broadcast because the bond already exists.+ if (!adapter_path.empty() && monitor.capability().advertising) {+ stop_advert(monitor);+ auto* advert = new AncsAdvertisement(conn, adapter_path);++ bool exported = false;+ monitor.invoke_sync([&] { exported = advert->export_object(); });+ // BlueZ reads the advertisement's properties back before returning, so+ // this call must stay off the thread that answers those reads.+ if (exported && advert->register_with_bluez()) {+ g_advert = advert;+ notify(progress,+ "soliciting",+ "Open Settings > Bluetooth > (i) on the iPhone and enable Show Message Notifications and "+ "Sync Contacts. They can take a few minutes to appear.");+ } else {+ monitor.invoke_sync([&] { advert->unexport_object(); });+ delete advert;+ notify(progress, "warning", "Could not advertise for ANCS; notification permissions may not appear.");+ }+ }++ if (!result.dual_bond) {+ result.message += " The bond covers BR/EDR only, so messages and contacts will work but notification "+ "mirroring will not.";+ }+ return result;+ }++ PairResult unpair_device(BluezMonitor& monitor, const std::string& address) {+ PairResult result;+ result.device_address = normalize_address(address);++ GDBusConnection* conn = monitor.connection();+ if (!conn) {+ result.status = "error";+ result.message = "Bluetooth is unavailable.";+ return result;+ }++ Device device;+ if (!lookup(monitor, result.device_address, device)) {+ result.status = "not_found";+ result.message = "Device " + result.device_address + " is not known to BlueZ.";+ return result;+ }++ const std::string adapter_path = adapter_for(monitor, device);+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(conn,+ BLUEZ_NAME,+ adapter_path.c_str(),+ IFACE_ADAPTER,+ "RemoveDevice",+ g_variant_new("(o)", device.path.c_str()),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ 10000,+ nullptr,+ &error);+ if (!reply) {+ result.status = "error";+ result.message = std::string("Could not remove the bond: ") + (error ? error->message : "unknown");+ g_clear_error(&error);+ return result;+ }+ g_variant_unref(reply);++ result.success = true;+ result.status = "unpaired";+ result.message = "Removed the bond. Also delete this computer from the iPhone's Bluetooth settings before "+ "pairing again — a stale record there will block a clean retry.";+ return result;+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/pbap_session.cpp b/src/core/src/bluetooth/pbap_session.cppnew file mode 100644index 0000000..4fbf61c--- /dev/null+++ b/src/core/src/bluetooth/pbap_session.cpp@@ -0,0 +1,152 @@+#include "tether/bluetooth/pbap_session.hpp"+#include "tether/bluetooth/obex_transfer.hpp"++#include <chrono>+#include <cstdlib>+#include <filesystem>+#include <fstream>+#include <thread>+#include <unistd.h>++namespace tether::bluetooth {++ namespace {++ constexpr const char* OBEX_NAME = "org.bluez.obex";+ constexpr const char* IFACE_PBAP = "org.bluez.obex.PhonebookAccess1";++ constexpr int POLL_INTERVAL_MS = 200;++ bool take_error(GError*& error, std::string& err_out) {+ err_out = error ? error->message : "unknown error";+ g_clear_error(&error);+ return false;+ }++ // The phonebook is personal data, so it is staged in the per-user runtime+ // directory rather than a world-readable /tmp.+ std::filesystem::path staging_file() {+ const char* runtime = getenv("XDG_RUNTIME_DIR");+ std::filesystem::path dir =+ runtime && *runtime ? std::filesystem::path(runtime) : std::filesystem::temp_directory_path();+ return dir / ("tether-pbap-" + std::to_string(getpid()) + ".vcf");+ }++ std::string read_file(const std::filesystem::path& path) {+ std::ifstream in(path, std::ios::binary);+ if (!in.is_open())+ return {};+ return std::string((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());+ }++ } // namespace++ struct PbapSessionState {+ GDBusConnection* bus = nullptr;+ std::string path;+ };++ PbapSession::PbapSession(GDBusConnection* session_bus, std::string session_path)+ : state_(std::make_unique<PbapSessionState>()) {+ state_->bus = session_bus;+ state_->path = std::move(session_path);+ }++ PbapSession::~PbapSession() = default;++ const std::string& PbapSession::path() const { return state_->path; }++ bool PbapSession::select_phonebook(std::string& err, const std::string& location, const std::string& phonebook) {+ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(state_->bus,+ OBEX_NAME,+ state_->path.c_str(),+ IFACE_PBAP,+ "Select",+ g_variant_new("(ss)", location.c_str(), phonebook.c_str()),+ nullptr,+ G_DBUS_CALL_FLAGS_NONE,+ PBAP_CALL_TIMEOUT_MS,+ nullptr,+ &error);+ if (!reply)+ return take_error(error, err);+ g_variant_unref(reply);+ return true;+ }++ std::vector<VCard> PbapSession::pull_all(std::string& err, int max) {+ std::vector<VCard> contacts;++ const std::filesystem::path target = staging_file();+ std::error_code ec;+ std::filesystem::remove(target, ec);++ GVariantBuilder filter;+ g_variant_builder_init(&filter, G_VARIANT_TYPE("a{sv}"));+ g_variant_builder_add(&filter, "{sv}", "Format", g_variant_new_string("vcard30"));+ // MaxCount, not MAP's MaxListCount.+ g_variant_builder_add(&filter, "{sv}", "MaxCount", g_variant_new_uint16(static_cast<guint16>(max)));++ GError* error = nullptr;+ GVariant* reply = g_dbus_connection_call_sync(state_->bus,+ OBEX_NAME,+ state_->path.c_str(),+ IFACE_PBAP,+ "PullAll",+ g_variant_new("(sa{sv})", target.c_str(), &filter),+ G_VARIANT_TYPE("(oa{sv})"),+ G_DBUS_CALL_FLAGS_NONE,+ PBAP_CALL_TIMEOUT_MS,+ nullptr,+ &error);+ if (!reply) {+ take_error(error, err);+ return contacts;+ }++ const gchar* transfer_path = nullptr;+ GVariant* props = nullptr;+ g_variant_get(reply, "(&o@a{sv})", &transfer_path, &props);+ const std::string transfer = transfer_path ? transfer_path : "";+ if (props)+ g_variant_unref(props);+ g_variant_unref(reply);++ if (transfer.empty()) {+ err = "obexd returned no transfer object";+ return contacts;+ }++ const TransferState state = wait_for_transfer(state_->bus, transfer, PBAP_TRANSFER_TIMEOUT_SECONDS);++ if (state == TransferState::Error) {+ err = "phonebook transfer failed";+ std::filesystem::remove(target, ec);+ return contacts;+ }+ if (state == TransferState::Active) {+ err = "phonebook transfer timed out";+ std::filesystem::remove(target, ec);+ return contacts;+ }++ // Both Complete and Gone are terminal, and in either case the file can+ // still be a moment behind, so wait a bounded time for it to appear.+ const auto grace = std::chrono::steady_clock::now() + std::chrono::seconds(PBAP_FILE_GRACE_SECONDS);+ while (!std::filesystem::exists(target, ec) && std::chrono::steady_clock::now() < grace)+ std::this_thread::sleep_for(std::chrono::milliseconds(POLL_INTERVAL_MS));++ const std::string text = read_file(target);+ std::filesystem::remove(target, ec);++ if (text.empty()) {+ err = "phonebook transfer produced no data";+ return contacts;+ }++ contacts = parse_vcards(text);+ return contacts;+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/profile_supervisor.cpp b/src/core/src/bluetooth/profile_supervisor.cppnew file mode 100644index 0000000..4e4b7df--- /dev/null+++ b/src/core/src/bluetooth/profile_supervisor.cpp@@ -0,0 +1,177 @@+#include "tether/bluetooth/profile_supervisor.hpp"+#include "tether/log.hpp"++#include <algorithm>+#include <cctype>++namespace tether::bluetooth {++ namespace {++ std::string lowered(std::string text) {+ std::transform(text.begin(), text.end(), text.begin(), [](unsigned char c) {+ return static_cast<char>(std::tolower(c));+ });+ return text;+ }++ bool contains(const std::string& haystack, const char* needle) {+ return haystack.find(needle) != std::string::npos;+ }++ } // namespace++ const char* to_string(ObexError error) {+ switch (error) {+ case ObexError::None:+ return "none";+ case ObexError::Forbidden:+ return "forbidden";+ case ObexError::Busy:+ return "busy";+ case ObexError::NoRecord:+ return "no_record";+ case ObexError::Unavailable:+ return "unavailable";+ default:+ return "other";+ }+ }++ ObexError classify_obex_error(const std::string& message) {+ if (message.empty())+ return ObexError::None;++ const std::string text = lowered(message);++ // permission toggle is off on the phone+ if (contains(text, "forbidden") || contains(text, "0x43"))+ return ObexError::Forbidden;++ if (contains(text, "connection refused") || contains(text, "(111)"))+ return ObexError::Busy;++ if (contains(text, "unable to find service record") || contains(text, "no such service"))+ return ObexError::NoRecord;++ if (contains(text, "host is down") || contains(text, "no route to host") || contains(text, "not connected") ||+ contains(text, "page timeout"))+ return ObexError::Unavailable;++ return ObexError::Other;+ }++ std::string obex_error_advice(ObexError error, const std::string& profile) {+ const std::string label = profile == "map" ? "Messages" : "Contacts";+ switch (error) {+ case ObexError::Forbidden:+ return "Enable \"" ++ (profile == "map" ? std::string("Show Message Notifications") : std::string("Sync Contacts")) ++ "\" for this computer in the iPhone's Settings > Bluetooth > (i). "+ "This is a permission, not a pairing problem.";+ case ObexError::Busy:+ return label + " is unavailable because another computer is using the iPhone's " + profile ++ " session. Disconnect it there, then this will connect on its own.";+ case ObexError::NoRecord:+ // obexd reports a missing record whenever its SDP fetch is refused, so the real cause is usually one layer+ // down.+ return label ++ " could not be fetched from the iPhone. Usually another computer holds the phone's "+ "Bluetooth session, or \"" ++ (profile == "map" ? std::string("Show Message Notifications") : std::string("Sync Contacts")) ++ "\" is off in Settings > Bluetooth > (i). Check both; re-pairing is not the fix.";+ case ObexError::Unavailable:+ return label + " is unreachable; waiting for the iPhone to come back.";+ case ObexError::Other:+ return label + " could not be opened.";+ default:+ return {};+ }+ }++ ProfileSupervisor::ProfileSupervisor(ProfileOps& ops) : ops_(ops) {}++ void ProfileSupervisor::reset() {+ if (!map_path_.empty())+ ops_.remove_session(map_path_);+ if (!pbap_path_.empty())+ ops_.remove_session(pbap_path_);+ map_path_.clear();+ pbap_path_.clear();+ map_retried_ = false;+ pbap_retried_ = false;+ next_attempt_ = 0;+ status_.map_open = false;+ status_.pbap_open = false;+ }++ bool+ ProfileSupervisor::open_profile(const std::string& target, std::string& path, ObexError& error, bool& retried) {+ std::string err;+ path = ops_.create_session(target, err);+ if (!path.empty()) {+ error = ObexError::None;+ retried = false;+ return true;+ }++ error = classify_obex_error(err);+ debug::log(WARN, "bluetooth: {} session failed ({}): {}", target, to_string(error), err);++ // A stale session from a previous run can present as Forbidden. Drop only+ // this profile's session and try once more, rather than restarting obexd.+ if (error == ObexError::Forbidden && !retried) {+ retried = true;+ ops_.remove_session(path);+ path = ops_.create_session(target, err);+ if (!path.empty()) {+ error = ObexError::None;+ return true;+ }+ error = classify_obex_error(err);+ }+ return false;+ }++ bool ProfileSupervisor::tick(int64_t now, bool link_ready) {+ ProfileStatus previous = status_;++ if (!link_ready) {+ // Nothing to do until the Classic bearer is up; hold what we have and+ // let reset() handle an actual disconnect.+ status_.reason = "Waiting for the Bluetooth link.";+ return !(status_ == previous);+ }++ if (status_.map_open && status_.pbap_open) {+ status_.reason = "Messages and contacts are connected.";+ return !(status_ == previous);+ }++ if (now < next_attempt_)+ return !(status_ == previous);++ if (!status_.map_open)+ status_.map_open = open_profile("map", map_path_, status_.map_error, map_retried_);+ if (!status_.pbap_open)+ status_.pbap_open = open_profile("pbap", pbap_path_, status_.pbap_error, pbap_retried_);++ if (status_.map_open || status_.pbap_open)+ opened_once_ = true;+ next_attempt_ = now + (opened_once_ ? PROFILE_STEADY_POLL_SECONDS : PROFILE_INITIAL_POLL_SECONDS);++ if (status_.map_open && status_.pbap_open) {+ status_.reason = "Messages and contacts are connected.";+ } else if (!status_.map_open && status_.map_error != ObexError::None) {+ // MAP is the feature people notice, so its problem leads.+ status_.reason = obex_error_advice(status_.map_error, "map");+ } else if (!status_.pbap_open && status_.pbap_error != ObexError::None) {+ status_.reason = obex_error_advice(status_.pbap_error, "pbap");+ } else {+ status_.reason = "Opening messages and contacts...";+ }++ return !(status_ == previous);+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/bluetooth/vcard.cpp b/src/core/src/bluetooth/vcard.cppnew file mode 100644index 0000000..8a360e7--- /dev/null+++ b/src/core/src/bluetooth/vcard.cpp@@ -0,0 +1,168 @@+#include "tether/bluetooth/vcard.hpp"++#include <algorithm>+#include <cctype>++namespace tether::bluetooth {++ namespace {++ std::string trim(const std::string& text) {+ size_t begin = text.find_first_not_of(" \t\r\n");+ if (begin == std::string::npos)+ return {};+ size_t end = text.find_last_not_of(" \t\r\n");+ return text.substr(begin, end - begin + 1);+ }++ std::string upper(std::string text) {+ std::transform(text.begin(), text.end(), text.begin(), [](unsigned char c) {+ return static_cast<char>(std::toupper(c));+ });+ return text;+ }++ } // namespace++ std::vector<std::string> vcard_unfold(const std::string& text) {+ std::vector<std::string> lines;+ size_t start = 0;+ while (start <= text.size()) {+ size_t nl = text.find('\n', start);+ std::string line = nl == std::string::npos ? text.substr(start) : text.substr(start, nl - start);+ if (!line.empty() && line.back() == '\r')+ line.pop_back();++ // A leading space or tab means this line continues the previous one.+ if (!line.empty() && (line[0] == ' ' || line[0] == '\t') && !lines.empty())+ lines.back() += line.substr(1);+ else+ lines.push_back(std::move(line));++ if (nl == std::string::npos)+ break;+ start = nl + 1;+ }+ return lines;+ }++ bool vcard_split_property(const std::string& line, std::string& name, std::string& value) {+ size_t colon = line.find(':');+ if (colon == std::string::npos)+ return false;+ std::string left = line.substr(0, colon);+ size_t semi = left.find(';');+ name = upper(trim(semi == std::string::npos ? left : left.substr(0, semi)));+ value = trim(line.substr(colon + 1));+ return !name.empty();+ }++ std::string vcard_name_from_n(const std::string& value) {+ std::vector<std::string> parts;+ size_t start = 0;+ while (true) {+ size_t semi = value.find(';', start);+ parts.push_back(value.substr(start, semi == std::string::npos ? std::string::npos : semi - start));+ if (semi == std::string::npos)+ break;+ start = semi + 1;+ }+ std::string given = parts.size() > 1 ? trim(parts[1]) : std::string{};+ std::string family = parts.empty() ? std::string{} : trim(parts[0]);+ if (!given.empty() && !family.empty())+ return given + " " + family;+ return given.empty() ? family : given;+ }++ std::string vcard_unescape(const std::string& value) {+ std::string out;+ out.reserve(value.size());+ for (size_t i = 0; i < value.size(); ++i) {+ if (value[i] != '\\' || i + 1 >= value.size()) {+ out += value[i];+ continue;+ }+ switch (value[i + 1]) {+ case 'n':+ case 'N':+ out += '\n';+ break;+ case ',':+ out += ',';+ break;+ case ';':+ out += ';';+ break;+ case '\\':+ out += '\\';+ break;+ default:+ // Not an escape we know; keep both characters verbatim.+ out += value[i];+ out += value[i + 1];+ break;+ }+ ++i;+ }+ return out;+ }++ std::vector<VCard> parse_vcards(const std::string& text) {+ std::vector<VCard> cards;+ if (text.empty())+ return cards;++ VCard current;+ std::string structured_name;+ bool in_card = false;++ auto flush = [&] {+ if (current.name.empty())+ current.name = structured_name;+ if (!current.empty())+ cards.push_back(current);+ current = VCard{};+ structured_name.clear();+ };++ for (const auto& raw : vcard_unfold(text)) {+ const std::string line = trim(raw);+ const std::string token = upper(line);++ if (token == "BEGIN:VCARD") {+ // An unterminated card still yields what it had, rather than+ // being silently merged into the next one.+ if (in_card)+ flush();+ in_card = true;+ continue;+ }+ if (token == "END:VCARD") {+ if (in_card)+ flush();+ in_card = false;+ continue;+ }+ if (!in_card)+ continue;++ std::string name, value;+ if (!vcard_split_property(line, name, value) || value.empty())+ continue;++ if (name == "TEL")+ current.tels.push_back(vcard_unescape(value));+ else if (name == "EMAIL")+ current.emails.push_back(vcard_unescape(value));+ else if (name == "FN")+ current.name = vcard_unescape(value);+ else if (name == "N")+ structured_name = vcard_name_from_n(vcard_unescape(value));+ }++ if (in_card)+ flush();+ return cards;+ }++} // namespace tether::bluetoothdiff --git a/src/core/src/net.cpp b/src/core/src/net.cppindex 3f78e8c..e929847 100644--- a/src/core/src/net.cpp+++ b/src/core/src/net.cpp@@ -10,12 +10,19 @@#include <sys/wait.h>#include <unistd.h>+#include "tether/bluetooth/config.hpp"+#include "tether/bluetooth/connection.hpp"+#include "tether/bluetooth/contacts.hpp"+#include "tether/bluetooth/diagnostics.hpp"+#include "tether/bluetooth/monitor.hpp"+#include "tether/bluetooth/pairing.hpp"#include "tether/client.hpp"#include "tether/crypto.hpp"#include "tether/discovery.hpp"#include "tether/file_transfer.hpp"#include "tether/otp.hpp"#include "tether/wayland.hpp"+#include <atomic>#include <cstring>#include <filesystem>#include <fstream>@@ -158,6 +165,14 @@ namespace tether {if (packet.empty() || packet.back() != '\n')packet += '\n';+ // Bluetooth state events feed the diagnostic timeline.+ if (packet.find("\"bt_") != std::string::npos) {+ try {+ bluetooth::record_diagnostic_event(nlohmann::json::parse(packet));+ } catch (...) {+ }+ }+std::lock_guard<std::mutex> lock(g_subscribers_mutex);for (int fd : local_subscribers) {if (fd == exclude_fd)@@ -196,6 +211,152 @@ namespace tether {return "";}+ nlohmann::json build_bt_status() {+ nlohmann::json status;+ status["command"] = "bt_status";+ status["available"] = bluetooth::g_bluez != nullptr && bluetooth::g_bluez->running();+ if (!bluetooth::g_bluez) {+ status["capability"] = nullptr;+ status["adapters"] = nlohmann::json::array();+ return status;+ }++ status["capability"] = bluetooth::to_json(bluetooth::g_bluez->capability());+ nlohmann::json adapters = nlohmann::json::array();+ for (const auto& adapter : bluetooth::g_bluez->snapshot().adapters)+ adapters.push_back(bluetooth::to_json(adapter));+ status["adapters"] = adapters;+ return status;+ }++ // Guards against two pairing transactions racing for the same agent and+ // advertisement object paths.+ static std::atomic<bool> g_bt_pair_busy{false};++ static void run_bt_pair(const std::string& address) {+ if (!bluetooth::g_bluez) {+ nlohmann::json event;+ event["command"] = "bt_pair_result";+ event["success"] = false;+ event["status"] = "error";+ event["message"] = "Bluetooth is unavailable.";+ broadcast_local_event(event.dump());+ return;+ }++ if (g_bt_pair_busy.exchange(true)) {+ nlohmann::json event;+ event["command"] = "bt_pair_result";+ event["success"] = false;+ event["status"] = "busy";+ event["message"] = "Another pairing attempt is already in progress.";+ broadcast_local_event(event.dump());+ return;+ }++ auto config = bluetooth::load_config();+ auto result = bluetooth::pair_device(+ *bluetooth::g_bluez,+ address,+ config.auth_strategy,+ [](const std::string& step, const std::string& detail) {+ nlohmann::json event;+ event["command"] = "bt_pair_progress";+ event["step"] = step;+ event["detail"] = detail;+ broadcast_local_event(event.dump());+ },+ nullptr);++ if (result.success) {+ config.device_address = result.device_address;+ // A BR/EDR-only bond can never have ANCS. Remember so later runs do not keep trying to bring up an LE+ // bearer the phone will not answer.+ config.ancs_enabled = result.dual_bond;+ bluetooth::save_config(config);+ // Point supervision at the device we just bonded with.+ if (bluetooth::g_bt_connections)+ bluetooth::g_bt_connections->set_device(config.device_address, config.ancs_enabled);+ }++ g_bt_pair_busy = false;+ broadcast_local_event(bluetooth::to_json(result).dump());+ broadcast_local_event(build_bt_status().dump());+ }++ static void run_bt_unpair(const std::string& address) {+ if (!bluetooth::g_bluez)+ return;+ auto result = bluetooth::unpair_device(*bluetooth::g_bluez, address);+ nlohmann::json event = bluetooth::to_json(result);+ event["command"] = "bt_unpair_result";+ broadcast_local_event(event.dump());+ broadcast_local_event(build_bt_status().dump());+ }++ nlohmann::json build_bt_threads() {+ nlohmann::json result;+ result["command"] = "bt_threads";+ nlohmann::json threads = nlohmann::json::array();+ {+ std::lock_guard<std::mutex> lock(bluetooth::message_store_mutex());+ for (const auto& thread : bluetooth::message_store().threads()) {+ auto entry = bluetooth::to_json(thread);+ // Contact names are applied for display only. Key on addresses, so a renamed or ambiguous contact can+ // never change which conversation a message belongs to.+ if (auto name = bluetooth::contact_store().name_for(thread.key); !name.empty())+ entry["name"] = name;++ if (thread.key.rfind("group:", 0) == 0) {+ entry["group"] = true;+ std::string reason;+ const auto eligibility = bluetooth::group_reply_status(thread.key, reason);+ entry["repliable"] = eligibility == bluetooth::ReplyEligibility::Allowed;+ entry["reply_status"] = bluetooth::to_string(eligibility);+ if (!reason.empty())+ entry["reply_reason"] = reason;+ } else {+ entry["group"] = false;+ entry["repliable"] = true;+ }+ threads.push_back(std::move(entry));+ }+ }+ result["threads"] = threads;+ return result;+ }++ nlohmann::json build_bt_messages(const std::string& thread_key) {+ nlohmann::json result;+ result["command"] = "bt_messages";+ result["thread"] = thread_key;+ nlohmann::json messages = nlohmann::json::array();+ {+ std::lock_guard<std::mutex> lock(bluetooth::message_store_mutex());+ const std::string name = bluetooth::contact_store().name_for(thread_key);+ for (const auto& message : bluetooth::message_store().messages(thread_key)) {+ auto entry = bluetooth::to_json(message);+ if (!name.empty() && !message.outgoing)+ entry["name"] = name;+ messages.push_back(std::move(entry));+ }+ }+ result["messages"] = messages;+ return result;+ }++ nlohmann::json build_bt_devices() {+ nlohmann::json result;+ result["command"] = "bt_devices";+ nlohmann::json devices = nlohmann::json::array();+ if (bluetooth::g_bluez) {+ for (const auto& device : bluetooth::g_bluez->snapshot().devices)+ devices.push_back(bluetooth::to_json(device));+ }+ result["devices"] = devices;+ return result;+ }+static nlohmann::json build_local_state_snapshot() {nlohmann::json snapshot;snapshot["command"] = "state_snapshot";@@ -312,7 +473,6 @@ namespace tether {throw std::system_error(errno, std::system_category(), "Failed to lock file");}}- // TODO: dont do this// we intentionally leak the fd so the lock is held for the lifetime of the process.// lock is automatically released by OS on exit.}@@ -456,6 +616,131 @@ namespace tether {debug::log(ERR, "net write error\n");}continue;+ } else if (j.contains("command") && j["command"] == "bt_status") {+ std::string payload = build_bt_status().dump() + "\n";+ if (write(client_fd, payload.c_str(), payload.size()) < 0) {+ debug::log(ERR, "net write error\n");+ }+ continue;+ } else if (j.contains("command") && j["command"] == "bt_list_devices") {+ std::string payload = build_bt_devices().dump() + "\n";+ if (write(client_fd, payload.c_str(), payload.size()) < 0) {+ debug::log(ERR, "net write error\n");+ }+ continue;+ } else if (j.contains("command") && j["command"] == "bt_pair" && j.contains("address")) {+ // Pairing waits on the user and the phone, so it runs on+ // its own thread; progress and the result arrive as events.+ std::string address = j["address"];+ std::thread([address]() { run_bt_pair(address); }).detach();+ } else if (j.contains("command") && j["command"] == "bt_unpair" && j.contains("address")) {+ std::string address = j["address"];+ std::thread([address]() { run_bt_unpair(address); }).detach();+ } else if (j.contains("command") && j["command"] == "bt_set_device" && j.contains("address")) {+ auto config = bluetooth::load_config();+ config.device_address = j["address"];+ bluetooth::save_config(config);+ if (bluetooth::g_bt_connections)+ bluetooth::g_bt_connections->set_device(config.device_address, config.ancs_enabled);+ broadcast_local_event(build_bt_status().dump());+ } else if (j.contains("command") && j["command"] == "bt_list_threads") {+ std::string payload = build_bt_threads().dump() + "\n";+ if (write(client_fd, payload.c_str(), payload.size()) < 0) {+ debug::log(ERR, "net write error\n");+ }+ continue;+ } else if (j.contains("command") && j["command"] == "bt_list_messages" && j.contains("thread")) {+ std::string payload = build_bt_messages(j["thread"]).dump() + "\n";+ if (write(client_fd, payload.c_str(), payload.size()) < 0) {+ debug::log(ERR, "net write error\n");+ }+ continue;+ } else if (j.contains("command") && j["command"] == "bt_mark_read" && j.contains("handle")) {+ std::string handle = j["handle"];+ bool read = j.value("read", true);+ // Writing through to the phone is a blocking OBEX call.+ std::thread([handle, read]() {+ std::string err;+ nlohmann::json event;+ event["command"] = "bt_message_read";+ event["handle"] = handle;+ event["read"] = read;+ event["success"] = bluetooth::mark_message_read(handle, read, err);+ if (!err.empty())+ event["message"] = err;+ broadcast_local_event(event.dump());+ }).detach();+ } else if (j.contains("command") && j["command"] == "bt_send_message" && j.contains("thread") &&+ j.contains("body")) {+ std::string thread = j["thread"];+ std::string body = j["body"];+ // PushMessage is a blocking OBEX transfer, so it cannot+ // run on the loop that has to keep serving the UI.+ std::thread([thread, body]() {+ std::string err;+ bluetooth::Message sent;+ nlohmann::json event;+ event["command"] = "bt_send_result";+ event["thread"] = thread;+ event["success"] = bluetooth::send_message(thread, body, sent, err);+ if (event["success"]) {+ // The phone reports nothing about a sent message,+ // so the local record is announced the same way an+ // incoming one would be.+ nlohmann::json message = bluetooth::to_json(sent);+ message["command"] = "bt_message";+ broadcast_local_event(message.dump());+ } else {+ event["message"] = err;+ }+ broadcast_local_event(event.dump());+ }).detach();+ } else if (j.contains("command") && j["command"] == "bt_list_notifications") {+ nlohmann::json payload;+ payload["command"] = "bt_notifications";+ payload["notifications"] = bluetooth::g_bt_connections+ ? bluetooth::g_bt_connections->notifications()+ : nlohmann::json::array();+ std::string out = payload.dump(-1, ' ', false, nlohmann::json::error_handler_t::replace) + "\n";+ if (write(client_fd, out.c_str(), out.size()) < 0) {+ debug::log(ERR, "net write error\n");+ }+ continue;+ } else if (j.contains("command") && j["command"] == "bt_notification_action" && j.contains("uid")) {+ // ANCS offers positive and negative only; there is no+ // free-text reply to expose here.+ const bool positive = j.value("action", "positive") == "positive";+ nlohmann::json payload;+ payload["command"] = "bt_notification_action_result";+ payload["uid"] = j["uid"];+ payload["success"] =+ bluetooth::g_bt_connections &&+ bluetooth::g_bt_connections->perform_notification_action(+ j["uid"].get<uint32_t>(),+ positive ? bluetooth::ancs::ActionId::Positive : bluetooth::ancs::ActionId::Negative);+ broadcast_local_event(payload.dump());+ } else if (j.contains("command") && j["command"] == "bt_connection") {+ nlohmann::json payload = bluetooth::g_bt_connections+ ? bluetooth::g_bt_connections->status()+ : nlohmann::json{{"command", "bt_connection_changed"},+ {"device_present", false},+ {"link_reason", "Bluetooth is unavailable."},+ {"profile_reason", ""}};+ std::string out = payload.dump() + "\n";+ if (write(client_fd, out.c_str(), out.size()) < 0) {+ debug::log(ERR, "net write error\n");+ }+ continue;+ } else if (j.contains("command") && j["command"] == "bt_diagnostics") {+ nlohmann::json connection =+ bluetooth::g_bt_connections+ ? bluetooth::g_bt_connections->status()+ : nlohmann::json{{"command", "bt_connection_changed"}, {"device_present", false}};+ std::string out = bluetooth::build_diagnostics(build_bt_status(), connection).dump() + "\n";+ if (write(client_fd, out.c_str(), out.size()) < 0) {+ debug::log(ERR, "net write error\n");+ }+ continue;} else if (j.contains("command") && j["command"] == "clipboard_set" && j.contains("content")) {std::string content = j["content"];if (g_wayland)diff --git a/src/daemon/main.cpp b/src/daemon/main.cppindex b5acf91..59741ea 100644--- a/src/daemon/main.cpp+++ b/src/daemon/main.cpp@@ -1,6 +1,11 @@#include "notification.hpp"#include <csignal>+#include <ctime>#include <nlohmann/json.hpp>+#include <tether/bluetooth/config.hpp>+#include <tether/bluetooth/connection.hpp>+#include <tether/bluetooth/contacts.hpp>+#include <tether/bluetooth/monitor.hpp>#include <tether/core.hpp>#include <tether/crypto.hpp>#include <tether/discovery.hpp>@@ -101,7 +106,7 @@ int main(int argc, char** argv) {}tether::FileReceiveManager file_mgr;- tether::FileArrivalNotifier notifier;+ tether::DesktopNotifier notifier;if (!notifier.init()) {debug::log(ERR, "Warning: desktop notifications unavailable");} else {@@ -112,6 +117,86 @@ int main(int argc, char** argv) {}tether::g_file_manager = &file_mgr;+ // BlueZ runs on its own GLib thread and wakes the loop through an eventfd+ // whenever the adapter or device set changes.+ tether::bluetooth::BluezMonitor bluez;+ tether::bluetooth::ConnectionManager connections(+ bluez,+ [](const nlohmann::json& status) { tether::broadcast_local_event(status.dump()); },+ [¬ifier](const tether::bluetooth::Message& message, bool backfill) {+ nlohmann::json event = tether::bluetooth::to_json(message);+ event["command"] = "bt_message";+ tether::broadcast_local_event(event.dump(-1, ' ', false, nlohmann::json::error_handler_t::replace));++ // ANCS deliberately shows no popup for Messages, because MAP is the+ // copy whose read state stays in sync with the phone. This is that popup.+ if (backfill || message.outgoing || message.read)+ return;++ std::string who = tether::bluetooth::contact_store().name_for(message.thread_key);+ if (who.empty())+ who = message.peer_name.empty() ? message.peer_address : message.peer_name;+ notifier.notify(who.empty() ? "iPhone" : who, message.body);+ });+ if (bluez.start()) {+ tether::bluetooth::g_bluez = &bluez;+ loop.addFd(bluez.event_fd(), [&bluez](int) {+ bluez.drain();+ tether::broadcast_local_event(tether::build_bt_status().dump());+ });+ auto cap = bluez.capability();+ debug::log(INFO, "Bluetooth: {} mode", tether::bluetooth::to_string(cap.mode));+ for (const auto& reason : cap.reasons)+ debug::log(INFO, "Bluetooth: {}", reason);++ // Supervise the selected iPhone's bearers and OBEX sessions. ANCS is only+ // attempted when the controller can carry it and pairing produced a bond+ // that covers LE.+ auto bt_config = tether::bluetooth::load_config();+ const bool ancs = bt_config.ancs_enabled && cap.mode == tether::bluetooth::DeliveryMode::Full;+ tether::bluetooth::g_bt_connections = &connections;++ tether::bluetooth::set_group_replies_enabled(bt_config.group_messages_enabled &&+ bt_config.ancs_content_enabled);+ tether::bluetooth::reload_group_rosters();++ if (ancs) {+ connections.set_notification_handlers(+ [¬ifier](const tether::bluetooth::ancs::Notification& notification) {+ // Messages notifications are the only side channel that says+ // which conversation a MAP message belongs to.+ if (notification.app_id == tether::bluetooth::ancs::APP_ID_MESSAGES) {+ tether::bluetooth::observe_message_notification(notification.title,+ notification.subtitle,+ notification.body,+ static_cast<int64_t>(std::time(nullptr)));+ }++ nlohmann::json event = tether::bluetooth::ancs::to_json(notification);+ event["command"] = "bt_notification";+ tether::broadcast_local_event(event.dump(-1, ' ', false, nlohmann::json::error_handler_t::replace));++ // Messages already arrive over MAP with read state that stays+ // in sync, so a popup here would be the second copy.+ if (!tether::bluetooth::ancs::should_show_desktop_popup(notification))+ return;++ const std::string title = notification.title.empty() ? notification.app_name : notification.title;+ notifier.notify(title.empty() ? "iPhone" : title, notification.body);+ },+ [](uint32_t uid) {+ nlohmann::json event;+ event["command"] = "bt_notification_removed";+ event["uid"] = uid;+ tether::broadcast_local_event(event.dump());+ });+ }++ connections.start(bt_config.device_address, ancs);+ } else {+ debug::log(INFO, "Bluetooth unavailable; messages and notifications are disabled");+ }+debug::log(INFO, "tetherd is running. Press Ctrl-C to stop.");loop.run();@@ -119,6 +204,10 @@ int main(int argc, char** argv) {debug::log(INFO, "tetherd shutdown complete.");// explicitly null globals to be safe during final stack unwinding+ tether::bluetooth::g_bt_connections = nullptr;+ connections.stop();+ tether::bluetooth::g_bluez = nullptr;+ bluez.stop();tether::g_wayland = nullptr;tether::g_file_manager = nullptr;g_loop = nullptr;diff --git a/src/daemon/notification.cpp b/src/daemon/notification.cppindex d07b7e8..45bf950 100644--- a/src/daemon/notification.cpp+++ b/src/daemon/notification.cpp@@ -103,16 +103,16 @@ namespace tether {} // namespace- struct FileArrivalNotifier::Impl {+ struct DesktopNotifier::Impl {GMainContext* context = nullptr;GMainLoop* loop = nullptr;std::thread thread;bool initialized = false;};- FileArrivalNotifier::FileArrivalNotifier() : impl_(std::make_unique<Impl>()) {}+ DesktopNotifier::DesktopNotifier() : impl_(std::make_unique<Impl>()) {}- FileArrivalNotifier::~FileArrivalNotifier() {+ DesktopNotifier::~DesktopNotifier() {if (!impl_->initialized) {return;}@@ -135,7 +135,7 @@ namespace tether {notify_uninit();}- bool FileArrivalNotifier::init() {+ bool DesktopNotifier::init() {if (impl_->initialized) {return true;}@@ -156,7 +156,26 @@ namespace tether {return true;}- void FileArrivalNotifier::notify_file_arrived(const std::filesystem::path& path) {+ void DesktopNotifier::notify(const std::string& summary, const std::string& body) {+ if (!impl_ || !impl_->initialized) {+ return;+ }++ NotifyNotification* notification =+ notify_notification_new(summary.c_str(), body.empty() ? nullptr : body.c_str(), "phone-symbolic");+ if (!notification) {+ return;+ }++ GError* error = nullptr;+ if (!notify_notification_show(notification, &error)) {+ debug::log(ERR, "Failed to show notification: {}", error ? error->message : "unknown");+ g_clear_error(&error);+ }+ g_object_unref(notification);+ }++ void DesktopNotifier::notify_file_arrived(const std::filesystem::path& path) {if (!impl_->initialized) {return;}diff --git a/src/daemon/notification.hpp b/src/daemon/notification.hppindex 8493e15..bae89d3 100644--- a/src/daemon/notification.hpp+++ b/src/daemon/notification.hpp@@ -2,20 +2,24 @@#include <filesystem>#include <memory>+#include <string>namespace tether {- class FileArrivalNotifier {+ class DesktopNotifier {public:- FileArrivalNotifier();- ~FileArrivalNotifier();+ DesktopNotifier();+ ~DesktopNotifier();- FileArrivalNotifier(const FileArrivalNotifier&) = delete;- FileArrivalNotifier& operator=(const FileArrivalNotifier&) = delete;+ DesktopNotifier(const DesktopNotifier&) = delete;+ DesktopNotifier& operator=(const DesktopNotifier&) = delete;bool init();void notify_file_arrived(const std::filesystem::path& path);+ // A plain notification with no actions.+ void notify(const std::string& summary, const std::string& body);+private:struct Impl;std::unique_ptr<Impl> impl_;diff --git a/src/gtk/CMakeLists.txt b/src/gtk/CMakeLists.txtindex c5905c7..23a5ba2 100644--- a/src/gtk/CMakeLists.txt+++ b/src/gtk/CMakeLists.txt@@ -3,6 +3,11 @@ pkg_check_modules(GTK3 REQUIRED gtk+-3.0)add_executable(tether-gtkmain.cpp+ ui_util.cpp+ daemon_client.cpp+ devices_view.cpp+ messages_view.cpp+ notifications_view.cpp)target_include_directories(tether-gtk PRIVATE ${GTK3_INCLUDE_DIRS})diff --git a/src/gtk/daemon_client.cpp b/src/gtk/daemon_client.cppnew file mode 100644index 0000000..a51e5a8--- /dev/null+++ b/src/gtk/daemon_client.cpp@@ -0,0 +1,184 @@+#include "daemon_client.hpp"+#include "ui_util.hpp"++#include <cstdio>+#include <cstdlib>+#include <cstring>+#include <filesystem>+#include <gtk/gtk.h>+#include <sys/socket.h>+#include <sys/un.h>+#include <sys/wait.h>+#include <tether/core.hpp>+#include <tether/log.hpp>+#include <tether/net.hpp>+#include <unistd.h>++namespace tether::ui {++ namespace {++ int g_event_fd = -1;+ GIOChannel* g_event_channel = nullptr;+ guint g_event_watch_id = 0;+ guint g_event_retry_id = 0;+ DaemonEventFn g_on_event;++ gboolean start_event_subscription(gpointer);++ void stop_event_subscription() {+ if (g_event_watch_id != 0) {+ g_source_remove(g_event_watch_id);+ g_event_watch_id = 0;+ }+ if (g_event_channel) {+ g_io_channel_shutdown(g_event_channel, TRUE, nullptr);+ g_io_channel_unref(g_event_channel);+ g_event_channel = nullptr;+ } else if (g_event_fd >= 0) {+ close(g_event_fd);+ }+ g_event_fd = -1;+ }++ void schedule_event_retry() {+ if (g_event_retry_id == 0)+ g_event_retry_id = g_timeout_add_seconds(2, start_event_subscription, nullptr);+ }++ gboolean on_event_channel(GIOChannel* source, GIOCondition condition, gpointer) {+ if (condition & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {+ stop_event_subscription();+ schedule_event_retry();+ set_status_main("Daemon Offline");+ return FALSE;+ }+ if (condition & G_IO_IN) {+ gchar* line = nullptr;+ gsize length = 0;+ GError* error = nullptr;+ while (true) {+ GIOStatus status = g_io_channel_read_line(source, &line, &length, nullptr, &error);+ if (status == G_IO_STATUS_AGAIN) {+ if (line)+ g_free(line);+ break;+ }+ if (status == G_IO_STATUS_EOF || status == G_IO_STATUS_ERROR) {+ if (error) {+ debug::log(ERR, "Stream err: {}", error->message);+ g_error_free(error);+ }+ if (line)+ g_free(line);+ stop_event_subscription();+ schedule_event_retry();+ set_status_main("Daemon Offline");+ return FALSE;+ }+ if (line && length > 0) {+ try {+ if (g_on_event)+ g_on_event(nlohmann::json::parse(std::string(line, length)));+ } catch (...) {+ }+ }+ if (line)+ g_free(line);+ }+ }+ return TRUE;+ }++ gboolean start_event_subscription(gpointer) {+ if (g_event_retry_id != 0) {+ g_source_remove(g_event_retry_id);+ g_event_retry_id = 0;+ }+ stop_event_subscription();+ int fd = socket(AF_UNIX, SOCK_STREAM, 0);+ if (fd < 0) {+ schedule_event_retry();+ return G_SOURCE_REMOVE;+ }++ sockaddr_un addr{};+ addr.sun_family = AF_UNIX;+ std::string path = tether::get_runtime_dir() + "/tetherd.sock";+ std::strncpy(addr.sun_path, path.c_str(), sizeof(addr.sun_path) - 1);++ if (::connect(fd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {+ close(fd);+ static bool autostart_attempted = false;+ if (!autostart_attempted) {+ autostart_attempted = true;+ pid_t pid = fork();+ if (pid == 0) {+ std::filesystem::path self_path = std::filesystem::read_symlink("/proc/self/exe");+ std::string daemon_path = (self_path.parent_path() / "tetherd").string();+ if (fork() == 0) {+ if (freopen("/dev/null", "w", stdout) == nullptr) {+ }+ if (freopen("/dev/null", "w", stderr) == nullptr) {+ }+ if (freopen("/dev/null", "r", stdin) == nullptr) {+ }+ execl(daemon_path.c_str(), "tetherd", nullptr);+ execlp("tetherd", "tetherd", nullptr);+ exit(1);+ }+ exit(0);+ } else if (pid > 0) {+ int status;+ waitpid(pid, &status, 0);+ }+ }+ schedule_event_retry();+ set_status_main("Daemon Offline");+ return G_SOURCE_REMOVE;+ }++ g_event_fd = fd;+ g_event_channel = g_io_channel_unix_new(fd);+ g_io_channel_set_encoding(g_event_channel, nullptr, nullptr);+ g_io_channel_set_buffered(g_event_channel, TRUE);+ g_io_channel_set_flags(g_event_channel, G_IO_FLAG_NONBLOCK, nullptr);+ g_event_watch_id = g_io_add_watch(g_event_channel,+ static_cast<GIOCondition>(G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL),+ on_event_channel,+ nullptr);+ static const char kSubscribe[] = "{\"command\":\"subscribe\"}\n";+ if (write(fd, kSubscribe, sizeof(kSubscribe) - 1) < 0) {+ debug::log(ERR, "subscribe write error\n");+ }+ set_status_main("Daemon Online");+ return G_SOURCE_REMOVE;+ }++ } // namespace++ void daemon_client_start(DaemonEventFn on_event) {+ g_on_event = std::move(on_event);+ start_event_subscription(nullptr);+ }++ void daemon_client_stop() {+ stop_event_subscription();+ if (g_event_retry_id != 0) {+ g_source_remove(g_event_retry_id);+ g_event_retry_id = 0;+ }+ }++ void daemon_send(const nlohmann::json& message) {+ if (g_event_fd >= 0) {+ std::string payload = message.dump() + "\n";+ if (::write(g_event_fd, payload.c_str(), payload.size()) < 0) {+ debug::log(ERR, "daemon write error\n");+ }+ }+ }++ bool daemon_connected() { return g_event_fd >= 0; }++} // namespace tether::uidiff --git a/src/gtk/daemon_client.hpp b/src/gtk/daemon_client.hppnew file mode 100644index 0000000..f066386--- /dev/null+++ b/src/gtk/daemon_client.hpp@@ -0,0 +1,18 @@+#pragma once++#include <functional>+#include <nlohmann/json.hpp>++namespace tether::ui {++ using DaemonEventFn = std::function<void(const nlohmann::json&)>;++ // Connects to unix socket, subscribes to the local event feed, and dispatches each nd event. Starts the daemon once+ // if it is not running, and reconnects on its own after it goes away.+ void daemon_client_start(DaemonEventFn on_event);+ void daemon_client_stop();++ void daemon_send(const nlohmann::json& message);+ bool daemon_connected();++} // namespace tether::uidiff --git a/src/gtk/devices_view.cpp b/src/gtk/devices_view.cppnew file mode 100644index 0000000..6409b38--- /dev/null+++ b/src/gtk/devices_view.cpp@@ -0,0 +1,539 @@+#include "devices_view.hpp"+#include "daemon_client.hpp"+#include "ui_util.hpp"++#include <algorithm>+#include <filesystem>+#include <string>+#include <tether/crypto.hpp>+#include <tether/discovery.hpp>+#include <vector>++namespace tether::ui {++ namespace {++ struct DevicesState {+ std::vector<tether::DiscoveredDevice> discovered_devices;+ std::vector<tether::DiscoveredDevice> pending_pairing_requests;+ std::vector<std::pair<std::string, std::string>> paired_devices; // fp, name+ std::vector<std::string> connected_fps; // active connections++ GtkWidget* list_devices = nullptr;+ GtkWidget* right_pane_stack = nullptr;++ std::string selected_device_fp;+ std::string selected_device_name;+ std::string selected_device_ip;+ uint16_t selected_device_port = 5134;++ GtkWidget* lbl_action_name = nullptr;+ GtkWidget* lbl_action_status = nullptr;+ GtkWidget* btn_grid = nullptr;++ GtkWidget* lbl_unpaired_name = nullptr;+ GtkWidget* lbl_unpaired_ip = nullptr;+ };++ DevicesState g_devices;++ void set_status_action(const std::string& text) { set_text(g_devices.lbl_action_status, text); }++ void update_right_pane() {+ if (g_devices.selected_device_fp.empty()) {+ gtk_stack_set_visible_child_name(GTK_STACK(g_devices.right_pane_stack), "placeholder");+ return;+ }++ bool is_paired = false;+ for (const auto& p : g_devices.paired_devices) {+ if (p.first == g_devices.selected_device_fp)+ is_paired = true;+ }++ if (is_paired) {+ gtk_stack_set_visible_child_name(GTK_STACK(g_devices.right_pane_stack), "action");+ set_markup(g_devices.lbl_action_name, ("<b>" + escape_markup(g_devices.selected_device_name) + "</b>"));+ bool online = std::find(g_devices.connected_fps.begin(),+ g_devices.connected_fps.end(),+ g_devices.selected_device_fp) != g_devices.connected_fps.end();+ set_status_action(online ? "Connected and ready."+ : "Device is offline. Pair again or wait for network.");+ if (g_devices.btn_grid) {+ gtk_widget_set_visible(g_devices.btn_grid, online);+ }+ } else {+ gtk_stack_set_visible_child_name(GTK_STACK(g_devices.right_pane_stack), "pair");+ set_markup(g_devices.lbl_unpaired_name,+ ("<b>" + escape_markup(g_devices.selected_device_name) + "</b>"));+ set_text(g_devices.lbl_unpaired_ip,+ ("Found at " + g_devices.selected_device_ip + ":" ++ std::to_string(g_devices.selected_device_port)));+ }+ }++ void on_device_selected(GtkListBox*, GtkListBoxRow* row, gpointer) {+ if (!row)+ return;+ const char* fp = (const char*)g_object_get_data(G_OBJECT(row), "fp");+ const char* name = (const char*)g_object_get_data(G_OBJECT(row), "name");+ const char* ip = (const char*)g_object_get_data(G_OBJECT(row), "ip");+ g_devices.selected_device_fp = fp ? fp : "";+ g_devices.selected_device_name = name ? name : "";+ g_devices.selected_device_ip = ip ? ip : "";+ g_devices.selected_device_port = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(row), "port"));+ update_right_pane();+ }++ void on_pair_click(GtkWidget*, gpointer) {+ if (g_devices.selected_device_ip.empty())+ return;+ set_text(g_devices.lbl_unpaired_ip, "Sending pair request...");+ nlohmann::json j;+ j["command"] = "pair_request";+ j["host"] = g_devices.selected_device_ip;+ j["port"] = g_devices.selected_device_port;+ daemon_send(j);+ set_status_main("Pair request sent. Approve on remote device!");+ }++ void on_accept_click(GtkWidget*, gpointer) {+ if (g_devices.selected_device_fp.empty())+ return;+ nlohmann::json j;+ j["command"] = "accept_device";+ j["fingerprint"] = g_devices.selected_device_fp;+ daemon_send(j);+ }++ void send_file_async(const std::filesystem::path& path) {+ if (!daemon_connected()) {+ set_status_action("Daemon unavailable.");+ return;+ }+ set_status_action("Sending " + path.filename().string() + "…");+ nlohmann::json j;+ j["command"] = "send_file";+ j["path"] = path.string();+ daemon_send(j);+ }++ void on_choose_file(GtkWidget*, gpointer) {+ GtkWidget* dialog = gtk_file_chooser_dialog_new("Send File",+ GTK_WINDOW(main_window()),+ GTK_FILE_CHOOSER_ACTION_OPEN,+ "_Cancel",+ GTK_RESPONSE_CANCEL,+ "_Send",+ GTK_RESPONSE_ACCEPT,+ nullptr);+ if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {+ char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));+ if (filename) {+ send_file_async(filename);+ g_free(filename);+ }+ }+ gtk_widget_destroy(dialog);+ }++ void apply_state_snapshot(const nlohmann::json& j) {+ g_devices.connected_fps.clear();+ if (j.contains("connected_clients") && j["connected_clients"].is_array()) {+ for (auto& c : j["connected_clients"]) {+ if (c.value("paired", false)) {+ g_devices.connected_fps.push_back(c.value("fingerprint", ""));+ } else {+ tether::DiscoveredDevice dev;+ dev.fingerprint = c.value("fingerprint", "");+ dev.name = c.value("device_name", "Unknown Device");+ dev.addresses.push_back({c.value("address", ""), 5134});+ g_devices.discovered_devices.push_back(dev);+ }+ }+ }+ g_devices.pending_pairing_requests.clear();+ if (j.contains("pending_pairs") && j["pending_pairs"].is_array()) {+ for (auto& p : j["pending_pairs"]) {+ tether::DiscoveredDevice req;+ req.fingerprint = p.value("fingerprint", "");+ req.name = p.value("device_name", "Unknown Device");+ g_devices.pending_pairing_requests.push_back(req);+ }+ }+ devices_view_refresh();+ }++ } // namespace++ void devices_view_trigger_discovery() {+ set_status_main("Scanning for nearby devices...");+ nlohmann::json j;+ j["command"] = "discover";+ daemon_send(j);+ }++ // Refresh the device list based on Discovered (unpaired), Paired (offline), Paired (online)+ void devices_view_refresh() {+ clear_list_box(g_devices.list_devices);++ tether::Crypto::instance().init();+ try {+ nlohmann::json known = nlohmann::json::parse(tether::Crypto::instance().get_known_hosts_dump());+ g_devices.paired_devices.clear();+ if (!known.empty()) {+ for (auto& [fingerprint, name_value] : known.items()) {+ g_devices.paired_devices.push_back(+ {fingerprint, name_value.is_string() ? name_value.get<std::string>() : "Unknown Device"});+ }+ }+ } catch (...) {+ }++ // We build a unified list of devices.+ // 1. All Paired Devices+ // 2. Any Discovered Devices not in the Paired list++ auto create_row = [](const std::string& name,+ const std::string& fp,+ const std::string& ip,+ uint16_t port,+ bool paired,+ bool online) {+ GtkWidget* row = gtk_list_box_row_new();+ g_object_set_data_full(G_OBJECT(row), "fp", g_strdup(fp.c_str()), g_free);+ g_object_set_data_full(G_OBJECT(row), "name", g_strdup(name.c_str()), g_free);+ g_object_set_data_full(G_OBJECT(row), "ip", g_strdup(ip.c_str()), g_free);+ g_object_set_data(G_OBJECT(row), "port", GINT_TO_POINTER(port));+ g_object_set_data(G_OBJECT(row), "paired", GINT_TO_POINTER(paired ? 1 : 0));++ GtkWidget* box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);+ gtk_container_set_border_width(GTK_CONTAINER(box), 12);++ const char* icon_name =+ paired ? (online ? "network-cellular-connected-symbolic" : "network-cellular-offline-symbolic")+ : "dialog-information-symbolic";+ GtkWidget* icon = gtk_image_new_from_icon_name(icon_name, GTK_ICON_SIZE_LARGE_TOOLBAR);+ gtk_box_pack_start(GTK_BOX(box), icon, FALSE, FALSE, 0);++ GtkWidget* labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);+ GtkWidget* title = gtk_label_new(nullptr);+ gtk_label_set_markup(GTK_LABEL(title), ("<b>" + escape_markup(name) + "</b>").c_str());+ gtk_label_set_xalign(GTK_LABEL(title), 0.0);+ gtk_box_pack_start(GTK_BOX(labels), title, FALSE, FALSE, 0);++ GtkWidget* subtitle = gtk_label_new(paired ? (online ? "Connected" : "Offline") : "Nearby (Tap to Pair)");+ gtk_label_set_xalign(GTK_LABEL(subtitle), 0.0);+ gtk_style_context_add_class(gtk_widget_get_style_context(subtitle), "muted");+ gtk_box_pack_start(GTK_BOX(labels), subtitle, FALSE, FALSE, 0);++ gtk_box_pack_start(GTK_BOX(box), labels, TRUE, TRUE, 0);+ gtk_container_add(GTK_CONTAINER(row), box);+ return row;+ };++ auto create_header_row = [](const std::string& title_text) {+ GtkWidget* row = gtk_list_box_row_new();+ gtk_list_box_row_set_selectable(GTK_LIST_BOX_ROW(row), FALSE);+ GtkWidget* box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);+ gtk_container_set_border_width(GTK_CONTAINER(box), 8);+ GtkWidget* lbl = gtk_label_new(nullptr);+ gtk_label_set_markup(+ GTK_LABEL(lbl),+ ("<b><span size='small' color='gray'>" + escape_markup(title_text) + "</span></b>").c_str());+ gtk_label_set_xalign(GTK_LABEL(lbl), 0.0);+ gtk_box_pack_start(GTK_BOX(box), lbl, TRUE, TRUE, 0);+ gtk_container_add(GTK_CONTAINER(row), box);+ return row;+ };++ std::string my_fp = tether::Crypto::instance().get_my_fingerprint();++ std::vector<GtkWidget*> connected_rows;+ std::vector<GtkWidget*> remembered_rows;+ std::vector<GtkWidget*> discovered_rows;++ for (const auto& paired : g_devices.paired_devices) {+ bool online = std::find(g_devices.connected_fps.begin(), g_devices.connected_fps.end(), paired.first) !=+ g_devices.connected_fps.end();+ GtkWidget* r = create_row(paired.second, paired.first, "", 5134, true, online);+ if (online) {+ connected_rows.push_back(r);+ } else {+ remembered_rows.push_back(r);+ }+ }++ for (const auto& disc : g_devices.discovered_devices) {+ if (disc.fingerprint == my_fp)+ continue;+ bool is_paired = false;+ for (const auto& p : g_devices.paired_devices) {+ if (p.first == disc.fingerprint) {+ is_paired = true;+ break;+ }+ }+ if (is_paired)+ continue; // already added above+ std::string ip = disc.addresses.empty() ? "" : disc.addresses[0].address;+ uint16_t port = disc.addresses.empty() ? 5134 : disc.addresses[0].port;+ GtkWidget* r = create_row(disc.name, disc.fingerprint, ip, port, false, false);+ discovered_rows.push_back(r);+ }++ // Render Pending Pair Requests+ for (const auto& req : g_devices.pending_pairing_requests) {+ bool is_paired = false;+ for (const auto& p : g_devices.paired_devices) {+ if (p.first == req.fingerprint) {+ is_paired = true;+ break;+ }+ }+ if (is_paired)+ continue; // ignore if they successfully paired++ bool already_shown = false;+ for (const auto& disc : g_devices.discovered_devices) {+ if (disc.fingerprint == req.fingerprint) {+ already_shown = true;+ break;+ }+ }+ if (already_shown)+ continue; // ignore if mDNS already populated it++ std::string ip = req.addresses.empty() ? "" : req.addresses[0].address;+ uint16_t port = req.addresses.empty() ? 5134 : req.addresses[0].port;+ GtkWidget* r = create_row(req.name, req.fingerprint, ip, port, false, false);+ discovered_rows.push_back(r);+ }++ if (!connected_rows.empty()) {+ gtk_list_box_insert(GTK_LIST_BOX(g_devices.list_devices), create_header_row("CONNECTED"), -1);+ for (auto* r : connected_rows)+ gtk_list_box_insert(GTK_LIST_BOX(g_devices.list_devices), r, -1);+ }++ if (!remembered_rows.empty()) {+ gtk_list_box_insert(GTK_LIST_BOX(g_devices.list_devices), create_header_row("REMEMBERED"), -1);+ for (auto* r : remembered_rows)+ gtk_list_box_insert(GTK_LIST_BOX(g_devices.list_devices), r, -1);+ }++ if (!discovered_rows.empty()) {+ gtk_list_box_insert(GTK_LIST_BOX(g_devices.list_devices), create_header_row("DISCOVERED"), -1);+ for (auto* r : discovered_rows)+ gtk_list_box_insert(GTK_LIST_BOX(g_devices.list_devices), r, -1);+ }++ gtk_widget_show_all(g_devices.list_devices);+ }++ bool devices_view_handle_event(const nlohmann::json& event) {+ const std::string command = event.value("command", "");+ if (command == "state_snapshot") {+ apply_state_snapshot(event);+ return true;+ }+ if (command == "client_connected") {+ std::string fp = event.value("fingerprint", "");+ if (std::find(g_devices.connected_fps.begin(), g_devices.connected_fps.end(), fp) ==+ g_devices.connected_fps.end()) {+ g_devices.connected_fps.push_back(fp);+ }+ devices_view_refresh();+ update_right_pane();+ return true;+ }+ if (command == "client_disconnected") {+ std::string fp = event.value("fingerprint", "");+ g_devices.connected_fps.erase(+ std::remove(g_devices.connected_fps.begin(), g_devices.connected_fps.end(), fp),+ g_devices.connected_fps.end());+ devices_view_refresh();+ update_right_pane();+ return true;+ }+ if (command == "pair_request_received" || command == "untrusted_client_connected") {+ tether::DiscoveredDevice req;+ req.fingerprint = event.value("fingerprint", "");++ std::string resolved_name = event.value("device_name", "Unknown Device");+ if (resolved_name == "Unknown Device") {+ for (const auto& d : g_devices.discovered_devices) {+ if (d.fingerprint == req.fingerprint && !d.name.empty()) {+ resolved_name = d.name;+ break;+ }+ }+ }+ req.name = resolved_name;+ req.addresses.push_back({event.value("address", ""), 5134});+ bool exists = false;+ for (const auto& dev : g_devices.pending_pairing_requests) {+ if (dev.fingerprint == req.fingerprint) {+ exists = true;+ break;+ }+ }+ if (!exists) {+ g_devices.pending_pairing_requests.push_back(req);+ devices_view_refresh();+ }+ return true;+ }+ if (command == "pair_accepted") {+ std::string fp = event.value("fingerprint", "");+ std::string name = event.value("device_name", "");+ if (!fp.empty()) {+ g_devices.connected_fps.push_back(fp);++ // Ensure it's in the paired devices list so the UI transitions+ bool already_paired = false;+ for (const auto& p : g_devices.paired_devices) {+ if (p.first == fp) {+ already_paired = true;+ break;+ }+ }+ if (!already_paired)+ g_devices.paired_devices.push_back({fp, name});++ g_devices.pending_pairing_requests.erase(+ std::remove_if(g_devices.pending_pairing_requests.begin(),+ g_devices.pending_pairing_requests.end(),+ [&](const tether::DiscoveredDevice& d) { return d.fingerprint == fp; }),+ g_devices.pending_pairing_requests.end());+ devices_view_refresh();+ update_right_pane();+ }+ return true;+ }+ if (command == "discovery_result") {+ g_devices.discovered_devices.clear();+ if (event.contains("devices") && event["devices"].is_array()) {+ for (const auto& d : event["devices"]) {+ tether::DiscoveredDevice dev;+ dev.name = d.value("name", "");+ dev.fingerprint = d.value("fingerprint", "");+ if (d.contains("addresses") && d["addresses"].is_array()) {+ for (const auto& a : d["addresses"]) {+ dev.addresses.push_back({a.value("address", ""), a.value<uint16_t>("port", 5134)});+ }+ }+ g_devices.discovered_devices.push_back(dev);+ }+ }+ devices_view_refresh();+ set_status_main("Ready");+ return true;+ }+ if (command == "file_send_complete") {+ set_status_action(event.value("message", ""));+ return true;+ }+ if (command == "clipboard_content") {+ set_status_action("Desktop Clipboard Sync triggered.");+ return true;+ }+ return false;+ }++ GtkWidget* devices_view_new() {+ GtkWidget* paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);++ // Left Pane (List)+ GtkWidget* left_scroll = gtk_scrolled_window_new(nullptr, nullptr);+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(left_scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);+ gtk_widget_set_size_request(left_scroll, 220, -1);++ g_devices.list_devices = gtk_list_box_new();+ g_signal_connect(g_devices.list_devices, "row-selected", G_CALLBACK(on_device_selected), nullptr);+ gtk_container_add(GTK_CONTAINER(left_scroll), g_devices.list_devices);+ gtk_paned_pack1(GTK_PANED(paned), left_scroll, FALSE, FALSE);++ // Right Pane+ g_devices.right_pane_stack = gtk_stack_new();+ gtk_stack_set_transition_type(GTK_STACK(g_devices.right_pane_stack), GTK_STACK_TRANSITION_TYPE_CROSSFADE);++ // Placeholder+ GtkWidget* placeholder = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);+ gtk_widget_set_valign(placeholder, GTK_ALIGN_CENTER);+ gtk_widget_set_halign(placeholder, GTK_ALIGN_CENTER);+ GtkWidget* p_icon = gtk_image_new_from_icon_name("computer-symbolic", GTK_ICON_SIZE_DIALOG);+ gtk_box_pack_start(GTK_BOX(placeholder), p_icon, FALSE, FALSE, 0);+ GtkWidget* p_lbl = gtk_label_new("Select a device to start");+ gtk_style_context_add_class(gtk_widget_get_style_context(p_lbl), "muted");+ gtk_box_pack_start(GTK_BOX(placeholder), p_lbl, FALSE, FALSE, 0);+ gtk_stack_add_named(GTK_STACK(g_devices.right_pane_stack), placeholder, "placeholder");++ // Pair+ GtkWidget* pair_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 16);+ gtk_widget_set_valign(pair_box, GTK_ALIGN_CENTER);+ gtk_widget_set_halign(pair_box, GTK_ALIGN_CENTER);+ g_devices.lbl_unpaired_name = gtk_label_new(nullptr);+ gtk_box_pack_start(GTK_BOX(pair_box), g_devices.lbl_unpaired_name, FALSE, FALSE, 0);+ g_devices.lbl_unpaired_ip = gtk_label_new(nullptr);+ gtk_style_context_add_class(gtk_widget_get_style_context(g_devices.lbl_unpaired_ip), "muted");+ gtk_box_pack_start(GTK_BOX(pair_box), g_devices.lbl_unpaired_ip, FALSE, FALSE, 0);++ GtkWidget* pair_btn = gtk_button_new_with_label("Pair Device");+ gtk_style_context_add_class(gtk_widget_get_style_context(pair_btn), "suggested-action");+ g_signal_connect(pair_btn, "clicked", G_CALLBACK(on_pair_click), nullptr);+ gtk_box_pack_start(GTK_BOX(pair_box), pair_btn, FALSE, FALSE, 0);++ // optional accept override button+ GtkWidget* accept_btn = gtk_button_new_with_label("Force Trust (Accept Pending)");+ g_signal_connect(accept_btn, "clicked", G_CALLBACK(on_accept_click), nullptr);+ gtk_box_pack_start(GTK_BOX(pair_box), accept_btn, FALSE, FALSE, 0);++ gtk_stack_add_named(GTK_STACK(g_devices.right_pane_stack), pair_box, "pair");++ // Action+ GtkWidget* action_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 24);+ gtk_container_set_border_width(GTK_CONTAINER(action_box), 32);+ gtk_widget_set_valign(action_box, GTK_ALIGN_CENTER);++ g_devices.lbl_action_name = gtk_label_new(nullptr);+ gtk_widget_set_halign(g_devices.lbl_action_name, GTK_ALIGN_CENTER);+ gtk_box_pack_start(GTK_BOX(action_box), g_devices.lbl_action_name, FALSE, FALSE, 0);++ GtkWidget* btn_grid = gtk_box_new(GTK_ORIENTATION_VERTICAL, 12);+ gtk_widget_set_halign(btn_grid, GTK_ALIGN_CENTER);+ g_devices.btn_grid = btn_grid;++ GtkWidget* btn_send_file = gtk_button_new_with_label("Send File");+ gtk_style_context_add_class(gtk_widget_get_style_context(btn_send_file), "suggested-action");+ g_signal_connect(btn_send_file, "clicked", G_CALLBACK(on_choose_file), nullptr);+ gtk_box_pack_start(GTK_BOX(btn_grid), btn_send_file, FALSE, FALSE, 0);++ GtkWidget* btn_send_clip = gtk_button_new_with_label("Send Clipboard");+ g_signal_connect(btn_send_clip,+ "clicked",+ G_CALLBACK(+[](GtkWidget*, gpointer) {+ nlohmann::json j;+ j["command"] = "clipboard_set"; // triggers clipboard send+ daemon_send(j);+ set_status_action("Clipboard sync requested...");+ }),+ nullptr);+ gtk_box_pack_start(GTK_BOX(btn_grid), btn_send_clip, FALSE, FALSE, 0);++ gtk_box_pack_start(GTK_BOX(action_box), btn_grid, FALSE, FALSE, 0);++ g_devices.lbl_action_status = gtk_label_new("Ready");+ gtk_widget_set_halign(g_devices.lbl_action_status, GTK_ALIGN_CENTER);+ gtk_style_context_add_class(gtk_widget_get_style_context(g_devices.lbl_action_status), "muted");+ gtk_box_pack_start(GTK_BOX(action_box), g_devices.lbl_action_status, FALSE, FALSE, 0);++ gtk_stack_add_named(GTK_STACK(g_devices.right_pane_stack), action_box, "action");++ gtk_paned_pack2(GTK_PANED(paned), g_devices.right_pane_stack, TRUE, FALSE);+ gtk_stack_set_visible_child_name(GTK_STACK(g_devices.right_pane_stack), "placeholder");++ return paned;+ }++} // namespace tether::uidiff --git a/src/gtk/devices_view.hpp b/src/gtk/devices_view.hppnew file mode 100644index 0000000..b4dfd3e--- /dev/null+++ b/src/gtk/devices_view.hpp@@ -0,0 +1,18 @@+#pragma once++#include <gtk/gtk.h>+#include <nlohmann/json.hpp>++namespace tether::ui {++ // The device manager: discovered, remembered and connected devices beside a+ // pane for acting on the selected one.+ GtkWidget* devices_view_new();++ // Returns true when the event belonged to this view.+ bool devices_view_handle_event(const nlohmann::json& event);++ void devices_view_refresh();+ void devices_view_trigger_discovery();++} // namespace tether::uidiff --git a/src/gtk/main.cpp b/src/gtk/main.cppindex 251fa1b..da02e2e 100644--- a/src/gtk/main.cpp+++ b/src/gtk/main.cpp@@ -1,794 +1,95 @@-#include <gio/gio.h>-#include <gtk/gtk.h>--#include <nlohmann/json.hpp>+#include "daemon_client.hpp"+#include "devices_view.hpp"+#include "messages_view.hpp"+#include "notifications_view.hpp"+#include "ui_util.hpp"-#include <algorithm>-#include <cstdio>-#include <cstdlib>-#include <ctime>-#include <filesystem>-#include <string>-#include <sys/socket.h>-#include <sys/un.h>-#include <sys/wait.h>-#include <tether/core.hpp>+#include <gtk/gtk.h>#include <tether/crypto.hpp>-#include <tether/discovery.hpp>-#include <tether/log.hpp>-#include <tether/net.hpp>-#include <unistd.h>-#include <vector>namespace {- struct AppState {- std::vector<tether::DiscoveredDevice> discovered_devices;- std::vector<tether::DiscoveredDevice> pending_pairing_requests;- std::vector<std::pair<std::string, std::string>> paired_devices; // fp, name- std::vector<std::string> connected_fps; // active connections-- int event_fd = -1;- GIOChannel* event_channel = nullptr;- guint event_watch_id = 0;- guint event_retry_id = 0;-- GtkApplication* app = nullptr;- GtkWidget* window = nullptr;-- GtkWidget* header_bar = nullptr;- GtkWidget* list_devices = nullptr;- GtkWidget* right_pane_stack = nullptr;-- std::string selected_device_fp;- std::string selected_device_name;- std::string selected_device_ip;- uint16_t selected_device_port = 5134;-- GtkWidget* lbl_action_name = nullptr;- GtkWidget* lbl_action_status = nullptr;- GtkWidget* btn_grid = nullptr;-- GtkWidget* lbl_unpaired_name = nullptr;- GtkWidget* lbl_unpaired_ip = nullptr;- };-- AppState g_app;-- std::string format_fingerprint(const std::string& fingerprint) {- std::string formatted;- for (size_t i = 0; i < fingerprint.size(); ++i) {- if (i > 0 && i % 2 == 0)- formatted += ":";- formatted += fingerprint[i];- }- return formatted;- }-- std::string escape_markup(const std::string& text) {- gchar* escaped = g_markup_escape_text(text.c_str(), -1);- std::string result = escaped ? escaped : "";- g_free(escaped);- return result;- }-- void set_markup(GtkWidget* label, const std::string& text) {- if (label) {- gtk_label_set_markup(GTK_LABEL(label), text.c_str());- }- }-- void set_status(GtkWidget* label, const std::string& text) {- if (label) {- gtk_label_set_text(GTK_LABEL(label), text.c_str());- }- }-- void set_status_main(const std::string& text) {- if (g_app.header_bar) {- gtk_header_bar_set_subtitle(GTK_HEADER_BAR(g_app.header_bar), text.c_str());- }- }-- void set_status_action(const std::string& text) { set_status(g_app.lbl_action_status, text); }-- void send_async_daemon_message(const nlohmann::json& j) {- if (g_app.event_fd >= 0) {- std::string payload = j.dump() + "\n";- if (::write(g_app.event_fd, payload.c_str(), payload.size()) < 0) {- debug::log(ERR, "daemon write error\n");- }- }- }-- void trigger_discovery() {- set_status_main("Scanning for nearby devices...");- nlohmann::json j;- j["command"] = "discover";- send_async_daemon_message(j);- }-- void clear_list_box(GtkWidget* list_box) {- GList* children = gtk_container_get_children(GTK_CONTAINER(list_box));- for (GList* iter = children; iter; iter = g_list_next(iter)) {- gtk_widget_destroy(GTK_WIDGET(iter->data));- }- g_list_free(children);- }-- // Refresh the device list based on Discovered (unpaired), Paired (offline), Paired (online)- void refresh_device_list() {- clear_list_box(g_app.list_devices);-- tether::Crypto::instance().init();- try {- nlohmann::json known = nlohmann::json::parse(tether::Crypto::instance().get_known_hosts_dump());- g_app.paired_devices.clear();- if (!known.empty()) {- for (auto& [fingerprint, name_value] : known.items()) {- g_app.paired_devices.push_back(- {fingerprint, name_value.is_string() ? name_value.get<std::string>() : "Unknown Device"});- }- }- } catch (...) {- }-- // We build a unified list of devices.- // 1. All Paired Devices- // 2. Any Discovered Devices not in the Paired list-- auto create_row = [](const std::string& name,- const std::string& fp,- const std::string& ip,- uint16_t port,- bool paired,- bool online) {- GtkWidget* row = gtk_list_box_row_new();- g_object_set_data_full(G_OBJECT(row), "fp", g_strdup(fp.c_str()), g_free);- g_object_set_data_full(G_OBJECT(row), "name", g_strdup(name.c_str()), g_free);- g_object_set_data_full(G_OBJECT(row), "ip", g_strdup(ip.c_str()), g_free);- g_object_set_data(G_OBJECT(row), "port", GINT_TO_POINTER(port));- g_object_set_data(G_OBJECT(row), "paired", GINT_TO_POINTER(paired ? 1 : 0));-- GtkWidget* box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);- gtk_container_set_border_width(GTK_CONTAINER(box), 12);-- const char* icon_name =- paired ? (online ? "network-cellular-connected-symbolic" : "network-cellular-offline-symbolic")- : "dialog-information-symbolic";- GtkWidget* icon = gtk_image_new_from_icon_name(icon_name, GTK_ICON_SIZE_LARGE_TOOLBAR);- gtk_box_pack_start(GTK_BOX(box), icon, FALSE, FALSE, 0);-- GtkWidget* labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);- GtkWidget* title = gtk_label_new(nullptr);- gtk_label_set_markup(GTK_LABEL(title), ("<b>" + escape_markup(name) + "</b>").c_str());- gtk_label_set_xalign(GTK_LABEL(title), 0.0);- gtk_box_pack_start(GTK_BOX(labels), title, FALSE, FALSE, 0);-- GtkWidget* subtitle = gtk_label_new(paired ? (online ? "Connected" : "Offline") : "Nearby (Tap to Pair)");- gtk_label_set_xalign(GTK_LABEL(subtitle), 0.0);- gtk_style_context_add_class(gtk_widget_get_style_context(subtitle), "muted");- gtk_box_pack_start(GTK_BOX(labels), subtitle, FALSE, FALSE, 0);-- gtk_box_pack_start(GTK_BOX(box), labels, TRUE, TRUE, 0);- gtk_container_add(GTK_CONTAINER(row), box);- return row;- };-- auto create_header_row = [](const std::string& title_text) {- GtkWidget* row = gtk_list_box_row_new();- gtk_list_box_row_set_selectable(GTK_LIST_BOX_ROW(row), FALSE);- GtkWidget* box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);- gtk_container_set_border_width(GTK_CONTAINER(box), 8);- GtkWidget* lbl = gtk_label_new(nullptr);- gtk_label_set_markup(- GTK_LABEL(lbl),- ("<b><span size='small' color='gray'>" + escape_markup(title_text) + "</span></b>").c_str());- gtk_label_set_xalign(GTK_LABEL(lbl), 0.0);- gtk_box_pack_start(GTK_BOX(box), lbl, TRUE, TRUE, 0);- gtk_container_add(GTK_CONTAINER(row), box);- return row;- };-- std::string my_fp = tether::Crypto::instance().get_my_fingerprint();-- std::vector<GtkWidget*> connected_rows;- std::vector<GtkWidget*> remembered_rows;- std::vector<GtkWidget*> discovered_rows;-- for (const auto& paired : g_app.paired_devices) {- bool online = std::find(g_app.connected_fps.begin(), g_app.connected_fps.end(), paired.first) !=- g_app.connected_fps.end();- GtkWidget* r = create_row(paired.second, paired.first, "", 5134, true, online);- if (online) {- connected_rows.push_back(r);- } else {- remembered_rows.push_back(r);- }- }-- for (const auto& disc : g_app.discovered_devices) {- if (disc.fingerprint == my_fp)- continue;- bool is_paired = false;- for (const auto& p : g_app.paired_devices) {- if (p.first == disc.fingerprint) {- is_paired = true;- break;- }- }- if (is_paired)- continue; // already added above- std::string ip = disc.addresses.empty() ? "" : disc.addresses[0].address;- uint16_t port = disc.addresses.empty() ? 5134 : disc.addresses[0].port;- GtkWidget* r = create_row(disc.name, disc.fingerprint, ip, port, false, false);- discovered_rows.push_back(r);- }-- // Render Pending Pair Requests- for (const auto& req : g_app.pending_pairing_requests) {- bool is_paired = false;- for (const auto& p : g_app.paired_devices) {- if (p.first == req.fingerprint) {- is_paired = true;- break;- }- }- if (is_paired)- continue; // ignore if they successfully paired-- bool already_shown = false;- for (const auto& disc : g_app.discovered_devices) {- if (disc.fingerprint == req.fingerprint) {- already_shown = true;- break;- }- }- if (already_shown)- continue; // ignore if mDNS already populated it-- std::string ip = req.addresses.empty() ? "" : req.addresses[0].address;- uint16_t port = req.addresses.empty() ? 5134 : req.addresses[0].port;- GtkWidget* r = create_row(req.name, req.fingerprint, ip, port, false, false);- discovered_rows.push_back(r);- }-- if (!connected_rows.empty()) {- gtk_list_box_insert(GTK_LIST_BOX(g_app.list_devices), create_header_row("CONNECTED"), -1);- for (auto* r : connected_rows)- gtk_list_box_insert(GTK_LIST_BOX(g_app.list_devices), r, -1);- }-- if (!remembered_rows.empty()) {- gtk_list_box_insert(GTK_LIST_BOX(g_app.list_devices), create_header_row("REMEMBERED"), -1);- for (auto* r : remembered_rows)- gtk_list_box_insert(GTK_LIST_BOX(g_app.list_devices), r, -1);- }-- if (!discovered_rows.empty()) {- gtk_list_box_insert(GTK_LIST_BOX(g_app.list_devices), create_header_row("DISCOVERED"), -1);- for (auto* r : discovered_rows)- gtk_list_box_insert(GTK_LIST_BOX(g_app.list_devices), r, -1);- }-- gtk_widget_show_all(g_app.list_devices);- }-- void update_right_pane() {- if (g_app.selected_device_fp.empty()) {- gtk_stack_set_visible_child_name(GTK_STACK(g_app.right_pane_stack), "placeholder");- return;- }+ using namespace tether::ui;- bool is_paired = false;- for (const auto& p : g_app.paired_devices) {- if (p.first == g_app.selected_device_fp)- is_paired = true;- }+ GtkWidget* g_refresh_button = nullptr;- if (is_paired) {- gtk_stack_set_visible_child_name(GTK_STACK(g_app.right_pane_stack), "action");- set_markup(g_app.lbl_action_name, ("<b>" + escape_markup(g_app.selected_device_name) + "</b>"));- bool online = std::find(g_app.connected_fps.begin(), g_app.connected_fps.end(), g_app.selected_device_fp) !=- g_app.connected_fps.end();- set_status_action(online ? "Connected and ready." : "Device is offline. Pair again or wait for network.");- if (g_app.btn_grid) {- gtk_widget_set_visible(g_app.btn_grid, online);- }- } else {- gtk_stack_set_visible_child_name(GTK_STACK(g_app.right_pane_stack), "pair");- set_markup(g_app.lbl_unpaired_name, ("<b>" + escape_markup(g_app.selected_device_name) + "</b>"));- set_status(g_app.lbl_unpaired_ip,- ("Found at " + g_app.selected_device_ip + ":" + std::to_string(g_app.selected_device_port)));- }- }+ void on_visible_view_changed(GObject* stack, GParamSpec*, gpointer) {+ const gchar* name = gtk_stack_get_visible_child_name(GTK_STACK(stack));+ const std::string view = name ? name : "";- void on_device_selected(GtkListBox*, GtkListBoxRow* row, gpointer) {- if (!row)- return;- const char* fp = (const char*)g_object_get_data(G_OBJECT(row), "fp");- const char* name = (const char*)g_object_get_data(G_OBJECT(row), "name");- const char* ip = (const char*)g_object_get_data(G_OBJECT(row), "ip");- g_app.selected_device_fp = fp ? fp : "";- g_app.selected_device_name = name ? name : "";- g_app.selected_device_ip = ip ? ip : "";- g_app.selected_device_port = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(row), "port"));- update_right_pane();- }+ // Refresh means "scan for devices", which is meaningless on the other+ // views, so it only appears where it does something.+ if (g_refresh_button)+ gtk_widget_set_visible(g_refresh_button, view == "devices");- void on_pair_click(GtkWidget*, gpointer) {- if (g_app.selected_device_ip.empty())- return;- set_status(g_app.lbl_unpaired_ip, "Sending pair request...");- nlohmann::json j;- j["command"] = "pair_request";- j["host"] = g_app.selected_device_ip;- j["port"] = g_app.selected_device_port;- send_async_daemon_message(j);- set_status_main("Pair request sent. Approve on remote device!");- }-- void on_accept_click(GtkWidget*, gpointer) {- if (g_app.selected_device_fp.empty())- return;- nlohmann::json j;- j["command"] = "accept_device";- j["fingerprint"] = g_app.selected_device_fp;- send_async_daemon_message(j);- }-- void send_file_async(const std::filesystem::path& path) {- if (g_app.event_fd < 0) {- set_status_action("Daemon unavailable.");- return;- }- set_status_action("Sending " + path.filename().string() + "…");- nlohmann::json j;- j["command"] = "send_file";- j["path"] = path.string();- send_async_daemon_message(j);- }-- void on_choose_file(GtkWidget*, gpointer) {- GtkWidget* dialog = gtk_file_chooser_dialog_new("Send File",- GTK_WINDOW(g_app.window),- GTK_FILE_CHOOSER_ACTION_OPEN,- "_Cancel",- GTK_RESPONSE_CANCEL,- "_Send",- GTK_RESPONSE_ACCEPT,- nullptr);- if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {- char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));- if (filename) {- send_file_async(filename);- g_free(filename);- }- }- gtk_widget_destroy(dialog);- }-- void on_pull_clipboard(GtkWidget*, gpointer) {- nlohmann::json j;- j["command"] = "clipboard_get";- send_async_daemon_message(j);- set_status_action("Requested desktop clipboard...");- }-- void on_push_clipboard(GtkWidget*, gpointer) {- // Wait, KDE Connect puts local clipboard to remote automatically, or via button.- // We can just use the Push Clipboard button which pushes current wayland clipboard.- // But the daemon does this transparently! We just need `clipboard_set` if the user typed text,- // but here we just push whatever is on Wayland to the remote right now, wait...- // Actually, if the user hits "Push", we read local Wayland, then send it via daemon? No, the Daemon already- // pushes wayland changes! Actually, let's keep the button for explicit "Sync Now" if they disabled auto-sync.- }-- void apply_state_snapshot(const nlohmann::json& j) {- g_app.connected_fps.clear();- if (j.contains("connected_clients") && j["connected_clients"].is_array()) {- for (auto& c : j["connected_clients"]) {- if (c.value("paired", false)) {- g_app.connected_fps.push_back(c.value("fingerprint", ""));- } else {- tether::DiscoveredDevice dev;- dev.fingerprint = c.value("fingerprint", "");- dev.name = c.value("device_name", "Unknown Device");- dev.addresses.push_back({c.value("address", ""), 5134});- g_app.discovered_devices.push_back(dev);- }- }- }- g_app.pending_pairing_requests.clear();- if (j.contains("pending_pairs") && j["pending_pairs"].is_array()) {- for (auto& p : j["pending_pairs"]) {- tether::DiscoveredDevice req;- req.fingerprint = p.value("fingerprint", "");- req.name = p.value("device_name", "Unknown Device");- g_app.pending_pairing_requests.push_back(req);- }- }- refresh_device_list();- }-- void handle_daemon_event(const nlohmann::json& event) {- const std::string command = event.value("command", "");- if (command == "state_snapshot") {- apply_state_snapshot(event);- return;- }- if (command == "client_connected") {- std::string fp = event.value("fingerprint", "");- if (std::find(g_app.connected_fps.begin(), g_app.connected_fps.end(), fp) == g_app.connected_fps.end()) {- g_app.connected_fps.push_back(fp);- }- refresh_device_list();- update_right_pane();- return;- }- if (command == "client_disconnected") {- std::string fp = event.value("fingerprint", "");- g_app.connected_fps.erase(std::remove(g_app.connected_fps.begin(), g_app.connected_fps.end(), fp),- g_app.connected_fps.end());- refresh_device_list();- update_right_pane();- return;- }- if (command == "pair_request_received" || command == "untrusted_client_connected") {- tether::DiscoveredDevice req;- req.fingerprint = event.value("fingerprint", "");-- std::string resolved_name = event.value("device_name", "Unknown Device");- if (resolved_name == "Unknown Device") {- for (const auto& d : g_app.discovered_devices) {- if (d.fingerprint == req.fingerprint && !d.name.empty()) {- resolved_name = d.name;- break;- }- }- }- req.name = resolved_name;- req.addresses.push_back({event.value("address", ""), 5134});- bool exists = false;- for (const auto& dev : g_app.pending_pairing_requests) {- if (dev.fingerprint == req.fingerprint) {- exists = true;- break;- }- }- if (!exists) {- g_app.pending_pairing_requests.push_back(req);- refresh_device_list();- }- return;- }- if (command == "pair_accepted") {- std::string fp = event.value("fingerprint", "");- std::string name = event.value("device_name", "");- if (!fp.empty()) {- g_app.connected_fps.push_back(fp);-- // Ensure it's in the paired devices list so the UI transitions- bool already_paired = false;- for (const auto& p : g_app.paired_devices) {- if (p.first == fp) {- already_paired = true;- break;- }- }- if (!already_paired)- g_app.paired_devices.push_back({fp, name});-- g_app.pending_pairing_requests.erase(- std::remove_if(g_app.pending_pairing_requests.begin(),- g_app.pending_pairing_requests.end(),- [&](const tether::DiscoveredDevice& d) { return d.fingerprint == fp; }),- g_app.pending_pairing_requests.end());- refresh_device_list();- update_right_pane();- }- return;- }- if (command == "discovery_result") {- g_app.discovered_devices.clear();- if (event.contains("devices") && event["devices"].is_array()) {- for (const auto& d : event["devices"]) {- tether::DiscoveredDevice dev;- dev.name = d.value("name", "");- dev.fingerprint = d.value("fingerprint", "");- if (d.contains("addresses") && d["addresses"].is_array()) {- for (const auto& a : d["addresses"]) {- dev.addresses.push_back({a.value("address", ""), a.value<uint16_t>("port", 5134)});- }- }- g_app.discovered_devices.push_back(dev);- }- }- refresh_device_list();- set_status_main("Ready");- return;- }- if (command == "file_send_complete") {- bool ok = event.value("success", false);- set_status_action(event.value("message", ""));- return;- }- if (command == "clipboard_content") {- set_status_action("Desktop Clipboard Sync triggered.");- return;- }- if (command == "pair_accepted") {- // Remove from pending pairing requests- std::string fp = event.value("fingerprint", "");- g_app.pending_pairing_requests.erase(- std::remove_if(g_app.pending_pairing_requests.begin(),- g_app.pending_pairing_requests.end(),- [&](const tether::DiscoveredDevice& d) { return d.fingerprint == fp; }),- g_app.pending_pairing_requests.end());-- refresh_device_list();- update_right_pane();- return;- }- }-- // ----------- EVENT LOOP ------------ void stop_event_subscription() {- if (g_app.event_watch_id != 0) {- g_source_remove(g_app.event_watch_id);- g_app.event_watch_id = 0;- }- if (g_app.event_channel) {- g_io_channel_shutdown(g_app.event_channel, TRUE, nullptr);- g_io_channel_unref(g_app.event_channel);- g_app.event_channel = nullptr;- } else if (g_app.event_fd >= 0) {- close(g_app.event_fd);- }- g_app.event_fd = -1;- }-- gboolean start_event_subscription(gpointer);- void schedule_event_retry() {- if (g_app.event_retry_id == 0)- g_app.event_retry_id = g_timeout_add_seconds(2, start_event_subscription, nullptr);- }-- gboolean on_event_channel(GIOChannel* source, GIOCondition condition, gpointer) {- if (condition & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {- stop_event_subscription();- schedule_event_retry();- set_status_main("Daemon Offline");- return FALSE;- }- if (condition & G_IO_IN) {- gchar* line = nullptr;- gsize length = 0;- GError* error = nullptr;- while (true) {- GIOStatus status = g_io_channel_read_line(source, &line, &length, nullptr, &error);- if (status == G_IO_STATUS_AGAIN) {- if (line)- g_free(line);- break;- }- if (status == G_IO_STATUS_EOF || status == G_IO_STATUS_ERROR) {- if (error) {- debug::log(ERR, "Stream err: {}", error->message);- g_error_free(error);- }- if (line)- g_free(line);- stop_event_subscription();- schedule_event_retry();- set_status_main("Daemon Offline");- return FALSE;- }- if (line && length > 0) {- try {- handle_daemon_event(nlohmann::json::parse(std::string(line, length)));- } catch (...) {- }- }- if (line)- g_free(line);- }- }- return TRUE;- }-- gboolean start_event_subscription(gpointer) {- if (g_app.event_retry_id != 0) {- g_source_remove(g_app.event_retry_id);- g_app.event_retry_id = 0;- }- stop_event_subscription();- int fd = socket(AF_UNIX, SOCK_STREAM, 0);- if (fd < 0) {- schedule_event_retry();- return G_SOURCE_REMOVE;- }-- sockaddr_un addr{};- addr.sun_family = AF_UNIX;- std::string path = tether::get_runtime_dir() + "/tetherd.sock";- std::strncpy(addr.sun_path, path.c_str(), sizeof(addr.sun_path) - 1);-- if (::connect(fd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {- close(fd);- static bool autostart_attempted = false;- if (!autostart_attempted) {- autostart_attempted = true;- pid_t pid = fork();- if (pid == 0) {- std::filesystem::path self_path = std::filesystem::read_symlink("/proc/self/exe");- std::string daemon_path = (self_path.parent_path() / "tetherd").string();- if (fork() == 0) {- if (freopen("/dev/null", "w", stdout) == nullptr) {- }- if (freopen("/dev/null", "w", stderr) == nullptr) {- }- if (freopen("/dev/null", "r", stdin) == nullptr) {- }- execl(daemon_path.c_str(), "tetherd", nullptr);- execlp("tetherd", "tetherd", nullptr);- exit(1);- }- exit(0);- } else if (pid > 0) {- int status;- waitpid(pid, &status, 0);- }- }- schedule_event_retry();- set_status_main("Daemon Offline");- return G_SOURCE_REMOVE;- }-- g_app.event_fd = fd;- g_app.event_channel = g_io_channel_unix_new(fd);- g_io_channel_set_encoding(g_app.event_channel, nullptr, nullptr);- g_io_channel_set_buffered(g_app.event_channel, TRUE);- g_io_channel_set_flags(g_app.event_channel, G_IO_FLAG_NONBLOCK, nullptr);- g_app.event_watch_id = g_io_add_watch(g_app.event_channel,- static_cast<GIOCondition>(G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL),- on_event_channel,- nullptr);- static const char kSubscribe[] = "{\"command\":\"subscribe\"}\n";- if (write(fd, kSubscribe, sizeof(kSubscribe) - 1) < 0) {- debug::log(ERR, "subscribe write error\n");- }- set_status_main("Daemon Online");- return G_SOURCE_REMOVE;+ messages_view_set_visible(view == "messages");+ notifications_view_set_visible(view == "notifications");}void activate(GtkApplication* app, gpointer) {- g_app.app = app;tether::Crypto::instance().init();- g_app.window = gtk_application_window_new(app);- gtk_window_set_title(GTK_WINDOW(g_app.window), "Tether");- gtk_window_set_default_size(GTK_WINDOW(g_app.window), 600, 500);-- // HeaderBar- g_app.header_bar = gtk_header_bar_new();- gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(g_app.header_bar), TRUE);- gtk_header_bar_set_title(GTK_HEADER_BAR(g_app.header_bar), "Tether");- gtk_window_set_titlebar(GTK_WINDOW(g_app.window), g_app.header_bar);-- GtkWidget* refresh_btn = gtk_button_new_from_icon_name("view-refresh-symbolic", GTK_ICON_SIZE_BUTTON);- g_signal_connect(- refresh_btn, "clicked", G_CALLBACK(+[](GtkWidget*, gpointer) { trigger_discovery(); }), nullptr);- gtk_header_bar_pack_start(GTK_HEADER_BAR(g_app.header_bar), refresh_btn);-- // Paned Layout- GtkWidget* paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);- gtk_container_add(GTK_CONTAINER(g_app.window), paned);-- // Left Pane (List)- GtkWidget* left_scroll = gtk_scrolled_window_new(nullptr, nullptr);- gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(left_scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);- gtk_widget_set_size_request(left_scroll, 220, -1);+ GtkWidget* window = gtk_application_window_new(app);+ gtk_window_set_title(GTK_WINDOW(window), "Tether");+ gtk_window_set_default_size(GTK_WINDOW(window), 820, 560);+ set_main_window(window);- g_app.list_devices = gtk_list_box_new();- g_signal_connect(g_app.list_devices, "row-selected", G_CALLBACK(on_device_selected), nullptr);- gtk_container_add(GTK_CONTAINER(left_scroll), g_app.list_devices);- gtk_paned_pack1(GTK_PANED(paned), left_scroll, FALSE, FALSE);+ GtkWidget* header_bar = gtk_header_bar_new();+ gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(header_bar), TRUE);+ gtk_header_bar_set_title(GTK_HEADER_BAR(header_bar), "Tether");+ gtk_window_set_titlebar(GTK_WINDOW(window), header_bar);+ set_header_bar(header_bar);- // Right Pane- g_app.right_pane_stack = gtk_stack_new();- gtk_stack_set_transition_type(GTK_STACK(g_app.right_pane_stack), GTK_STACK_TRANSITION_TYPE_CROSSFADE);-- // --- State: Placeholder ---- GtkWidget* placeholder = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);- gtk_widget_set_valign(placeholder, GTK_ALIGN_CENTER);- gtk_widget_set_halign(placeholder, GTK_ALIGN_CENTER);- GtkWidget* p_icon = gtk_image_new_from_icon_name("computer-symbolic", GTK_ICON_SIZE_DIALOG);- gtk_box_pack_start(GTK_BOX(placeholder), p_icon, FALSE, FALSE, 0);- GtkWidget* p_lbl = gtk_label_new("Select a device to start");- gtk_style_context_add_class(gtk_widget_get_style_context(p_lbl), "muted");- gtk_box_pack_start(GTK_BOX(placeholder), p_lbl, FALSE, FALSE, 0);- gtk_stack_add_named(GTK_STACK(g_app.right_pane_stack), placeholder, "placeholder");-- // --- State: Pair ---- GtkWidget* pair_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 16);- gtk_widget_set_valign(pair_box, GTK_ALIGN_CENTER);- gtk_widget_set_halign(pair_box, GTK_ALIGN_CENTER);- g_app.lbl_unpaired_name = gtk_label_new(nullptr);- gtk_box_pack_start(GTK_BOX(pair_box), g_app.lbl_unpaired_name, FALSE, FALSE, 0);- g_app.lbl_unpaired_ip = gtk_label_new(nullptr);- gtk_style_context_add_class(gtk_widget_get_style_context(g_app.lbl_unpaired_ip), "muted");- gtk_box_pack_start(GTK_BOX(pair_box), g_app.lbl_unpaired_ip, FALSE, FALSE, 0);-- GtkWidget* pair_btn = gtk_button_new_with_label("Pair Device");- gtk_style_context_add_class(gtk_widget_get_style_context(pair_btn), "suggested-action");- g_signal_connect(pair_btn, "clicked", G_CALLBACK(on_pair_click), nullptr);- gtk_box_pack_start(GTK_BOX(pair_box), pair_btn, FALSE, FALSE, 0);-- // optional accept override button- GtkWidget* accept_btn = gtk_button_new_with_label("Force Trust (Accept Pending)");- g_signal_connect(accept_btn, "clicked", G_CALLBACK(on_accept_click), nullptr);- gtk_box_pack_start(GTK_BOX(pair_box), accept_btn, FALSE, FALSE, 0);-- gtk_stack_add_named(GTK_STACK(g_app.right_pane_stack), pair_box, "pair");-- // --- State: Action ---- GtkWidget* action_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 24);- gtk_container_set_border_width(GTK_CONTAINER(action_box), 32);- gtk_widget_set_valign(action_box, GTK_ALIGN_CENTER);-- g_app.lbl_action_name = gtk_label_new(nullptr);- gtk_widget_set_halign(g_app.lbl_action_name, GTK_ALIGN_CENTER);- gtk_box_pack_start(GTK_BOX(action_box), g_app.lbl_action_name, FALSE, FALSE, 0);-- GtkWidget* btn_grid = gtk_box_new(GTK_ORIENTATION_VERTICAL, 12);- gtk_widget_set_halign(btn_grid, GTK_ALIGN_CENTER);- g_app.btn_grid = btn_grid;-- GtkWidget* btn_send_file = gtk_button_new_with_label("Send File");- gtk_style_context_add_class(gtk_widget_get_style_context(btn_send_file), "suggested-action");- g_signal_connect(btn_send_file, "clicked", G_CALLBACK(on_choose_file), nullptr);- gtk_box_pack_start(GTK_BOX(btn_grid), btn_send_file, FALSE, FALSE, 0);-- GtkWidget* btn_send_clip = gtk_button_new_with_label("Send Clipboard");- g_signal_connect(btn_send_clip,+ g_refresh_button = gtk_button_new_from_icon_name("view-refresh-symbolic", GTK_ICON_SIZE_BUTTON);+ g_signal_connect(g_refresh_button,"clicked",- G_CALLBACK(+[](GtkWidget*, gpointer) {- nlohmann::json j;- j["command"] = "clipboard_set"; // triggers clipboard send- send_async_daemon_message(j);- set_status_action("Clipboard sync requested...");- }),+ G_CALLBACK(+[](GtkWidget*, gpointer) { devices_view_trigger_discovery(); }),nullptr);- gtk_box_pack_start(GTK_BOX(btn_grid), btn_send_clip, FALSE, FALSE, 0);+ gtk_header_bar_pack_start(GTK_HEADER_BAR(header_bar), g_refresh_button);++ GtkWidget* stack = gtk_stack_new();+ gtk_stack_set_transition_type(GTK_STACK(stack), GTK_STACK_TRANSITION_TYPE_CROSSFADE);+ gtk_stack_add_titled(GTK_STACK(stack), devices_view_new(), "devices", "Devices");+ gtk_stack_add_titled(GTK_STACK(stack), messages_view_new(), "messages", "Messages");+ gtk_stack_add_titled(GTK_STACK(stack), notifications_view_new(), "notifications", "Notifications");- gtk_box_pack_start(GTK_BOX(action_box), btn_grid, FALSE, FALSE, 0);+ GtkWidget* switcher = gtk_stack_switcher_new();+ gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(switcher), GTK_STACK(stack));+ gtk_header_bar_set_custom_title(GTK_HEADER_BAR(header_bar), switcher);- g_app.lbl_action_status = gtk_label_new("Ready");- gtk_widget_set_halign(g_app.lbl_action_status, GTK_ALIGN_CENTER);- gtk_style_context_add_class(gtk_widget_get_style_context(g_app.lbl_action_status), "muted");- gtk_box_pack_start(GTK_BOX(action_box), g_app.lbl_action_status, FALSE, FALSE, 0);+ g_signal_connect(stack, "notify::visible-child-name", G_CALLBACK(on_visible_view_changed), nullptr);+ gtk_container_add(GTK_CONTAINER(window), stack);- gtk_stack_add_named(GTK_STACK(g_app.right_pane_stack), action_box, "action");+ // One feed, dispatched to whichever view owns the event; the views never+ // hold the socket themselves.+ daemon_client_start([](const nlohmann::json& event) {+ if (devices_view_handle_event(event))+ return;+ if (messages_view_handle_event(event))+ return;+ notifications_view_handle_event(event);+ });- gtk_paned_pack2(GTK_PANED(paned), g_app.right_pane_stack, TRUE, FALSE);- gtk_stack_set_visible_child_name(GTK_STACK(g_app.right_pane_stack), "placeholder");+ devices_view_trigger_discovery();+ devices_view_refresh();- start_event_subscription(nullptr);- trigger_discovery();- refresh_device_list();+ // Ask once at startup so the messages banner reflects reality before the+ // user ever opens that view.+ nlohmann::json connection;+ connection["command"] = "bt_connection";+ daemon_send(connection);- gtk_widget_show_all(g_app.window);+ gtk_widget_show_all(window);+ gtk_stack_set_visible_child_name(GTK_STACK(stack), "devices");}+} // namespaceint main(int argc, char** argv) {GtkApplication* app = gtk_application_new("com.tether.desktop", G_APPLICATION_DEFAULT_FLAGS);g_signal_connect(app, "activate", G_CALLBACK(activate), nullptr);int status = g_application_run(G_APPLICATION(app), argc, argv);- stop_event_subscription();- if (g_app.event_retry_id != 0)- g_source_remove(g_app.event_retry_id);+ tether::ui::daemon_client_stop();g_object_unref(app);return status;}diff --git a/src/gtk/messages_view.cpp b/src/gtk/messages_view.cppnew file mode 100644index 0000000..6abf803--- /dev/null+++ b/src/gtk/messages_view.cpp@@ -0,0 +1,450 @@+#include "messages_view.hpp"+#include "daemon_client.hpp"+#include "ui_util.hpp"++#include <ctime>+#include <string>++namespace tether::ui {++ namespace {++ struct MessagesState {+ GtkWidget* banner = nullptr;+ GtkWidget* banner_label = nullptr;+ GtkWidget* thread_list = nullptr;+ GtkWidget* conversation = nullptr;+ GtkWidget* conversation_scroll = nullptr;+ GtkWidget* composer = nullptr;+ GtkWidget* send_button = nullptr;+ GtkWidget* placeholder_stack = nullptr;++ std::string selected_thread;+ std::string selected_name;+ bool visible = false;+ bool map_open = false;+ bool sending = false;+ // Whether the daemon says the selected thread can be replied to, and+ // why not when it cannot.+ bool selected_repliable = false;+ std::string selected_block_reason;+ };++ MessagesState g_messages;++ void update_composer_sensitivity();++ std::string format_timestamp(int64_t epoch) {+ if (epoch <= 0)+ return "";+ std::time_t t = static_cast<std::time_t>(epoch);+ std::tm tm{};+ localtime_r(&t, &tm);++ std::time_t now = std::time(nullptr);+ std::tm now_tm{};+ localtime_r(&now, &now_tm);++ char buffer[64];+ // Same day gets a time, anything older gets a date: a wall of+ // identical timestamps is harder to scan than a mixed list.+ const char* format =+ (tm.tm_year == now_tm.tm_year && tm.tm_yday == now_tm.tm_yday) ? "%H:%M" : "%b %-d, %H:%M";+ std::strftime(buffer, sizeof(buffer), format, &tm);+ return buffer;+ }++ void request_threads() {+ nlohmann::json j;+ j["command"] = "bt_list_threads";+ daemon_send(j);+ }++ void request_messages(const std::string& thread_key) {+ if (thread_key.empty())+ return;+ nlohmann::json j;+ j["command"] = "bt_list_messages";+ j["thread"] = thread_key;+ daemon_send(j);+ }++ GtkWidget* build_thread_row(const nlohmann::json& thread) {+ const std::string key = thread.value("thread", "");+ const std::string address = thread.value("address", "");+ const std::string name = thread.value("name", address);+ const std::string preview = thread.value("preview", "");+ const int unread = thread.value("unread", 0);++ GtkWidget* row = gtk_list_box_row_new();+ g_object_set_data_full(G_OBJECT(row), "thread", g_strdup(key.c_str()), g_free);+ g_object_set_data_full(G_OBJECT(row), "name", g_strdup(name.c_str()), g_free);+ // The daemon owns the decision about whether a group can be replied+ // to; the UI must not re-derive it from the key shape.+ g_object_set_data(G_OBJECT(row), "repliable", GINT_TO_POINTER(thread.value("repliable", true) ? 1 : 0));+ g_object_set_data_full(+ G_OBJECT(row), "reply_reason", g_strdup(thread.value("reply_reason", "").c_str()), g_free);+ g_object_set_data(G_OBJECT(row), "group", GINT_TO_POINTER(thread.value("group", false) ? 1 : 0));++ GtkWidget* box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);+ gtk_container_set_border_width(GTK_CONTAINER(box), 10);++ GtkWidget* labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);++ GtkWidget* title = gtk_label_new(nullptr);+ gtk_label_set_markup(GTK_LABEL(title), ("<b>" + escape_markup(name) + "</b>").c_str());+ gtk_label_set_xalign(GTK_LABEL(title), 0.0);+ gtk_label_set_ellipsize(GTK_LABEL(title), PANGO_ELLIPSIZE_END);+ gtk_box_pack_start(GTK_BOX(labels), title, FALSE, FALSE, 0);++ GtkWidget* subtitle = gtk_label_new(preview.c_str());+ gtk_label_set_xalign(GTK_LABEL(subtitle), 0.0);+ gtk_label_set_ellipsize(GTK_LABEL(subtitle), PANGO_ELLIPSIZE_END);+ gtk_label_set_single_line_mode(GTK_LABEL(subtitle), TRUE);+ gtk_style_context_add_class(gtk_widget_get_style_context(subtitle), "muted");+ gtk_box_pack_start(GTK_BOX(labels), subtitle, FALSE, FALSE, 0);++ gtk_box_pack_start(GTK_BOX(box), labels, TRUE, TRUE, 0);++ if (unread > 0) {+ GtkWidget* badge = gtk_label_new(nullptr);+ gtk_label_set_markup(GTK_LABEL(badge), ("<b>" + std::to_string(unread) + "</b>").c_str());+ gtk_widget_set_valign(badge, GTK_ALIGN_CENTER);+ gtk_box_pack_start(GTK_BOX(box), badge, FALSE, FALSE, 0);+ }++ gtk_container_add(GTK_CONTAINER(row), box);+ return row;+ }++ GtkWidget* build_message_row(const nlohmann::json& message) {+ const bool outgoing = message.value("outgoing", false);+ const std::string body = message.value("body", "");+ const std::string stamp = format_timestamp(message.value("timestamp", static_cast<int64_t>(0)));++ GtkWidget* row = gtk_list_box_row_new();+ gtk_list_box_row_set_selectable(GTK_LIST_BOX_ROW(row), FALSE);+ gtk_list_box_row_set_activatable(GTK_LIST_BOX_ROW(row), FALSE);++ GtkWidget* box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);+ gtk_container_set_border_width(GTK_CONTAINER(box), 8);+ gtk_widget_set_halign(box, outgoing ? GTK_ALIGN_END : GTK_ALIGN_START);++ GtkWidget* bubble = gtk_label_new(body.c_str());+ gtk_label_set_line_wrap(GTK_LABEL(bubble), TRUE);+ gtk_label_set_line_wrap_mode(GTK_LABEL(bubble), PANGO_WRAP_WORD_CHAR);+ gtk_label_set_max_width_chars(GTK_LABEL(bubble), 48);+ gtk_label_set_xalign(GTK_LABEL(bubble), outgoing ? 1.0 : 0.0);+ gtk_label_set_selectable(GTK_LABEL(bubble), TRUE);+ gtk_box_pack_start(GTK_BOX(box), bubble, FALSE, FALSE, 0);++ if (!stamp.empty()) {+ GtkWidget* time_label = gtk_label_new(stamp.c_str());+ gtk_label_set_xalign(GTK_LABEL(time_label), outgoing ? 1.0 : 0.0);+ gtk_style_context_add_class(gtk_widget_get_style_context(time_label), "muted");+ gtk_box_pack_start(GTK_BOX(box), time_label, FALSE, FALSE, 0);+ }++ gtk_container_add(GTK_CONTAINER(row), box);+ return row;+ }++ void scroll_conversation_to_end() {+ if (!g_messages.conversation_scroll)+ return;+ GtkAdjustment* adjustment =+ gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(g_messages.conversation_scroll));+ if (adjustment)+ gtk_adjustment_set_value(adjustment, gtk_adjustment_get_upper(adjustment));+ }++ void show_threads(const nlohmann::json& event) {+ clear_list_box(g_messages.thread_list);+ if (!event.contains("threads") || !event["threads"].is_array())+ return;++ GtkWidget* reselect = nullptr;+ for (const auto& thread : event["threads"]) {+ GtkWidget* row = build_thread_row(thread);+ gtk_list_box_insert(GTK_LIST_BOX(g_messages.thread_list), row, -1);+ if (thread.value("thread", "") == g_messages.selected_thread)+ reselect = row;+ }+ gtk_widget_show_all(g_messages.thread_list);++ // Rebuilding the list drops the selection; restoring it keeps the+ // open conversation from closing every time a message arrives.+ if (reselect)+ gtk_list_box_select_row(GTK_LIST_BOX(g_messages.thread_list), GTK_LIST_BOX_ROW(reselect));+ }++ void show_messages(const nlohmann::json& event) {+ if (event.value("thread", "") != g_messages.selected_thread)+ return;++ clear_list_box(g_messages.conversation);+ if (event.contains("messages") && event["messages"].is_array()) {+ for (const auto& message : event["messages"])+ gtk_list_box_insert(GTK_LIST_BOX(g_messages.conversation), build_message_row(message), -1);+ }+ gtk_widget_show_all(g_messages.conversation);+ scroll_conversation_to_end();++ // Opening a conversation marks it read here and on the phone, which+ // is what makes the unread badge agree with what the user has seen.+ if (event.contains("messages") && event["messages"].is_array()) {+ for (const auto& message : event["messages"]) {+ if (message.value("read", true) || message.value("outgoing", false))+ continue;+ nlohmann::json j;+ j["command"] = "bt_mark_read";+ j["handle"] = message.value("handle", "");+ j["read"] = true;+ daemon_send(j);+ }+ }+ }++ void set_banner(const std::string& text) {+ if (!g_messages.banner)+ return;+ if (text.empty()) {+ gtk_widget_hide(g_messages.banner);+ return;+ }+ set_text(g_messages.banner_label, text);+ gtk_widget_show_all(g_messages.banner);+ }++ void update_connection(const nlohmann::json& event) {+ const bool map_open = event.value("map_open", false);+ g_messages.map_open = map_open;+ update_composer_sensitivity();+ if (map_open) {+ set_banner("");+ if (g_messages.visible)+ request_threads();+ return;+ }+ // The daemon's reason strings name the actual next step, including+ // which toggle to flip on the phone, so they are shown verbatim+ // rather than replaced with something vaguer.+ std::string reason = event.value("profile_reason", "");+ if (reason.empty())+ reason = event.value("link_reason", "");+ if (reason.empty())+ reason = "Messages are not connected.";+ set_banner(reason);+ }++ // Replying needs an open conversation and a live MAP session. A group+ // thread has no reply routing yet, and the daemon refuses one anyway, so+ // the composer stays shut rather than accepting text that will bounce.+ void update_composer_sensitivity() {+ const bool can_send =+ g_messages.map_open && !g_messages.selected_thread.empty() && g_messages.selected_repliable;+ if (!g_messages.composer)+ return;++ gtk_widget_set_sensitive(g_messages.composer, can_send && !g_messages.sending);+ gtk_widget_set_sensitive(g_messages.send_button, can_send && !g_messages.sending);++ const char* reason = nullptr;+ if (g_messages.sending)+ reason = "Sending…";+ else if (!g_messages.map_open)+ reason = "Messages are not connected.";+ else if (g_messages.selected_thread.empty())+ reason = "Select a conversation first.";+ else if (!g_messages.selected_block_reason.empty())+ reason = g_messages.selected_block_reason.c_str();+ else if (!can_send)+ reason = "Replying to this conversation is not available.";+ gtk_widget_set_tooltip_text(g_messages.send_button, reason);+ }++ std::string composer_text() {+ GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(g_messages.composer));+ GtkTextIter start, end;+ gtk_text_buffer_get_bounds(buffer, &start, &end);+ gchar* text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);+ std::string out = text ? text : "";+ g_free(text);+ return out;+ }++ void on_send_clicked(GtkWidget*, gpointer) {+ const std::string body = composer_text();+ if (body.empty() || g_messages.selected_thread.empty())+ return;++ nlohmann::json j;+ j["command"] = "bt_send_message";+ j["thread"] = g_messages.selected_thread;+ j["body"] = body;+ daemon_send(j);++ // The composer stays locked until the phone answers. Sending is a+ // real OBEX transfer and takes a moment; an unlocked box invites a+ // second copy of the same message.+ g_messages.sending = true;+ update_composer_sensitivity();+ set_status_main("Sending…");+ }++ void on_send_result(const nlohmann::json& event) {+ g_messages.sending = false;+ update_composer_sensitivity();++ if (event.value("success", false)) {+ // Only cleared once the phone accepted it, so a failed send+ // leaves the text where the user can retry or copy it out.+ GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(g_messages.composer));+ gtk_text_buffer_set_text(buffer, "", -1);+ set_status_main("Sent");+ return;+ }+ set_status_main(event.value("message", "The message was not sent."));+ }++ void on_thread_selected(GtkListBox*, GtkListBoxRow* row, gpointer) {+ if (!row) {+ g_messages.selected_thread.clear();+ g_messages.selected_repliable = false;+ g_messages.selected_block_reason.clear();+ update_composer_sensitivity();+ return;+ }+ const char* thread = (const char*)g_object_get_data(G_OBJECT(row), "thread");+ const char* name = (const char*)g_object_get_data(G_OBJECT(row), "name");+ const char* block_reason = (const char*)g_object_get_data(G_OBJECT(row), "reply_reason");+ g_messages.selected_thread = thread ? thread : "";+ g_messages.selected_name = name ? name : "";+ g_messages.selected_repliable = g_object_get_data(G_OBJECT(row), "repliable") != nullptr;+ g_messages.selected_block_reason = block_reason ? block_reason : "";+ update_composer_sensitivity();+ gtk_stack_set_visible_child_name(GTK_STACK(g_messages.placeholder_stack), "conversation");+ request_messages(g_messages.selected_thread);+ }++ } // namespace++ void messages_view_set_visible(bool visible) {+ g_messages.visible = visible;+ if (visible)+ request_threads();+ }++ bool messages_view_handle_event(const nlohmann::json& event) {+ const std::string command = event.value("command", "");+ if (command == "bt_threads") {+ show_threads(event);+ return true;+ }+ if (command == "bt_messages") {+ show_messages(event);+ return true;+ }+ if (command == "bt_connection_changed") {+ update_connection(event);+ return true;+ }+ if (command == "bt_message") {+ // A new message changes both the thread list and, when it lands in+ // the open conversation, the conversation itself. Refreshing while+ // the view is hidden would just be traffic nobody sees; switching+ // back re-reads everything anyway.+ if (!g_messages.visible)+ return true;+ request_threads();+ if (event.value("thread", "") == g_messages.selected_thread)+ request_messages(g_messages.selected_thread);+ return true;+ }+ if (command == "bt_send_result") {+ on_send_result(event);+ return true;+ }+ if (command == "bt_message_read") {+ if (g_messages.visible)+ request_threads();+ return true;+ }+ return false;+ }++ GtkWidget* messages_view_new() {+ GtkWidget* root = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);++ g_messages.banner = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);+ gtk_container_set_border_width(GTK_CONTAINER(g_messages.banner), 8);+ GtkWidget* banner_icon = gtk_image_new_from_icon_name("dialog-information-symbolic", GTK_ICON_SIZE_BUTTON);+ gtk_box_pack_start(GTK_BOX(g_messages.banner), banner_icon, FALSE, FALSE, 0);+ g_messages.banner_label = gtk_label_new(nullptr);+ gtk_label_set_xalign(GTK_LABEL(g_messages.banner_label), 0.0);+ gtk_label_set_line_wrap(GTK_LABEL(g_messages.banner_label), TRUE);+ gtk_box_pack_start(GTK_BOX(g_messages.banner), g_messages.banner_label, TRUE, TRUE, 0);+ gtk_box_pack_start(GTK_BOX(root), g_messages.banner, FALSE, FALSE, 0);++ GtkWidget* paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);+ gtk_box_pack_start(GTK_BOX(root), paned, TRUE, TRUE, 0);++ GtkWidget* thread_scroll = gtk_scrolled_window_new(nullptr, nullptr);+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(thread_scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);+ gtk_widget_set_size_request(thread_scroll, 240, -1);+ g_messages.thread_list = gtk_list_box_new();+ g_signal_connect(g_messages.thread_list, "row-selected", G_CALLBACK(on_thread_selected), nullptr);+ gtk_container_add(GTK_CONTAINER(thread_scroll), g_messages.thread_list);+ gtk_paned_pack1(GTK_PANED(paned), thread_scroll, FALSE, FALSE);++ g_messages.placeholder_stack = gtk_stack_new();++ GtkWidget* placeholder = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);+ gtk_widget_set_valign(placeholder, GTK_ALIGN_CENTER);+ gtk_widget_set_halign(placeholder, GTK_ALIGN_CENTER);+ GtkWidget* placeholder_icon = gtk_image_new_from_icon_name("mail-unread-symbolic", GTK_ICON_SIZE_DIALOG);+ gtk_box_pack_start(GTK_BOX(placeholder), placeholder_icon, FALSE, FALSE, 0);+ GtkWidget* placeholder_label = gtk_label_new("Select a conversation");+ gtk_style_context_add_class(gtk_widget_get_style_context(placeholder_label), "muted");+ gtk_box_pack_start(GTK_BOX(placeholder), placeholder_label, FALSE, FALSE, 0);+ gtk_stack_add_named(GTK_STACK(g_messages.placeholder_stack), placeholder, "placeholder");++ GtkWidget* conversation_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);++ g_messages.conversation_scroll = gtk_scrolled_window_new(nullptr, nullptr);+ gtk_scrolled_window_set_policy(+ GTK_SCROLLED_WINDOW(g_messages.conversation_scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);+ g_messages.conversation = gtk_list_box_new();+ gtk_list_box_set_selection_mode(GTK_LIST_BOX(g_messages.conversation), GTK_SELECTION_NONE);+ gtk_container_add(GTK_CONTAINER(g_messages.conversation_scroll), g_messages.conversation);+ gtk_box_pack_start(GTK_BOX(conversation_box), g_messages.conversation_scroll, TRUE, TRUE, 0);++ GtkWidget* composer_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);+ gtk_container_set_border_width(GTK_CONTAINER(composer_box), 8);+ g_messages.composer = gtk_text_view_new();+ gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(g_messages.composer), GTK_WRAP_WORD_CHAR);+ gtk_widget_set_size_request(g_messages.composer, -1, 48);+ GtkWidget* composer_frame = gtk_scrolled_window_new(nullptr, nullptr);+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(composer_frame), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);+ gtk_container_add(GTK_CONTAINER(composer_frame), g_messages.composer);+ gtk_box_pack_start(GTK_BOX(composer_box), composer_frame, TRUE, TRUE, 0);++ g_messages.send_button = gtk_button_new_with_label("Send");+ gtk_widget_set_valign(g_messages.send_button, GTK_ALIGN_END);+ gtk_box_pack_start(GTK_BOX(composer_box), g_messages.send_button, FALSE, FALSE, 0);++ g_signal_connect(g_messages.send_button, "clicked", G_CALLBACK(on_send_clicked), nullptr);+ // Enabled only once MAP is up and a conversation is open.+ update_composer_sensitivity();++ gtk_box_pack_start(GTK_BOX(conversation_box), composer_box, FALSE, FALSE, 0);+ gtk_stack_add_named(GTK_STACK(g_messages.placeholder_stack), conversation_box, "conversation");++ gtk_paned_pack2(GTK_PANED(paned), g_messages.placeholder_stack, TRUE, FALSE);+ gtk_stack_set_visible_child_name(GTK_STACK(g_messages.placeholder_stack), "placeholder");++ gtk_widget_set_no_show_all(g_messages.banner, TRUE);+ return root;+ }++} // namespace tether::uidiff --git a/src/gtk/messages_view.hpp b/src/gtk/messages_view.hppnew file mode 100644index 0000000..40b3563--- /dev/null+++ b/src/gtk/messages_view.hpp@@ -0,0 +1,19 @@+#pragma once++#include <gtk/gtk.h>+#include <nlohmann/json.hpp>++namespace tether::ui {++ // Conversations from the iPhone over MAP: a thread list beside the selected+ // conversation, with a composer that stays disabled until sending exists.+ GtkWidget* messages_view_new();++ // Returns true when the event belonged to this view.+ bool messages_view_handle_event(const nlohmann::json& event);++ // Threads are only pulled while someone is looking at them, so the view has+ // to be told when it comes and goes.+ void messages_view_set_visible(bool visible);++} // namespace tether::uidiff --git a/src/gtk/notifications_view.cpp b/src/gtk/notifications_view.cppnew file mode 100644index 0000000..d2344e6--- /dev/null+++ b/src/gtk/notifications_view.cpp@@ -0,0 +1,155 @@+#include "notifications_view.hpp"+#include "daemon_client.hpp"+#include "ui_util.hpp"++#include <ctime>+#include <string>++namespace tether::ui {++ namespace {++ struct NotificationsState {+ GtkWidget* status_label = nullptr;+ GtkWidget* list = nullptr;+ GtkWidget* stack = nullptr;+ bool visible = false;+ bool ready = false;+ };++ NotificationsState g_notifications;++ std::string format_timestamp(int64_t epoch) {+ if (epoch <= 0)+ return "";+ std::time_t t = static_cast<std::time_t>(epoch);+ std::tm tm{};+ localtime_r(&t, &tm);+ char buffer[32];+ std::strftime(buffer, sizeof(buffer), "%H:%M", &tm);+ return buffer;+ }++ void request_notifications() {+ nlohmann::json j;+ j["command"] = "bt_list_notifications";+ daemon_send(j);+ }++ GtkWidget* build_row(const nlohmann::json& notification) {+ const std::string app = notification.value("app_name", notification.value("app_id", ""));+ const std::string title = notification.value("title", "");+ const std::string body = notification.value("body", "");+ const std::string stamp = format_timestamp(notification.value("timestamp", static_cast<int64_t>(0)));++ GtkWidget* row = gtk_list_box_row_new();+ gtk_list_box_row_set_selectable(GTK_LIST_BOX_ROW(row), FALSE);++ GtkWidget* box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);+ gtk_container_set_border_width(GTK_CONTAINER(box), 10);++ GtkWidget* header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);+ GtkWidget* app_label = gtk_label_new(nullptr);+ gtk_label_set_markup(GTK_LABEL(app_label), ("<b>" + escape_markup(app) + "</b>").c_str());+ gtk_label_set_xalign(GTK_LABEL(app_label), 0.0);+ gtk_box_pack_start(GTK_BOX(header), app_label, TRUE, TRUE, 0);++ if (!stamp.empty()) {+ GtkWidget* time_label = gtk_label_new(stamp.c_str());+ gtk_style_context_add_class(gtk_widget_get_style_context(time_label), "muted");+ gtk_box_pack_start(GTK_BOX(header), time_label, FALSE, FALSE, 0);+ }+ gtk_box_pack_start(GTK_BOX(box), header, FALSE, FALSE, 0);++ // With content mirroring off, only the app is known — which is the+ // point of that default, so the row says so rather than looking broken.+ const std::string detail = !title.empty() ? title : (!body.empty() ? body : "New notification");+ GtkWidget* detail_label = gtk_label_new(detail.c_str());+ gtk_label_set_xalign(GTK_LABEL(detail_label), 0.0);+ gtk_label_set_line_wrap(GTK_LABEL(detail_label), TRUE);+ gtk_box_pack_start(GTK_BOX(box), detail_label, FALSE, FALSE, 0);++ if (!title.empty() && !body.empty()) {+ GtkWidget* body_label = gtk_label_new(body.c_str());+ gtk_label_set_xalign(GTK_LABEL(body_label), 0.0);+ gtk_label_set_line_wrap(GTK_LABEL(body_label), TRUE);+ gtk_style_context_add_class(gtk_widget_get_style_context(body_label), "muted");+ gtk_box_pack_start(GTK_BOX(box), body_label, FALSE, FALSE, 0);+ }++ gtk_container_add(GTK_CONTAINER(row), box);+ return row;+ }++ void show_notifications(const nlohmann::json& event) {+ clear_list_box(g_notifications.list);+ const bool empty = !event.contains("notifications") || event["notifications"].empty();+ if (!empty) {+ for (const auto& notification : event["notifications"])+ gtk_list_box_insert(GTK_LIST_BOX(g_notifications.list), build_row(notification), -1);+ }+ gtk_widget_show_all(g_notifications.list);+ gtk_stack_set_visible_child_name(GTK_STACK(g_notifications.stack), empty ? "status" : "list");+ }++ } // namespace++ void notifications_view_set_visible(bool visible) {+ g_notifications.visible = visible;+ if (visible)+ request_notifications();+ }++ bool notifications_view_handle_event(const nlohmann::json& event) {+ const std::string command = event.value("command", "");++ if (command == "bt_notifications") {+ show_notifications(event);+ return true;+ }+ if (command == "bt_notification" || command == "bt_notification_removed") {+ if (g_notifications.visible)+ request_notifications();+ return true;+ }+ if (command == "bt_connection_changed") {+ g_notifications.ready = event.value("ancs_ready", false);+ // The daemon's reason names the actual next step, including the+ // toggle to enable on the phone, so it is shown verbatim.+ const std::string reason = event.value("ancs_reason", "");+ set_text(g_notifications.status_label,+ g_notifications.ready ? "No notifications yet."+ : (reason.empty() ? "Notification mirroring is unavailable." : reason));+ return false;+ }+ return false;+ }++ GtkWidget* notifications_view_new() {+ g_notifications.stack = gtk_stack_new();++ GtkWidget* status_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);+ gtk_widget_set_valign(status_box, GTK_ALIGN_CENTER);+ gtk_widget_set_halign(status_box, GTK_ALIGN_CENTER);+ GtkWidget* icon =+ gtk_image_new_from_icon_name("preferences-system-notifications-symbolic", GTK_ICON_SIZE_DIALOG);+ gtk_box_pack_start(GTK_BOX(status_box), icon, FALSE, FALSE, 0);+ g_notifications.status_label = gtk_label_new("Waiting for the iPhone.");+ gtk_label_set_line_wrap(GTK_LABEL(g_notifications.status_label), TRUE);+ gtk_label_set_justify(GTK_LABEL(g_notifications.status_label), GTK_JUSTIFY_CENTER);+ gtk_style_context_add_class(gtk_widget_get_style_context(g_notifications.status_label), "muted");+ gtk_box_pack_start(GTK_BOX(status_box), g_notifications.status_label, FALSE, FALSE, 0);+ gtk_stack_add_named(GTK_STACK(g_notifications.stack), status_box, "status");++ GtkWidget* scroll = gtk_scrolled_window_new(nullptr, nullptr);+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);+ g_notifications.list = gtk_list_box_new();+ gtk_list_box_set_selection_mode(GTK_LIST_BOX(g_notifications.list), GTK_SELECTION_NONE);+ gtk_container_add(GTK_CONTAINER(scroll), g_notifications.list);+ gtk_stack_add_named(GTK_STACK(g_notifications.stack), scroll, "list");++ gtk_stack_set_visible_child_name(GTK_STACK(g_notifications.stack), "status");+ return g_notifications.stack;+ }++} // namespace tether::uidiff --git a/src/gtk/notifications_view.hpp b/src/gtk/notifications_view.hppnew file mode 100644index 0000000..4275b64--- /dev/null+++ b/src/gtk/notifications_view.hpp@@ -0,0 +1,16 @@+#pragma once++#include <gtk/gtk.h>+#include <nlohmann/json.hpp>++namespace tether::ui {++ // Mirrored iPhone notifications, delivered over ANCS.+ GtkWidget* notifications_view_new();++ bool notifications_view_handle_event(const nlohmann::json& event);++ // Notifications are only re-read while the view is on screen.+ void notifications_view_set_visible(bool visible);++} // namespace tether::uidiff --git a/src/gtk/ui_util.cpp b/src/gtk/ui_util.cppnew file mode 100644index 0000000..7dffe2a--- /dev/null+++ b/src/gtk/ui_util.cpp@@ -0,0 +1,49 @@+#include "ui_util.hpp"++namespace tether::ui {++ namespace {+ GtkWidget* g_window = nullptr;+ GtkWidget* g_header_bar = nullptr;+ } // namespace++ std::string escape_markup(const std::string& text) {+ gchar* escaped = g_markup_escape_text(text.c_str(), -1);+ std::string result = escaped ? escaped : "";+ g_free(escaped);+ return result;+ }++ void set_markup(GtkWidget* label, const std::string& text) {+ if (label) {+ gtk_label_set_markup(GTK_LABEL(label), text.c_str());+ }+ }++ void set_text(GtkWidget* label, const std::string& text) {+ if (label) {+ gtk_label_set_text(GTK_LABEL(label), text.c_str());+ }+ }++ void clear_list_box(GtkWidget* list_box) {+ GList* children = gtk_container_get_children(GTK_CONTAINER(list_box));+ for (GList* iter = children; iter; iter = g_list_next(iter)) {+ gtk_widget_destroy(GTK_WIDGET(iter->data));+ }+ g_list_free(children);+ }++ void set_main_window(GtkWidget* window) { g_window = window; }++ GtkWidget* main_window() { return g_window; }++ void set_header_bar(GtkWidget* bar) { g_header_bar = bar; }++ void set_status_main(const std::string& text) {+ if (g_header_bar) {+ gtk_header_bar_set_subtitle(GTK_HEADER_BAR(g_header_bar), text.c_str());+ }+ }++} // namespace tether::uidiff --git a/src/gtk/ui_util.hpp b/src/gtk/ui_util.hppnew file mode 100644index 0000000..a298715--- /dev/null+++ b/src/gtk/ui_util.hpp@@ -0,0 +1,20 @@+#pragma once++#include <gtk/gtk.h>+#include <string>++namespace tether::ui {++ std::string escape_markup(const std::string& text);+ void set_markup(GtkWidget* label, const std::string& text);+ void set_text(GtkWidget* label, const std::string& text);+ void clear_list_box(GtkWidget* list_box);++ // Registered once at startup so views can reach the window and the header+ // bar without every one of them holding the whole application struct.+ void set_main_window(GtkWidget* window);+ GtkWidget* main_window();+ void set_header_bar(GtkWidget* bar);+ void set_status_main(const std::string& text);++} // namespace tether::uidiff --git a/test/CMakeLists.txt b/test/CMakeLists.txtindex 72f34d2..75ca1ac 100644--- a/test/CMakeLists.txt+++ b/test/CMakeLists.txt@@ -1,5 +1,16 @@add_executable(tether_testtest_base64.cpp+ test_bluetooth_objects.cpp+ test_bluetooth_pairing.cpp+ test_bluetooth_supervisor.cpp+ test_bmessage.cpp+ test_bmessage_build.cpp+ test_ancs_parser.cpp+ test_ancs_sequencer.cpp+ test_groups.cpp+ test_bt_diagnostics.cpp+ test_vcard.cpp+ test_journal.cpptest_crypto.cpptest_discovery.cpptest_file_transfer.cppdiff --git a/test/test_ancs_parser.cpp b/test/test_ancs_parser.cppnew file mode 100644index 0000000..8069b6c--- /dev/null+++ b/test/test_ancs_parser.cpp@@ -0,0 +1,260 @@+#include <gtest/gtest.h>+#include <tether/bluetooth/ancs/parser.hpp>++using namespace tether::bluetooth::ancs;++namespace {++ std::vector<uint8_t> source_packet(uint8_t event, uint8_t flags, uint8_t category, uint8_t count, uint32_t uid) {+ return {event,+ flags,+ category,+ count,+ static_cast<uint8_t>(uid & 0xff),+ static_cast<uint8_t>((uid >> 8) & 0xff),+ static_cast<uint8_t>((uid >> 16) & 0xff),+ static_cast<uint8_t>((uid >> 24) & 0xff)};+ }++ void append_attribute(std::vector<uint8_t>& out, uint8_t id, const std::string& value) {+ out.push_back(id);+ out.push_back(static_cast<uint8_t>(value.size() & 0xff));+ out.push_back(static_cast<uint8_t>((value.size() >> 8) & 0xff));+ out.insert(out.end(), value.begin(), value.end());+ }++ std::vector<uint8_t> notification_response(uint32_t uid) {+ std::vector<uint8_t> out{0x00,+ static_cast<uint8_t>(uid & 0xff),+ static_cast<uint8_t>((uid >> 8) & 0xff),+ static_cast<uint8_t>((uid >> 16) & 0xff),+ static_cast<uint8_t>((uid >> 24) & 0xff)};+ append_attribute(out, 0, "com.example.app");+ append_attribute(out, 1, "Title here");+ return out;+ }++ DataSourceAssembler::Result feed(DataSourceAssembler& assembler,+ const std::vector<uint8_t>& bytes,+ Response& out,+ std::string& err) {+ return assembler.append(bytes.data(), bytes.size(), out, err);+ }++} // namespace++// --- Notification Source -------------------------------------------------++TEST(AncsParser, ParsesASourceEvent) {+ SourceEvent event;+ auto packet = source_packet(0, FlagImportant | FlagPositiveAction, 4, 2, 0xDEADBEEF);++ ASSERT_TRUE(parse_source_event(packet.data(), packet.size(), event));+ EXPECT_EQ(event.event, EventId::Added);+ EXPECT_EQ(event.category, CategoryId::Social);+ EXPECT_EQ(event.category_count, 2);+ EXPECT_EQ(event.uid, 0xDEADBEEFu);+ EXPECT_TRUE(event.has_positive_action());+ EXPECT_FALSE(event.pre_existing());+}++// A truncated packet would leave fields to be invented, and the UID is what+// every later request is keyed on — so anything but eight bytes is refused.+TEST(AncsParser, RejectsSourcePacketsOfTheWrongLength) {+ SourceEvent event;+ auto packet = source_packet(0, 0, 0, 0, 1);++ EXPECT_FALSE(parse_source_event(packet.data(), 7, event));+ EXPECT_FALSE(parse_source_event(packet.data(), 9, event));+ EXPECT_FALSE(parse_source_event(packet.data(), 0, event));+ EXPECT_FALSE(parse_source_event(nullptr, 8, event));+}++TEST(AncsParser, RejectsUnknownEventIds) {+ SourceEvent event;+ auto packet = source_packet(9, 0, 0, 0, 1);+ EXPECT_FALSE(parse_source_event(packet.data(), packet.size(), event));+}++// --- Data Source reassembly ----------------------------------------------++TEST(AncsParser, ReassemblesACompleteResponse) {+ DataSourceAssembler assembler;+ assembler.expect(CommandId::GetNotificationAttributes, {0, 1});++ Response response;+ std::string err;+ ASSERT_EQ(feed(assembler, notification_response(42), response, err), DataSourceAssembler::Result::Complete) << err;+ EXPECT_EQ(response.uid, 42u);+ EXPECT_EQ(response.attribute(0), "com.example.app");+ EXPECT_EQ(response.attribute(1), "Title here");+ EXPECT_FALSE(assembler.expecting());+}++// Responses have no total length and arrive split across GATT notifications, so+// completion can only be recognized from the requested attribute sequence.+TEST(AncsParser, ReassemblesAcrossArbitraryFragmentBoundaries) {+ const auto full = notification_response(7);++ for (size_t split = 1; split < full.size(); ++split) {+ DataSourceAssembler assembler;+ assembler.expect(CommandId::GetNotificationAttributes, {0, 1});++ Response response;+ std::string err;+ std::vector<uint8_t> first(full.begin(), full.begin() + static_cast<long>(split));+ std::vector<uint8_t> second(full.begin() + static_cast<long>(split), full.end());++ ASSERT_EQ(feed(assembler, first, response, err), DataSourceAssembler::Result::NeedMore)+ << "split at " << split << ": " << err;+ ASSERT_EQ(feed(assembler, second, response, err), DataSourceAssembler::Result::Complete)+ << "split at " << split << ": " << err;+ EXPECT_EQ(response.attribute(1), "Title here");+ }+}++TEST(AncsParser, ReassemblesOneByteAtATime) {+ const auto full = notification_response(9);+ DataSourceAssembler assembler;+ assembler.expect(CommandId::GetNotificationAttributes, {0, 1});++ Response response;+ std::string err;+ for (size_t i = 0; i + 1 < full.size(); ++i)+ ASSERT_EQ(assembler.append(&full[i], 1, response, err), DataSourceAssembler::Result::NeedMore) << i;+ EXPECT_EQ(assembler.append(&full.back(), 1, response, err), DataSourceAssembler::Result::Complete) << err;+}++TEST(AncsParser, ParsesAppAttributeResponses) {+ DataSourceAssembler assembler;+ assembler.expect(CommandId::GetAppAttributes, {0});++ std::vector<uint8_t> bytes{0x01};+ const std::string app = "com.apple.MobileSMS";+ bytes.insert(bytes.end(), app.begin(), app.end());+ bytes.push_back(0);+ append_attribute(bytes, 0, "Messages");++ Response response;+ std::string err;+ ASSERT_EQ(feed(assembler, bytes, response, err), DataSourceAssembler::Result::Complete) << err;+ EXPECT_EQ(response.app_id, "com.apple.MobileSMS");+ EXPECT_EQ(response.attribute(0), "Messages");+}++TEST(AncsParser, WaitsForAnUnterminatedAppIdentifier) {+ DataSourceAssembler assembler;+ assembler.expect(CommandId::GetAppAttributes, {0});++ std::vector<uint8_t> bytes{0x01, 'c', 'o', 'm'};+ Response response;+ std::string err;+ EXPECT_EQ(feed(assembler, bytes, response, err), DataSourceAssembler::Result::NeedMore);+}++// --- Hostile input -------------------------------------------------------++TEST(AncsParser, RejectsAResponseThatDoesNotEchoTheCommand) {+ DataSourceAssembler assembler;+ assembler.expect(CommandId::GetNotificationAttributes, {0});++ std::vector<uint8_t> bytes{0x07, 0, 0, 0, 0};+ Response response;+ std::string err;+ EXPECT_EQ(feed(assembler, bytes, response, err), DataSourceAssembler::Result::Error);+ EXPECT_FALSE(err.empty());+}++TEST(AncsParser, RejectsAttributesReturnedOutOfOrder) {+ DataSourceAssembler assembler;+ assembler.expect(CommandId::GetNotificationAttributes, {0, 1});++ std::vector<uint8_t> bytes{0x00, 1, 0, 0, 0};+ append_attribute(bytes, 3, "wrong attribute");++ Response response;+ std::string err;+ EXPECT_EQ(feed(assembler, bytes, response, err), DataSourceAssembler::Result::Error);+}++// A length field is two bytes and can claim far more than we ever ask for.+// Believing it would let a peer make us buffer for as long as it likes.+TEST(AncsParser, RejectsAnImplausibleAttributeLength) {+ DataSourceAssembler assembler;+ assembler.expect(CommandId::GetNotificationAttributes, {0});++ std::vector<uint8_t> bytes{0x00, 1, 0, 0, 0, 0, 0xff, 0xff};+ Response response;+ std::string err;+ EXPECT_EQ(feed(assembler, bytes, response, err), DataSourceAssembler::Result::Error);+}++TEST(AncsParser, RejectsTrailingBytesAfterACompleteResponse) {+ DataSourceAssembler assembler;+ assembler.expect(CommandId::GetNotificationAttributes, {0, 1});++ auto bytes = notification_response(3);+ bytes.push_back(0xAA);+ bytes.push_back(0xBB);++ Response response;+ std::string err;+ EXPECT_EQ(feed(assembler, bytes, response, err), DataSourceAssembler::Result::Error);+}++TEST(AncsParser, RejectsAResponseThatGrowsWithoutEnding) {+ DataSourceAssembler assembler;+ assembler.expect(CommandId::GetNotificationAttributes, {0, 1, 2, 3});++ Response response;+ std::string err;+ std::vector<uint8_t> flood(1024, 0);+ flood[0] = 0x00;++ DataSourceAssembler::Result result = DataSourceAssembler::Result::NeedMore;+ for (int i = 0; i < 16 && result == DataSourceAssembler::Result::NeedMore; ++i)+ result = feed(assembler, flood, response, err);++ EXPECT_EQ(result, DataSourceAssembler::Result::Error) << "an endless response must be cut off";+}++TEST(AncsParser, RefusesFragmentsWithNoRequestInFlight) {+ DataSourceAssembler assembler;+ Response response;+ std::string err;++ auto bytes = notification_response(1);+ EXPECT_EQ(feed(assembler, bytes, response, err), DataSourceAssembler::Result::Error);+}++// A rejected response must not leave half-parsed state behind for the next one+// to inherit.+TEST(AncsParser, RecoversAfterAnError) {+ DataSourceAssembler assembler;+ assembler.expect(CommandId::GetNotificationAttributes, {0, 1});++ Response response;+ std::string err;+ std::vector<uint8_t> garbage{0x09, 0x09};+ ASSERT_EQ(feed(assembler, garbage, response, err), DataSourceAssembler::Result::Error);+ EXPECT_FALSE(assembler.expecting());++ assembler.expect(CommandId::GetNotificationAttributes, {0, 1});+ EXPECT_EQ(feed(assembler, notification_response(5), response, err), DataSourceAssembler::Result::Complete) << err;+ EXPECT_EQ(response.uid, 5u);+}++TEST(AncsParser, HandlesEmptyAttributeValues) {+ DataSourceAssembler assembler;+ assembler.expect(CommandId::GetNotificationAttributes, {0, 1});++ std::vector<uint8_t> bytes{0x00, 4, 0, 0, 0};+ append_attribute(bytes, 0, "com.example.app");+ append_attribute(bytes, 1, "");++ Response response;+ std::string err;+ ASSERT_EQ(feed(assembler, bytes, response, err), DataSourceAssembler::Result::Complete) << err;+ EXPECT_EQ(response.attribute(1), "") << "an absent attribute is still a tuple";+ EXPECT_EQ(response.attributes.size(), 2u);+}diff --git a/test/test_ancs_sequencer.cpp b/test/test_ancs_sequencer.cppnew file mode 100644index 0000000..741dd03--- /dev/null+++ b/test/test_ancs_sequencer.cpp@@ -0,0 +1,305 @@+#include <gtest/gtest.h>+#include <tether/bluetooth/ancs/notifications.hpp>+#include <tether/bluetooth/ancs/sequencer.hpp>++using namespace tether::bluetooth::ancs;++namespace {++ struct Harness {+ std::vector<std::vector<uint8_t>> writes;+ std::vector<std::pair<Request, Response>> completions;+ std::vector<std::pair<Request, std::string>> failures;+ bool write_succeeds = true;++ ControlPointSequencer make() {+ return ControlPointSequencer([this](const std::vector<uint8_t>& payload) {+ writes.push_back(payload);+ return write_succeeds;+ },+ [this](const Request& request, const Response& response) {+ completions.emplace_back(request, response);+ },+ [this](const Request& request, const std::string& reason) {+ failures.emplace_back(request, reason);+ });+ }+ };++ std::vector<uint8_t> notification_response(uint32_t uid, const std::string& app) {+ std::vector<uint8_t> out{0x00,+ static_cast<uint8_t>(uid & 0xff),+ static_cast<uint8_t>((uid >> 8) & 0xff),+ static_cast<uint8_t>((uid >> 16) & 0xff),+ static_cast<uint8_t>((uid >> 24) & 0xff)};+ out.push_back(0);+ out.push_back(static_cast<uint8_t>(app.size() & 0xff));+ out.push_back(static_cast<uint8_t>((app.size() >> 8) & 0xff));+ out.insert(out.end(), app.begin(), app.end());+ return out;+ }++ SourceEvent event_for(uint32_t uid, EventId event = EventId::Added, uint8_t flags = 0) {+ SourceEvent e;+ e.uid = uid;+ e.event = event;+ e.flags = flags;+ return e;+ }++} // namespace++// --- Request encoding ----------------------------------------------------++TEST(AncsSequencer, EncodesANotificationRequest) {+ Request request = build_notification_request(0x01020304, {NotificationAttributeId::AppIdentifier,+ NotificationAttributeId::Message});++ ASSERT_GE(request.payload.size(), 8u);+ EXPECT_EQ(request.payload[0], 0x00);+ EXPECT_EQ(request.payload[1], 0x04) << "the UID is little-endian";+ EXPECT_EQ(request.payload[4], 0x01);+ EXPECT_EQ(request.payload[5], 0x00) << "AppIdentifier takes no length";+ EXPECT_EQ(request.payload[6], 0x03) << "Message follows immediately";+ // Message is length-capped, and the cap is what Phase 9 correlates against.+ EXPECT_EQ(request.payload[7] | (request.payload[8] << 8), MAX_BODY_LENGTH);+ EXPECT_EQ(request.attribute_ids, (std::vector<uint8_t>{0, 3}));+}++TEST(AncsSequencer, EncodesAnAppRequest) {+ Request request = build_app_request("com.apple.MobileSMS");++ EXPECT_EQ(request.payload[0], 0x01);+ EXPECT_EQ(request.payload[request.payload.size() - 2], 0x00) << "the identifier is NUL-terminated";+ EXPECT_EQ(request.payload.back(), 0x00) << "DisplayName is the requested attribute";+}++TEST(AncsSequencer, EncodesAnActionRequest) {+ Request request = build_action_request(0x11223344, ActionId::Negative);++ EXPECT_EQ(request.payload[0], 0x02);+ EXPECT_EQ(request.payload.back(), 0x01);+ EXPECT_TRUE(request.attribute_ids.empty()) << "an action expects no response";+}++// --- Serialization -------------------------------------------------------++// Responses carry no request identifier, so two in flight cannot be told apart+// and one notification's attributes would be attached to another.+TEST(AncsSequencer, KeepsExactlyOneRequestInFlight) {+ Harness harness;+ auto sequencer = harness.make();++ sequencer.submit(build_notification_request(1, {NotificationAttributeId::AppIdentifier}));+ sequencer.submit(build_notification_request(2, {NotificationAttributeId::AppIdentifier}));+ sequencer.submit(build_notification_request(3, {NotificationAttributeId::AppIdentifier}));+ sequencer.tick(0);++ EXPECT_EQ(harness.writes.size(), 1u);+ EXPECT_EQ(sequencer.queued(), 2u);+ EXPECT_TRUE(sequencer.in_flight());++ auto bytes = notification_response(1, "com.example.one");+ sequencer.on_data_source(bytes.data(), bytes.size(), 1);++ EXPECT_EQ(harness.completions.size(), 1u);+ EXPECT_EQ(harness.completions[0].first.uid, 1u);+ EXPECT_EQ(harness.writes.size(), 2u) << "the next request starts as soon as the first completes";+}++TEST(AncsSequencer, MatchesEachResponseToItsOwnRequest) {+ Harness harness;+ auto sequencer = harness.make();++ sequencer.submit(build_notification_request(11, {NotificationAttributeId::AppIdentifier}));+ sequencer.submit(build_notification_request(22, {NotificationAttributeId::AppIdentifier}));+ sequencer.tick(0);++ auto first = notification_response(11, "com.example.first");+ sequencer.on_data_source(first.data(), first.size(), 1);+ auto second = notification_response(22, "com.example.second");+ sequencer.on_data_source(second.data(), second.size(), 2);++ ASSERT_EQ(harness.completions.size(), 2u);+ EXPECT_EQ(harness.completions[0].first.uid, 11u);+ EXPECT_EQ(harness.completions[0].second.attribute(0), "com.example.first");+ EXPECT_EQ(harness.completions[1].first.uid, 22u);+ EXPECT_EQ(harness.completions[1].second.attribute(0), "com.example.second");+}++// An action gets no Data Source response at all, so waiting for one would stall+// every queued request behind it for the full timeout.+TEST(AncsSequencer, DoesNotWaitForAResponseToAnAction) {+ Harness harness;+ auto sequencer = harness.make();++ sequencer.submit(build_action_request(5, ActionId::Positive));+ sequencer.submit(build_notification_request(6, {NotificationAttributeId::AppIdentifier}));+ sequencer.tick(0);++ EXPECT_EQ(harness.writes.size(), 2u);+ EXPECT_EQ(harness.completions.size(), 1u);+ EXPECT_TRUE(sequencer.in_flight()) << "the notification request is the one now waiting";+}++TEST(AncsSequencer, TimesOutARequestThatIsNeverAnswered) {+ Harness harness;+ auto sequencer = harness.make();++ sequencer.submit(build_notification_request(1, {NotificationAttributeId::AppIdentifier}));+ sequencer.submit(build_notification_request(2, {NotificationAttributeId::AppIdentifier}));+ sequencer.tick(0);+ ASSERT_EQ(harness.writes.size(), 1u);++ sequencer.tick(REQUEST_TIMEOUT_SECONDS - 1);+ EXPECT_TRUE(harness.failures.empty()) << "not yet due";++ sequencer.tick(REQUEST_TIMEOUT_SECONDS);+ ASSERT_EQ(harness.failures.size(), 1u);+ EXPECT_EQ(harness.failures[0].first.uid, 1u);+ EXPECT_EQ(harness.writes.size(), 2u) << "the queue must not stay wedged behind a lost response";+}++TEST(AncsSequencer, FailsARequestWhoseWriteIsRefused) {+ Harness harness;+ harness.write_succeeds = false;+ auto sequencer = harness.make();++ sequencer.submit(build_notification_request(1, {NotificationAttributeId::AppIdentifier}));+ sequencer.tick(0);++ EXPECT_EQ(harness.failures.size(), 1u);+ EXPECT_FALSE(sequencer.in_flight());+}++TEST(AncsSequencer, FailsTheRequestWhenItsResponseIsMalformed) {+ Harness harness;+ auto sequencer = harness.make();++ sequencer.submit(build_notification_request(1, {NotificationAttributeId::AppIdentifier}));+ sequencer.tick(0);++ std::vector<uint8_t> garbage{0x09, 0x09, 0x09};+ sequencer.on_data_source(garbage.data(), garbage.size(), 1);++ EXPECT_EQ(harness.failures.size(), 1u);+ EXPECT_TRUE(harness.completions.empty());+}++TEST(AncsSequencer, DropsEverythingOnReset) {+ Harness harness;+ auto sequencer = harness.make();++ sequencer.submit(build_notification_request(1, {NotificationAttributeId::AppIdentifier}));+ sequencer.submit(build_notification_request(2, {NotificationAttributeId::AppIdentifier}));+ sequencer.tick(0);+ sequencer.reset();++ EXPECT_FALSE(sequencer.in_flight());+ EXPECT_EQ(sequencer.queued(), 0u);++ // A response from the dead session must not be applied to anything.+ auto bytes = notification_response(1, "com.example.one");+ sequencer.on_data_source(bytes.data(), bytes.size(), 1);+ EXPECT_TRUE(harness.completions.empty());+}++TEST(AncsSequencer, BoundsTheQueue) {+ Harness harness;+ auto sequencer = harness.make();++ size_t accepted = 0;+ for (size_t i = 0; i < MAX_QUEUED_REQUESTS + 10; ++i) {+ if (sequencer.submit(build_notification_request(static_cast<uint32_t>(i),+ {NotificationAttributeId::AppIdentifier})))+ ++accepted;+ }+ EXPECT_EQ(accepted, MAX_QUEUED_REQUESTS) << "a notification burst must not grow the daemon without bound";+}++// --- Delivery rules ------------------------------------------------------++// iOS replays its whole backlog whenever the subscription comes up. Delivering+// it would turn every reconnect into a burst of desktop popups.+TEST(AncsNotifications, SkipsPreExistingOnFirstSubscribe) {+ NotificationRegistry registry;+ auto pre_existing = event_for(1, EventId::Added, FlagPreExisting);++ EXPECT_EQ(registry.classify(pre_existing, true), Decision::Ignore);+ EXPECT_EQ(registry.classify(pre_existing, false), Decision::Fetch)+ << "after the initial sync a pre-existing flag is not a reason to hide it";+}++TEST(AncsNotifications, DedupesRepeatedAddedEvents) {+ NotificationRegistry registry;+ auto added = event_for(7);++ EXPECT_EQ(registry.classify(added, false), Decision::Fetch);+ registry.remember(added);+ EXPECT_EQ(registry.classify(added, false), Decision::Ignore) << "a replay of the same UID is not news";+}++// A modification is a genuine update — a call that became a missed call, a+// message that was edited — so dedupe must not swallow it.+TEST(AncsNotifications, NeverSuppressesAModification) {+ NotificationRegistry registry;+ auto added = event_for(7);+ registry.remember(added);++ EXPECT_EQ(registry.classify(event_for(7, EventId::Modified), false), Decision::Fetch);+}++TEST(AncsNotifications, WithdrawsRemovedNotifications) {+ NotificationRegistry registry;+ auto added = event_for(7);+ registry.remember(added);++ EXPECT_EQ(registry.classify(event_for(7, EventId::Removed), false), Decision::Withdraw);++ registry.forget(7);+ EXPECT_EQ(registry.classify(added, false), Decision::Fetch) << "the UID is free to be seen again";+}++// MAP already delivers these with read state that stays in sync, so an ANCS+// popup would be the second copy of the same message.+TEST(AncsNotifications, SuppressesDesktopPopupsForMessages) {+ Notification messages;+ messages.app_id = "com.apple.MobileSMS";+ EXPECT_FALSE(should_show_desktop_popup(messages));++ Notification other;+ other.app_id = "com.example.chat";+ EXPECT_TRUE(should_show_desktop_popup(other));++ Notification silent;+ silent.app_id = "com.example.chat";+ silent.silent = true;+ EXPECT_FALSE(should_show_desktop_popup(silent)) << "the phone was told to stay quiet about this one";+}++TEST(AncsNotifications, KeepsRecentNotificationsNewestFirst) {+ NotificationRegistry registry;+ for (uint32_t i = 1; i <= 3; ++i) {+ Notification n;+ n.uid = i;+ n.app_id = "com.example.app";+ registry.store(n);+ }++ auto recent = registry.recent();+ ASSERT_EQ(recent.size(), 3u);+ EXPECT_EQ(recent[0].uid, 3u);+ EXPECT_EQ(recent[2].uid, 1u);+}++TEST(AncsNotifications, ClearingForgetsEverything) {+ NotificationRegistry registry;+ Notification n;+ n.uid = 1;+ registry.store(n);+ registry.remember(event_for(1));++ registry.clear();+ EXPECT_EQ(registry.size(), 0u);+ EXPECT_EQ(registry.classify(event_for(1), false), Decision::Fetch);+}diff --git a/test/test_bluetooth_objects.cpp b/test/test_bluetooth_objects.cppnew file mode 100644index 0000000..ef6fe40--- /dev/null+++ b/test/test_bluetooth_objects.cpp@@ -0,0 +1,304 @@+#include <gtest/gtest.h>+#include <tether/bluetooth/objects.hpp>++using namespace tether::bluetooth;++namespace {++ // Builds an ObjectManager payload from GVariant text format, the same shape+ // BlueZ returns from GetManagedObjects. Keeps the tests free of a real bus.+ struct Payload {+ GVariant* v = nullptr;++ explicit Payload(const char* text) {+ GError* error = nullptr;+ v = g_variant_parse(G_VARIANT_TYPE("a{oa{sa{sv}}}"), text, nullptr, nullptr, &error);+ if (!v) {+ ADD_FAILURE() << "bad fixture: " << (error ? error->message : "unknown");+ g_clear_error(&error);+ }+ }+ ~Payload() {+ if (v)+ g_variant_unref(v);+ }+ Payload(const Payload&) = delete;+ Payload& operator=(const Payload&) = delete;+ };++ // A capable adapter: powered, both LE roles, advertising, A/V Hands-Free class.+ constexpr const char* ADAPTER_FULL = R"({+ '/org/bluez/hci0': {+ 'org.bluez.Adapter1': {+ 'Address': <'AC:F2:3C:AF:52:9C'>,+ 'Alias': <'btw'>,+ 'Class': <uint32 8127496>,+ 'Powered': <true>,+ 'Roles': <['central', 'peripheral']>+ },+ 'org.bluez.LEAdvertisingManager1': {+ 'SupportedInstances': <byte 15>+ }+ }+ })";++ // An iPhone bonded on both transports, exposing MAP, PBAP and ANCS.+ constexpr const char* IPHONE_BONDED = R"({+ '/org/bluez/hci0/dev_60_57_C8_30_6A_F7': {+ 'org.bluez.Device1': {+ 'Address': <'60:57:C8:30:6A:F7'>,+ 'Alias': <'Zack 15 Pro'>,+ 'Adapter': <objectpath '/org/bluez/hci0'>,+ 'Paired': <true>,+ 'Bonded': <true>,+ 'Trusted': <true>,+ 'Connected': <true>,+ 'UUIDs': <['00001132-0000-1000-8000-00805f9b34fb',+ '00001133-0000-1000-8000-00805f9b34fb',+ '0000112f-0000-1000-8000-00805f9b34fb',+ '7905f431-b5ce-4e99-a40f-4b1e122d00d0']>+ },+ 'org.bluez.Bearer.LE1': {+ 'Paired': <true>, 'Bonded': <true>, 'Connected': <true>+ }+ }+ })";++ std::string join(const char* a, const char* b) {+ std::string left(a), right(b);+ // Splice two single-entry dictionaries into one.+ left.erase(left.find_last_of('}'));+ right = right.substr(right.find('{') + 1);+ return left + "," + right;+ }++} // namespace++TEST(BluetoothObjects, ParsesAdapterProperties) {+ Payload p(ADAPTER_FULL);+ auto objects = parse_managed_objects(p.v);++ ASSERT_EQ(objects.adapters.size(), 1u);+ const auto& a = objects.adapters[0];+ EXPECT_EQ(a.path, "/org/bluez/hci0");+ EXPECT_EQ(a.address, "AC:F2:3C:AF:52:9C");+ EXPECT_EQ(a.name, "btw");+ EXPECT_TRUE(a.powered);+ EXPECT_TRUE(a.has_role("central"));+ EXPECT_TRUE(a.has_role("peripheral"));+ EXPECT_FALSE(a.has_role("broadcaster"));+ EXPECT_EQ(a.advertising_instances, 15);+ // 8127496 == 0x7c0408: service bits set above an A/V Hands-Free base class.+ EXPECT_TRUE(a.class_is_handsfree());+}++TEST(BluetoothObjects, ParsesDeviceAndBearer) {+ Payload p(IPHONE_BONDED);+ auto objects = parse_managed_objects(p.v);++ ASSERT_EQ(objects.devices.size(), 1u);+ const auto& d = objects.devices[0];+ EXPECT_EQ(d.address, "60:57:C8:30:6A:F7");+ EXPECT_EQ(d.name, "Zack 15 Pro");+ EXPECT_EQ(d.adapter_path, "/org/bluez/hci0");+ EXPECT_TRUE(d.bonded);+ EXPECT_TRUE(d.connected);+ EXPECT_TRUE(d.has_le_bearer);+ EXPECT_TRUE(d.le_connected);+ EXPECT_TRUE(d.supports_map());+ EXPECT_TRUE(d.supports_pbap());+ EXPECT_TRUE(d.supports_ancs());+ EXPECT_TRUE(d.looks_like_iphone());+}++TEST(BluetoothObjects, UuidMatchIsCaseInsensitive) {+ Payload p(R"({+ '/org/bluez/hci0/dev_AA': {+ 'org.bluez.Device1': {+ 'UUIDs': <['7905F431-B5CE-4E99-A40F-4B1E122D00D0']>+ }+ }+ })");+ auto objects = parse_managed_objects(p.v);+ ASSERT_EQ(objects.devices.size(), 1u);+ EXPECT_TRUE(objects.devices[0].supports_ancs());+}++TEST(BluetoothObjects, DerivesAdapterPathWhenPropertyMissing) {+ Payload p(R"({+ '/org/bluez/hci1/dev_AA_BB': {+ 'org.bluez.Device1': { 'Address': <'AA:BB:CC:DD:EE:FF'> }+ }+ })");+ auto objects = parse_managed_objects(p.v);+ ASSERT_EQ(objects.devices.size(), 1u);+ EXPECT_EQ(objects.devices[0].adapter_path, "/org/bluez/hci1");+}++// Older BlueZ has no Bonded property; a paired device must still read as bonded+// or capability resolution would treat the bearer API as merely unconfirmed.+TEST(BluetoothObjects, BondedFallsBackToPaired) {+ Payload p(R"({+ '/org/bluez/hci0/dev_AA': {+ 'org.bluez.Device1': { 'Paired': <true> }+ }+ })");+ auto objects = parse_managed_objects(p.v);+ ASSERT_EQ(objects.devices.size(), 1u);+ EXPECT_TRUE(objects.devices[0].bonded);+}++TEST(BluetoothObjects, IgnoresUnexpectedPropertyTypes) {+ // A string where a boolean belongs must not throw or corrupt the record.+ Payload p(R"({+ '/org/bluez/hci0': {+ 'org.bluez.Adapter1': { 'Powered': <'yes'>, 'Class': <'nope'>, 'Address': <uint32 7> }+ }+ })");+ auto objects = parse_managed_objects(p.v);+ ASSERT_EQ(objects.adapters.size(), 1u);+ EXPECT_FALSE(objects.adapters[0].powered);+ EXPECT_EQ(objects.adapters[0].device_class, 0u);+ EXPECT_TRUE(objects.adapters[0].address.empty());+}++TEST(BluetoothObjects, RejectsNullAndWrongShape) {+ EXPECT_TRUE(parse_managed_objects(nullptr).adapters.empty());++ GVariant* wrong = g_variant_new_string("not an object tree");+ g_variant_ref_sink(wrong);+ auto objects = parse_managed_objects(wrong);+ EXPECT_TRUE(objects.adapters.empty());+ EXPECT_TRUE(objects.devices.empty());+ g_variant_unref(wrong);+}++TEST(Capability, FullModeWhenBearerConfirmed) {+ Payload p(join(ADAPTER_FULL, IPHONE_BONDED).c_str());+ auto cap = resolve_capability(parse_managed_objects(p.v));++ EXPECT_EQ(cap.mode, DeliveryMode::Full);+ EXPECT_EQ(cap.bearer_api, BearerApi::Confirmed);+ EXPECT_TRUE(cap.le_central);+ EXPECT_TRUE(cap.le_peripheral);+ EXPECT_TRUE(cap.advertising);+ EXPECT_TRUE(cap.class_ok);+ EXPECT_TRUE(cap.reasons.empty());+}++// Without --experimental the bearer interface can never appear, so its absence+// is conclusive.+TEST(Capability, CompatibilityWhenExperimentalIsOff) {+ Payload p(join(ADAPTER_FULL, R"({+ '/org/bluez/hci0/dev_60_57_C8_30_6A_F7': {+ 'org.bluez.Device1': { 'Paired': <true>, 'Bonded': <true> }+ }+ })")+ .c_str());+ auto objects = parse_managed_objects(p.v);+ objects.experimental_api = false;+ auto cap = resolve_capability(objects);++ EXPECT_EQ(cap.mode, DeliveryMode::Compatibility);+ EXPECT_EQ(cap.bearer_api, BearerApi::Absent);+ EXPECT_FALSE(cap.reasons.empty());+}++// Headsets and game controllers are bonded but never expose a bearer under any+// build, so treating any bond as proof of absence gives a false negative and+// silently disables ANCS on a machine that supports it.+TEST(Capability, ClassicOnlyBondDoesNotDisproveBearerApi) {+ Payload p(join(ADAPTER_FULL, R"({+ '/org/bluez/hci0/dev_F8_D3_F0_3C_84_4A': {+ 'org.bluez.Device1': { 'Paired': <true>, 'Bonded': <true> }+ }+ })")+ .c_str());+ auto objects = parse_managed_objects(p.v);+ objects.experimental_api = true;+ auto cap = resolve_capability(objects);++ EXPECT_EQ(cap.bearer_api, BearerApi::Unknown);+ EXPECT_EQ(cap.mode, DeliveryMode::Full);+}++TEST(Capability, BearerUnknownWithoutAnyBondStaysFull) {+ Payload p(ADAPTER_FULL);+ auto objects = parse_managed_objects(p.v);+ objects.experimental_api = true;+ auto cap = resolve_capability(objects);++ EXPECT_EQ(cap.mode, DeliveryMode::Full);+ EXPECT_EQ(cap.bearer_api, BearerApi::Unknown);+ // Tentative, so it must say why rather than claiming a verified result.+ EXPECT_FALSE(cap.reasons.empty());+}++TEST(Capability, BlockedWhenAdapterMissingOrOff) {+ EXPECT_EQ(resolve_capability({}).mode, DeliveryMode::Blocked);++ Payload off(R"({+ '/org/bluez/hci0': {+ 'org.bluez.Adapter1': { 'Powered': <false>, 'Roles': <['central', 'peripheral']> }+ }+ })");+ auto cap = resolve_capability(parse_managed_objects(off.v));+ EXPECT_EQ(cap.mode, DeliveryMode::Blocked);+ EXPECT_TRUE(cap.adapter_present);+}++TEST(Capability, BlockedWithoutCentralRole) {+ Payload p(R"({+ '/org/bluez/hci0': {+ 'org.bluez.Adapter1': { 'Powered': <true>, 'Roles': <['peripheral']> }+ }+ })");+ EXPECT_EQ(resolve_capability(parse_managed_objects(p.v)).mode, DeliveryMode::Blocked);+}++TEST(Capability, CompatibilityWithoutAdvertising) {+ Payload p(R"({+ '/org/bluez/hci0': {+ 'org.bluez.Adapter1': {+ 'Powered': <true>, 'Roles': <['central', 'peripheral']>, 'Class': <uint32 8127496>+ }+ }+ })");+ auto cap = resolve_capability(parse_managed_objects(p.v));+ EXPECT_EQ(cap.mode, DeliveryMode::Compatibility);+ EXPECT_FALSE(cap.advertising);+}++// Wrong Class of Device blocks the iPhone's permission toggles for MAP and PBAP+// too, so it is reported as a setup problem rather than an ANCS downgrade.+TEST(Capability, WrongClassIsReportedButDoesNotDowngradeMode) {+ Payload p(join(R"({+ '/org/bluez/hci0': {+ 'org.bluez.Adapter1': {+ 'Powered': <true>, 'Roles': <['central', 'peripheral']>, 'Class': <uint32 8126732>+ },+ 'org.bluez.LEAdvertisingManager1': { 'SupportedInstances': <byte 15> }+ }+ })",+ IPHONE_BONDED)+ .c_str());+ auto cap = resolve_capability(parse_managed_objects(p.v));++ EXPECT_EQ(cap.mode, DeliveryMode::Full);+ EXPECT_FALSE(cap.class_ok);+ EXPECT_FALSE(cap.reasons.empty());+}++TEST(Capability, PrefersAPoweredAdapter) {+ Payload p(R"({+ '/org/bluez/hci0': {+ 'org.bluez.Adapter1': { 'Powered': <false>, 'Roles': <['central']> }+ },+ '/org/bluez/hci1': {+ 'org.bluez.Adapter1': { 'Powered': <true>, 'Roles': <['central', 'peripheral']> }+ }+ })");+ auto cap = resolve_capability(parse_managed_objects(p.v));+ EXPECT_TRUE(cap.powered);+ EXPECT_TRUE(cap.le_peripheral);+}diff --git a/test/test_bluetooth_pairing.cpp b/test/test_bluetooth_pairing.cppnew file mode 100644index 0000000..4fade67--- /dev/null+++ b/test/test_bluetooth_pairing.cpp@@ -0,0 +1,76 @@+#include <gtest/gtest.h>+#include <tether/bluetooth/agent.hpp>+#include <tether/bluetooth/config.hpp>++using namespace tether::bluetooth;++// The agent authorizes services during pairing. Anything outside this set would+// grant the phone a profile Tether has no reason to consume.+TEST(AgentPolicy, AuthorizesOnlyMapAndPbap) {+ EXPECT_TRUE(is_authorized_service("0000112e-0000-1000-8000-00805f9b34fb")); // PBAP client+ EXPECT_TRUE(is_authorized_service("0000112f-0000-1000-8000-00805f9b34fb")); // PBAP server+ EXPECT_TRUE(is_authorized_service("00001132-0000-1000-8000-00805f9b34fb")); // MAP server+ EXPECT_TRUE(is_authorized_service("00001133-0000-1000-8000-00805f9b34fb")); // MAP notification+ EXPECT_TRUE(is_authorized_service("00001134-0000-1000-8000-00805f9b34fb")); // MAP client+}++TEST(AgentPolicy, RefusesEverythingElse) {+ // Hands-free / headset: the phone offers these, Tether must not accept them.+ EXPECT_FALSE(is_authorized_service("0000111e-0000-1000-8000-00805f9b34fb"));+ EXPECT_FALSE(is_authorized_service("0000110a-0000-1000-8000-00805f9b34fb"));+ // ANCS is reached over GATT after bonding, never authorized as a profile.+ EXPECT_FALSE(is_authorized_service("7905f431-b5ce-4e99-a40f-4b1e122d00d0"));+ EXPECT_FALSE(is_authorized_service(""));+ EXPECT_FALSE(is_authorized_service("garbage"));+ // A prefix match would be a real hole; require the whole UUID.+ EXPECT_FALSE(is_authorized_service("00001132-0000-1000-8000-00805f9b34f"));+ EXPECT_FALSE(is_authorized_service("00001132-0000-1000-8000-00805f9b34fbb"));+}++TEST(AgentPolicy, ServiceMatchIsCaseInsensitive) {+ EXPECT_TRUE(is_authorized_service("0000112F-0000-1000-8000-00805F9B34FB"));+}++// iOS renders the comparison with leading zeros. Dropping them shows the user a+// code that does not match their phone, which reads as a failed pairing.+TEST(Passkey, FormatsSixDigitsWithLeadingZeros) {+ EXPECT_EQ(format_passkey(123456), "123456");+ EXPECT_EQ(format_passkey(1234), "001234");+ EXPECT_EQ(format_passkey(0), "000000");+ EXPECT_EQ(format_passkey(7), "000007");+ EXPECT_EQ(format_passkey(999999), "999999");+}++TEST(BluetoothConfig, RoundTrips) {+ Config config;+ config.device_address = "60:57:C8:30:6A:F7";+ config.auth_strategy = AuthStrategy::ExplicitPair;+ config.ancs_enabled = false;++ EXPECT_EQ(deserialize_config(serialize_config(config)), config);+}++TEST(BluetoothConfig, DefaultsToConnectFirstAndAncsEnabled) {+ Config config = deserialize_config("{}");+ EXPECT_EQ(config.auth_strategy, AuthStrategy::ConnectFirst);+ EXPECT_TRUE(config.ancs_enabled);+ EXPECT_TRUE(config.device_address.empty());+}++// Connect-first is the default for a reason: a Linux-initiated Pair() can yield+// a BR/EDR-only bond that can never carry ANCS. An unknown value must not+// silently select the workaround.+TEST(BluetoothConfig, UnknownStrategyFallsBackToConnectFirst) {+ EXPECT_EQ(auth_strategy_from_string("nonsense"), AuthStrategy::ConnectFirst);+ EXPECT_EQ(auth_strategy_from_string(""), AuthStrategy::ConnectFirst);+ EXPECT_EQ(auth_strategy_from_string("explicit-pair"), AuthStrategy::ExplicitPair);+}++TEST(BluetoothConfig, SurvivesCorruptFile) {+ Config config = deserialize_config("{not json at all");+ EXPECT_EQ(config, Config{});++ // A valid JSON document of the wrong shape must also yield defaults.+ EXPECT_EQ(deserialize_config("[1,2,3]"), Config{});+ EXPECT_EQ(deserialize_config("\"string\""), Config{});+}diff --git a/test/test_bluetooth_supervisor.cpp b/test/test_bluetooth_supervisor.cppnew file mode 100644index 0000000..612803e--- /dev/null+++ b/test/test_bluetooth_supervisor.cpp@@ -0,0 +1,470 @@+#include <gtest/gtest.h>+#include <tether/bluetooth/bearer_supervisor.hpp>+#include <tether/bluetooth/profile_supervisor.hpp>++#include <string>+#include <vector>++using namespace tether::bluetooth;++namespace {++ class FakeBearer : public BearerOps {+ public:+ bool present = true;+ bool paired = true;+ bool classic = false;+ bool le_available = true;+ bool le = false;+ bool classic_succeeds = true;+ bool le_succeeds = true;++ int classic_attempts = 0;+ int le_attempts = 0;+ std::vector<std::string> preferred;++ bool device_present() const override { return present; }+ bool device_paired() const override { return paired; }+ bool classic_connected() const override { return classic; }+ bool le_bearer_available() const override { return le_available; }+ bool le_connected() const override { return le; }++ void set_preferred_bearer(const std::string& bearer) override { preferred.push_back(bearer); }++ std::string classic_error = "br/edr refused";+ std::string le_error = "le refused";++ bool connect_classic(std::string& err) override {+ ++classic_attempts;+ if (!classic_succeeds) {+ err = classic_error;+ return false;+ }+ classic = true;+ return true;+ }++ bool connect_le(std::string& err) override {+ ++le_attempts;+ if (!le_succeeds) {+ err = le_error;+ return false;+ }+ le = true;+ return true;+ }+ };++ class FakeProfiles : public ProfileOps {+ public:+ std::string map_error;+ std::string pbap_error;+ int map_attempts = 0;+ int pbap_attempts = 0;+ std::vector<std::string> removed;+ int session_counter = 0;++ std::string create_session(const std::string& target, std::string& err) override {+ const bool is_map = target == "map";+ (is_map ? map_attempts : pbap_attempts)++;+ const std::string& failure = is_map ? map_error : pbap_error;+ if (!failure.empty()) {+ err = failure;+ return {};+ }+ return "/session" + std::to_string(++session_counter);+ }++ void remove_session(const std::string& path) override { removed.push_back(path); }+ };++} // namespace++// BR/EDR must come up first; LE must wait out the settle window. Connecting LE+// too early leaves the bond half-connected and flapping.+TEST(BearerSupervisor, ConnectsClassicThenLeAfterSettling) {+ FakeBearer ops;+ BearerSupervisor sup(ops, true);++ sup.tick(0);+ EXPECT_EQ(ops.classic_attempts, 1);+ EXPECT_EQ(ops.le_attempts, 0) << "LE must not be attempted before Classic is up";++ // Classic is up at t=1, but the settle window has not elapsed.+ sup.tick(1);+ EXPECT_EQ(ops.le_attempts, 0);+ sup.tick(1 + BEARER_SETTLE_SECONDS - 1);+ EXPECT_EQ(ops.le_attempts, 0) << "LE attempted before the settle window elapsed";++ sup.tick(1 + BEARER_SETTLE_SECONDS);+ EXPECT_EQ(ops.le_attempts, 1);+ EXPECT_TRUE(sup.status().le_connected);+}++// PreferredBearer is an instruction for the next connection, not a durable+// setting. Leaving LE preferred while idle changes later reconnect behavior.+TEST(BearerSupervisor, NeverLeavesLePreferredWhileIdle) {+ FakeBearer ops;+ BearerSupervisor sup(ops, true);++ sup.tick(0);+ sup.tick(1);+ sup.tick(1 + BEARER_SETTLE_SECONDS);++ ASSERT_FALSE(ops.preferred.empty());+ EXPECT_EQ(ops.preferred.back(), "bredr");++ // Every "le" selection must be immediately followed by a return to "bredr".+ for (size_t i = 0; i < ops.preferred.size(); ++i) {+ if (ops.preferred[i] == "le") {+ ASSERT_LT(i + 1, ops.preferred.size()) << "left LE preferred at the end";+ EXPECT_EQ(ops.preferred[i + 1], "bredr");+ }+ }+}++TEST(BearerSupervisor, ClassicBackoffGrowsAndCaps) {+ FakeBearer ops;+ ops.classic_succeeds = false;+ BearerSupervisor sup(ops, true);++ sup.tick(0);+ EXPECT_EQ(ops.classic_attempts, 1);+ EXPECT_EQ(sup.status().classic_backoff, BEARER_BACKOFF_MIN_SECONDS);++ // Ticking inside the backoff window must not retry.+ sup.tick(BEARER_BACKOFF_MIN_SECONDS - 1);+ EXPECT_EQ(ops.classic_attempts, 1) << "retried before the backoff expired";++ sup.tick(BEARER_BACKOFF_MIN_SECONDS);+ EXPECT_EQ(ops.classic_attempts, 2);+ EXPECT_EQ(sup.status().classic_backoff, BEARER_BACKOFF_MIN_SECONDS * 2);++ // Drive many failures and confirm the cap holds.+ int64_t now = BEARER_BACKOFF_MIN_SECONDS;+ for (int i = 0; i < 20; ++i) {+ now += sup.status().classic_backoff;+ sup.tick(now);+ }+ EXPECT_EQ(sup.status().classic_backoff, BEARER_BACKOFF_MAX_SECONDS);+}++// InProgress means BlueZ is still finishing an operation of its own, which+// clears without help. Treating it like a refusal pushed the retry out to+// minutes and left LE — and so ANCS — down long after the cause was gone.+TEST(BearerSupervisor, InProgressDoesNotGrowTheClassicBackoff) {+ FakeBearer ops;+ ops.classic_succeeds = false;+ ops.classic_error = "GDBus.Error:org.bluez.Error.InProgress: In Progress";+ BearerSupervisor sup(ops, true);++ int64_t now = 0;+ for (int i = 0; i < 10; ++i) {+ sup.tick(now);+ EXPECT_EQ(sup.status().classic_backoff, BEARER_BACKOFF_MIN_SECONDS);+ now += BEARER_BACKOFF_MIN_SECONDS;+ }+ EXPECT_EQ(ops.classic_attempts, 10);+}++TEST(BearerSupervisor, InProgressDoesNotGrowTheLeBackoff) {+ FakeBearer ops;+ ops.le_succeeds = false;+ ops.le_error = "GDBus.Error:org.bluez.Error.InProgress: In Progress";+ BearerSupervisor sup(ops, true);++ // Classic is observed connected on the tick after it is dialed, and the+ // settle window runs from there.+ sup.tick(0);+ sup.tick(1);+ int64_t now = 1 + BEARER_SETTLE_SECONDS;+ for (int i = 0; i < 10; ++i) {+ sup.tick(now);+ EXPECT_EQ(sup.status().le_backoff, BEARER_BACKOFF_MIN_SECONDS);+ now += BEARER_BACKOFF_MIN_SECONDS;+ }+ EXPECT_EQ(ops.le_attempts, 10);+}++// A refusal is different: the phone said no, and hammering it was observed to+// hold the bond in a half-connected flapping state.+TEST(BearerSupervisor, RefusalStillGrowsTheLeBackoff) {+ FakeBearer ops;+ ops.le_succeeds = false;+ BearerSupervisor sup(ops, true);++ sup.tick(0);+ sup.tick(1);+ sup.tick(1 + BEARER_SETTLE_SECONDS);+ EXPECT_EQ(sup.status().le_backoff, BEARER_BACKOFF_MIN_SECONDS);++ sup.tick(1 + BEARER_SETTLE_SECONDS + BEARER_BACKOFF_MIN_SECONDS);+ EXPECT_EQ(sup.status().le_backoff, BEARER_BACKOFF_MIN_SECONDS * 2);+}++TEST(BearerSupervisor, LeBackoffDoesNotBlockClassic) {+ FakeBearer ops;+ ops.le_succeeds = false;+ BearerSupervisor sup(ops, true);++ sup.tick(0);+ sup.tick(1);+ sup.tick(1 + BEARER_SETTLE_SECONDS);+ EXPECT_EQ(ops.le_attempts, 1);+ EXPECT_GT(sup.status().le_backoff, 0);+ EXPECT_TRUE(sup.status().classic_connected) << "an LE failure must not tear down Classic";+}++TEST(BearerSupervisor, RecoversAfterDisconnect) {+ FakeBearer ops;+ BearerSupervisor sup(ops, true);++ sup.tick(0);+ sup.tick(1);+ sup.tick(1 + BEARER_SETTLE_SECONDS);+ ASSERT_TRUE(sup.status().le_connected);++ // The phone walks out of range.+ ops.classic = false;+ ops.le = false;+ sup.tick(100);+ EXPECT_FALSE(sup.status().classic_connected);+ EXPECT_FALSE(sup.status().le_connected) << "LE cannot be up while Classic is down";+ EXPECT_EQ(ops.classic_attempts, 2);++ // ...and comes back.+ sup.tick(101);+ sup.tick(101 + BEARER_SETTLE_SECONDS);+ EXPECT_TRUE(sup.status().classic_connected);+ EXPECT_TRUE(sup.status().le_connected);+}++// reset() models a resume: recovery should start at once, not after waiting out+// a backoff accumulated before the machine slept.+TEST(BearerSupervisor, ResetClearsBackoffForImmediateRetry) {+ FakeBearer ops;+ ops.classic_succeeds = false;+ BearerSupervisor sup(ops, true);++ sup.tick(0);+ sup.tick(BEARER_BACKOFF_MIN_SECONDS);+ ASSERT_EQ(ops.classic_attempts, 2);++ sup.reset();+ ops.classic_succeeds = true;+ sup.tick(BEARER_BACKOFF_MIN_SECONDS + 1);+ EXPECT_EQ(ops.classic_attempts, 3) << "reset must allow an immediate retry";+}++TEST(BearerSupervisor, SkipsLeWhenAncsDisabled) {+ FakeBearer ops;+ BearerSupervisor sup(ops, false);++ sup.tick(0);+ sup.tick(1);+ sup.tick(1 + BEARER_SETTLE_SECONDS + 10);+ EXPECT_EQ(ops.le_attempts, 0);+ EXPECT_TRUE(sup.status().classic_connected);+}++TEST(BearerSupervisor, SkipsLeWhenBearerUnavailable) {+ FakeBearer ops;+ ops.le_available = false;+ BearerSupervisor sup(ops, true);++ sup.tick(0);+ sup.tick(1);+ sup.tick(1 + BEARER_SETTLE_SECONDS + 10);+ EXPECT_EQ(ops.le_attempts, 0);+ EXPECT_FALSE(sup.status().le_available);+}++TEST(BearerSupervisor, ReportsMissingDevice) {+ FakeBearer ops;+ ops.present = false;+ BearerSupervisor sup(ops, true);++ sup.tick(0);+ EXPECT_FALSE(sup.status().device_present);+ EXPECT_EQ(ops.classic_attempts, 0) << "must not dial a device BlueZ does not know";+}++// A known-but-unpaired device happens after an unpair or after the phone forgets+// this computer. Dialing it collides with the pairing transaction, and BlueZ+// answers both attempts with br-connection-busy.+TEST(BearerSupervisor, StandsDownWhenDeviceIsUnpaired) {+ FakeBearer ops;+ ops.paired = false;+ BearerSupervisor sup(ops, true);++ sup.tick(0);+ sup.tick(BEARER_POLL_SECONDS * 20);+ EXPECT_TRUE(sup.status().device_present);+ EXPECT_FALSE(sup.status().device_paired);+ EXPECT_EQ(ops.classic_attempts, 0) << "must not dial an unpaired device";+ EXPECT_EQ(ops.le_attempts, 0);+ EXPECT_TRUE(ops.preferred.empty()) << "must not touch PreferredBearer before a bond exists";+}++// Forbidden and Busy look similar but call for opposite advice. Reporting a+// permissions problem as a busy session sends the user off re-pairing for+// nothing, and vice versa.+TEST(ObexErrors, DistinguishesForbiddenFromBusy) {+ EXPECT_EQ(classify_obex_error("Forbidden"), ObexError::Forbidden);+ EXPECT_EQ(classify_obex_error("org.bluez.obex.Error.Forbidden: Forbidden"), ObexError::Forbidden);+ EXPECT_EQ(classify_obex_error("OBEX response 0x43"), ObexError::Forbidden);++ EXPECT_EQ(classify_obex_error("Connection refused (111)"), ObexError::Busy);+ EXPECT_EQ(classify_obex_error("connection refused"), ObexError::Busy);+}++// Observed on real hardware with the iPhone bonded, connected, and all three+// permission toggles verified on. Classifying it as Forbidden would send the+// user to settings that are already correct.+TEST(ObexErrors, ServiceRecordMissingIsNotAPermissionProblem) {+ const std::string real = "GDBus.Error:org.bluez.obex.Error.Failed: Unable to find service record";+ EXPECT_EQ(classify_obex_error(real), ObexError::NoRecord);+ EXPECT_NE(classify_obex_error(real), ObexError::Forbidden);++ // obexd reports a missing record whenever its SDP fetch is refused, so the+ // advice must name both plausible causes and must not send the user+ // re-pairing, which fixes neither.+ const std::string advice = obex_error_advice(ObexError::NoRecord, "map");+ EXPECT_NE(advice.find("another computer"), std::string::npos);+ EXPECT_NE(advice.find("Show Message Notifications"), std::string::npos);+ EXPECT_NE(advice.find("re-pairing is not the fix"), std::string::npos);+}++TEST(ObexErrors, ClassifiesUnavailableAndOther) {+ EXPECT_EQ(classify_obex_error("Host is down"), ObexError::Unavailable);+ EXPECT_EQ(classify_obex_error("Page Timeout"), ObexError::Unavailable);+ EXPECT_EQ(classify_obex_error(""), ObexError::None);+ EXPECT_EQ(classify_obex_error("something entirely new"), ObexError::Other);+}++TEST(ObexErrors, AdviceNamesThePermissionToggle) {+ const std::string map_advice = obex_error_advice(ObexError::Forbidden, "map");+ EXPECT_NE(map_advice.find("Show Message Notifications"), std::string::npos);+ // Must not send the user re-pairing over a permission.+ EXPECT_EQ(map_advice.find("re-pair"), std::string::npos);++ EXPECT_NE(obex_error_advice(ObexError::Forbidden, "pbap").find("Sync Contacts"), std::string::npos);+ EXPECT_NE(obex_error_advice(ObexError::Busy, "map").find("another computer"), std::string::npos);+}++TEST(ProfileSupervisor, OpensBothSessionsWhenLinkReady) {+ FakeProfiles ops;+ ProfileSupervisor sup(ops);++ sup.tick(0, true);+ EXPECT_TRUE(sup.status().map_open);+ EXPECT_TRUE(sup.status().pbap_open);+ EXPECT_FALSE(sup.map_session().empty());+ EXPECT_FALSE(sup.pbap_session().empty());+}++TEST(ProfileSupervisor, DoesNothingUntilLinkIsReady) {+ FakeProfiles ops;+ ProfileSupervisor sup(ops);++ sup.tick(0, false);+ EXPECT_EQ(ops.map_attempts, 0);+ EXPECT_EQ(ops.pbap_attempts, 0);+}++// A Forbidden may be a stale obexd session from a previous run, so exactly one+// retry is allowed. It must never escalate to restarting obexd.+TEST(ProfileSupervisor, RetriesOnceAfterForbidden) {+ FakeProfiles ops;+ ops.map_error = "Forbidden";+ ProfileSupervisor sup(ops);++ sup.tick(0, true);+ EXPECT_EQ(ops.map_attempts, 2) << "expected exactly one retry after Forbidden";+ EXPECT_FALSE(sup.status().map_open);+ EXPECT_EQ(sup.status().map_error, ObexError::Forbidden);++ // PBAP opened, so the supervisor is on the steady cadence even though MAP is+ // still failing. The extra Forbidden retry is spent, so this poll makes+ // exactly one attempt — a persistent permission problem must not turn into a+ // retry burst against obexd.+ sup.tick(PROFILE_STEADY_POLL_SECONDS, true);+ EXPECT_EQ(ops.map_attempts, 3);+}++// While nothing has opened yet, the fast cadence applies so a user flipping the+// permission toggles is picked up promptly.+TEST(ProfileSupervisor, UsesFastCadenceUntilSomethingOpens) {+ FakeProfiles ops;+ ops.map_error = "Forbidden";+ ops.pbap_error = "Forbidden";+ ProfileSupervisor sup(ops);++ sup.tick(0, true);+ const int attempts = ops.map_attempts;++ sup.tick(PROFILE_INITIAL_POLL_SECONDS - 1, true);+ EXPECT_EQ(ops.map_attempts, attempts);++ sup.tick(PROFILE_INITIAL_POLL_SECONDS, true);+ EXPECT_GT(ops.map_attempts, attempts);+}++TEST(ProfileSupervisor, PartialSuccessKeepsRetryingTheOtherProfile) {+ FakeProfiles ops;+ ops.pbap_error = "Forbidden";+ ProfileSupervisor sup(ops);++ sup.tick(0, true);+ EXPECT_TRUE(sup.status().map_open);+ EXPECT_FALSE(sup.status().pbap_open);++ const int map_attempts_after_open = ops.map_attempts;+ ops.pbap_error.clear();+ sup.tick(PROFILE_STEADY_POLL_SECONDS, true);+ EXPECT_TRUE(sup.status().pbap_open);+ EXPECT_EQ(ops.map_attempts, map_attempts_after_open) << "must not reopen an already-open session";+}++TEST(ProfileSupervisor, RespectsPollInterval) {+ FakeProfiles ops;+ ops.map_error = "Connection refused (111)";+ ops.pbap_error = "Connection refused (111)";+ ProfileSupervisor sup(ops);++ sup.tick(0, true);+ const int attempts = ops.map_attempts;+ sup.tick(1, true);+ EXPECT_EQ(ops.map_attempts, attempts) << "retried before the poll interval elapsed";++ sup.tick(PROFILE_INITIAL_POLL_SECONDS, true);+ EXPECT_GT(ops.map_attempts, attempts);+}++TEST(ProfileSupervisor, ResetRemovesSessions) {+ FakeProfiles ops;+ ProfileSupervisor sup(ops);++ sup.tick(0, true);+ ASSERT_TRUE(sup.status().map_open);++ sup.reset();+ EXPECT_EQ(ops.removed.size(), 2u);+ EXPECT_FALSE(sup.status().map_open);+ EXPECT_TRUE(sup.map_session().empty());++ // And reopens on the next tick.+ sup.tick(100, true);+ EXPECT_TRUE(sup.status().map_open);+}++TEST(ProfileSupervisor, BusySessionKeepsPollingWithoutRetryBurst) {+ FakeProfiles ops;+ ops.map_error = "Connection refused (111)";+ ProfileSupervisor sup(ops);++ sup.tick(0, true);+ // Busy is not Forbidden, so it gets no extra immediate retry.+ EXPECT_EQ(ops.map_attempts, 1);+ EXPECT_EQ(sup.status().map_error, ObexError::Busy);+}diff --git a/test/test_bmessage.cpp b/test/test_bmessage.cppnew file mode 100644index 0000000..34a811b--- /dev/null+++ b/test/test_bmessage.cpp@@ -0,0 +1,386 @@+#include <gtest/gtest.h>+#include <tether/bluetooth/bmessage.hpp>+#include <tether/bluetooth/map_session.hpp>+#include <tether/bluetooth/messages.hpp>++using namespace tether::bluetooth;++namespace {++ // Shape observed from the iPhone: originator vCard outside BENV, recipient+ // inside it, UTF-8 body in BBODY/MSG, TYPE always SMS_GSM.+ constexpr const char* INCOMING_TEL =+ "BEGIN:BMSG\r\n"+ "VERSION:1.0\r\n"+ "STATUS:UNREAD\r\n"+ "TYPE:SMS_GSM\r\n"+ "FOLDER:telecom/msg/inbox\r\n"+ "BEGIN:VCARD\r\n"+ "VERSION:2.1\r\n"+ "N:Doe;Jane\r\n"+ "TEL:+1 (555) 123-4567\r\n"+ "END:VCARD\r\n"+ "BEGIN:BENV\r\n"+ "BEGIN:VCARD\r\n"+ "VERSION:2.1\r\n"+ "TEL:+15559998888\r\n"+ "END:VCARD\r\n"+ "BEGIN:BBODY\r\n"+ "CHARSET:UTF-8\r\n"+ "LENGTH:42\r\n"+ "BEGIN:MSG\r\n"+ "Running late\r\n"+ "END:MSG\r\n"+ "END:BBODY\r\n"+ "END:BENV\r\n"+ "END:BMSG\r\n";++ // Apple-ID destination: no TEL at all, only EMAIL.+ constexpr const char* INCOMING_EMAIL =+ "BEGIN:BMSG\n"+ "VERSION:1.0\n"+ "STATUS:READ\n"+ "TYPE:SMS_GSM\n"+ "FOLDER:telecom/msg/inbox\n"+ "BEGIN:VCARD\n"+ "FN:Sam Smith\n"+ "EMAIL:[email protected]\n"+ "END:VCARD\n"+ "BEGIN:BENV\n"+ "BEGIN:BBODY\n"+ "BEGIN:MSG\n"+ "sent from an apple id\n"+ "END:MSG\n"+ "END:BBODY\n"+ "END:BENV\n"+ "END:BMSG\n";++} // namespace++TEST(BMessageParse, ParsesTelephoneOriginator) {+ BMessage m = parse_bmessage(INCOMING_TEL);+ ASSERT_TRUE(m.valid);+ EXPECT_FALSE(m.read);+ EXPECT_EQ(m.type, "SMS_GSM");+ EXPECT_EQ(m.folder, "telecom/msg/inbox");+ EXPECT_EQ(m.originator.tel, "+1 (555) 123-4567");+ EXPECT_EQ(m.originator.name, "Jane Doe");+ EXPECT_EQ(m.body, "Running late");+ ASSERT_EQ(m.recipients.size(), 1u);+ EXPECT_EQ(m.recipients[0].tel, "+15559998888");+}++TEST(BMessageParse, ParsesAppleIdOriginator) {+ BMessage m = parse_bmessage(INCOMING_EMAIL);+ ASSERT_TRUE(m.valid);+ EXPECT_TRUE(m.read);+ EXPECT_TRUE(m.originator.tel.empty());+ EXPECT_EQ(m.originator.email, "[email protected]");+ EXPECT_EQ(m.originator.name, "Sam Smith");+ EXPECT_EQ(m.body, "sent from an apple id");+}++TEST(BMessageParse, KeepsMultilineAndUtf8Bodies) {+ const std::string text = "BEGIN:BMSG\r\nSTATUS:UNREAD\r\n"+ "BEGIN:VCARD\r\nTEL:+15551112222\r\nEND:VCARD\r\n"+ "BEGIN:BENV\r\nBEGIN:BBODY\r\nBEGIN:MSG\r\n"+ "line one\r\nline two\r\n\xC3\xA9\xC3\xA0 \xE2\x9C\x93 \xF0\x9F\x8E\x89\r\n"+ "END:MSG\r\nEND:BBODY\r\nEND:BENV\r\nEND:BMSG\r\n";+ BMessage m = parse_bmessage(text);+ ASSERT_TRUE(m.valid);+ EXPECT_EQ(m.body, "line one\nline two\n\xC3\xA9\xC3\xA0 \xE2\x9C\x93 \xF0\x9F\x8E\x89");+}++// A body line that looks like a structural token is byte-stuffed by the sender.+// Failing to unstuff would corrupt the message; failing to stop at the real+// END:MSG would swallow the rest of the container.+TEST(BMessageParse, UnstuffsBodyLinesThatLookStructural) {+ const std::string text = "BEGIN:BMSG\r\nSTATUS:UNREAD\r\n"+ "BEGIN:VCARD\r\nTEL:+15551112222\r\nEND:VCARD\r\n"+ "BEGIN:BENV\r\nBEGIN:BBODY\r\nBEGIN:MSG\r\n"+ " END:MSG\r\n"+ " BEGIN:VCARD\r\n"+ "real text\r\n"+ "END:MSG\r\nEND:BBODY\r\nEND:BENV\r\nEND:BMSG\r\n";+ BMessage m = parse_bmessage(text);+ ASSERT_TRUE(m.valid);+ EXPECT_EQ(m.body, "END:MSG\nBEGIN:VCARD\nreal text");+ // The stuffed vCard line must not have been read as a real party.+ EXPECT_TRUE(m.recipients.empty());+}++TEST(BMessageParse, AcceptsLfOnlyAndIgnoresUnknownProperties) {+ const std::string text = "BEGIN:BMSG\nX-WEIRD:whatever\nSTATUS:READ\n"+ "BEGIN:VCARD\nTEL;TYPE=CELL:+15551112222\nX-OTHER:x\nEND:VCARD\n"+ "BEGIN:BENV\nBEGIN:BBODY\nBEGIN:MSG\nhi\nEND:MSG\nEND:BBODY\nEND:BENV\nEND:BMSG";+ BMessage m = parse_bmessage(text);+ ASSERT_TRUE(m.valid);+ EXPECT_EQ(m.originator.tel, "+15551112222") << "vCard parameters must not break property parsing";+ EXPECT_EQ(m.body, "hi");+}++TEST(BMessageParse, RejectsMalformedInputWithoutThrowing) {+ EXPECT_FALSE(parse_bmessage("").valid);+ EXPECT_FALSE(parse_bmessage("not a bmessage at all").valid);+ EXPECT_FALSE(parse_bmessage("STATUS:READ\nBEGIN:MSG\nbody\n").valid);++ // Truncated mid-container: must parse what it can and not crash.+ BMessage truncated = parse_bmessage("BEGIN:BMSG\nSTATUS:UNREAD\nBEGIN:VCARD\nTEL:+1555");+ EXPECT_TRUE(truncated.valid);+ EXPECT_TRUE(truncated.body.empty());+}++// --- Identity ----------------------------------------------------------++TEST(AddressIdentity, NormalizesPhoneFormatting) {+ EXPECT_EQ(normalize_phone("+1 (555) 123-4567"), "+15551234567");+ EXPECT_EQ(normalize_phone("+1-555-123-4567"), "+15551234567");+ EXPECT_EQ(normalize_phone("555.123.4567"), "5551234567");+ EXPECT_EQ(normalize_phone(""), "");+}++// Guessing a country code could route a reply to a different person, so a+// national number must not silently become an international one.+TEST(AddressIdentity, DoesNotInventCountryCodes) {+ EXPECT_NE(normalize_phone("5551234567"), normalize_phone("+15551234567"));+}++TEST(AddressIdentity, EmailIsCaseInsensitive) {+ EXPECT_EQ(normalize_email(" [email protected] "), "[email protected]");+}++TEST(AddressIdentity, ThreadKeyPrefersTelAndNamespacesTypes) {+ VCardParty both;+ both.tel = "+1 555 123 4567";+ both.email = "[email protected]";+ EXPECT_EQ(thread_key_for(both), "tel:+15551234567");++ VCardParty email_only;+ email_only.email = "[email protected]";+ EXPECT_EQ(thread_key_for(email_only), "email:[email protected]");++ // A phone number and an email must never collide.+ EXPECT_NE(thread_key_for(both), thread_key_for(email_only));++ EXPECT_TRUE(thread_key_for(VCardParty{}).empty());+}++// The display name is not identity; two contacts sharing a name must stay apart.+TEST(AddressIdentity, NameDoesNotAffectThreadKey) {+ VCardParty a;+ a.name = "Sam";+ a.tel = "+15551110000";+ VCardParty b;+ b.name = "Sam";+ b.tel = "+15552220000";+ EXPECT_NE(thread_key_for(a), thread_key_for(b));+}++TEST(Timestamps, ParsesMapBasicIso) {+ EXPECT_GT(parse_map_timestamp("20260816T024500"), 0);+ EXPECT_EQ(parse_map_timestamp("20260816T024500Z"), 1786848300); // 2026-08-16T02:45:00Z+ EXPECT_EQ(parse_map_timestamp(""), 0);+ EXPECT_EQ(parse_map_timestamp("garbage"), 0);+ EXPECT_EQ(parse_map_timestamp("20261399T999999"), 0);+}++// --- Store -------------------------------------------------------------++namespace {++ Message make(const std::string& handle, const std::string& thread, int64_t ts, bool read = false,+ bool outgoing = false) {+ Message m;+ m.handle = handle;+ m.thread_key = thread;+ m.peer_address = thread;+ m.body = "body " + handle;+ m.timestamp = ts;+ m.read = read;+ m.outgoing = outgoing;+ return m;+ }++} // namespace++// MNS events and ListMessages polling both deliver the same message, and the+// phone replays messages after a reconnect.+TEST(MessageStore, DedupesByHandle) {+ MessageStore store;+ EXPECT_TRUE(store.add(make("h1", "tel:+1555", 100)));+ EXPECT_FALSE(store.add(make("h1", "tel:+1555", 100)));+ EXPECT_EQ(store.size(), 1u);+}++TEST(MessageStore, RejectsMessagesWithoutHandle) {+ MessageStore store;+ EXPECT_FALSE(store.add(make("", "tel:+1555", 100)));+ EXPECT_EQ(store.size(), 0u);+}++TEST(MessageStore, GroupsThreadsNewestFirst) {+ MessageStore store;+ store.add(make("a", "tel:+1111", 100));+ store.add(make("b", "tel:+2222", 300));+ store.add(make("c", "tel:+1111", 200));++ auto threads = store.threads();+ ASSERT_EQ(threads.size(), 2u);+ EXPECT_EQ(threads[0].key, "tel:+2222");+ EXPECT_EQ(threads[1].key, "tel:+1111");+ EXPECT_EQ(threads[1].count, 2);+ EXPECT_EQ(threads[1].last_body, "body c") << "preview must come from the newest message";+}++TEST(MessageStore, CountsUnreadIncomingOnly) {+ MessageStore store;+ store.add(make("a", "tel:+1111", 100, /*read=*/false));+ store.add(make("b", "tel:+1111", 200, /*read=*/true));+ store.add(make("c", "tel:+1111", 300, /*read=*/false, /*outgoing=*/true));++ auto threads = store.threads();+ ASSERT_EQ(threads.size(), 1u);+ EXPECT_EQ(threads[0].unread, 1) << "an unread outgoing message is not unread mail";+}++TEST(MessageStore, MarkReadIsIdempotentAndReportsChange) {+ MessageStore store;+ store.add(make("a", "tel:+1111", 100, /*read=*/false));++ EXPECT_TRUE(store.set_read("a", true));+ EXPECT_FALSE(store.set_read("a", true)) << "an echo of our own change must not loop";+ EXPECT_TRUE(store.set_read("a", false));+ EXPECT_FALSE(store.set_read("unknown", true));+}++TEST(MessageStore, MessagesAreOldestFirstAndLimited) {+ MessageStore store;+ for (int i = 0; i < 10; ++i)+ store.add(make("h" + std::to_string(i), "tel:+1111", 100 + i));++ auto all = store.messages("tel:+1111");+ ASSERT_EQ(all.size(), 10u);+ EXPECT_EQ(all.front().handle, "h0");+ EXPECT_EQ(all.back().handle, "h9");++ auto recent = store.messages("tel:+1111", 3);+ ASSERT_EQ(recent.size(), 3u);+ EXPECT_EQ(recent.front().handle, "h7") << "limit must keep the newest, in oldest-first order";+ EXPECT_EQ(recent.back().handle, "h9");+}++TEST(MessageStore, EvictsOldestBeyondCap) {+ MessageStore store(3);+ for (int i = 0; i < 5; ++i)+ store.add(make("h" + std::to_string(i), "tel:+1111", 100 + i));++ EXPECT_EQ(store.size(), 3u);+ EXPECT_EQ(store.find("h0"), nullptr);+ EXPECT_NE(store.find("h4"), nullptr);+}++TEST(MessageStore, BuildsMessageFromIncomingBMessage) {+ Message m = message_from_bmessage(parse_bmessage(INCOMING_TEL), "0x0001", 12345);+ EXPECT_EQ(m.handle, "0x0001");+ EXPECT_EQ(m.thread_key, "tel:+15551234567") << "keyed on the originator for incoming mail";+ EXPECT_EQ(m.peer_name, "Jane Doe");+ EXPECT_FALSE(m.outgoing);+ EXPECT_FALSE(m.read);+ EXPECT_EQ(m.timestamp, 12345);+}++// For a message we sent, the conversation is the recipient, not ourselves.+TEST(MessageStore, OutgoingMessageIsKeyedOnRecipient) {+ const std::string sent = "BEGIN:BMSG\nSTATUS:READ\nFOLDER:telecom/msg/sent\n"+ "BEGIN:VCARD\nEND:VCARD\n"+ "BEGIN:BENV\nBEGIN:VCARD\nTEL:+15557778888\nEND:VCARD\n"+ "BEGIN:BBODY\nBEGIN:MSG\nyo\nEND:MSG\nEND:BBODY\nEND:BENV\nEND:BMSG\n";+ Message m = message_from_bmessage(parse_bmessage(sent), "0x0002", 999);+ EXPECT_TRUE(m.outgoing);+ EXPECT_EQ(m.thread_key, "tel:+15557778888");+}++// --- MAP listings ------------------------------------------------------+//+// ListMessages alone carries enough to display a conversation, so the listing+// path must produce the same identity as a parsed bMessage would.++TEST(MapListing, BuildsMessageWithoutBMessageFetch) {+ MapListing listing;+ listing.handle = "/org/bluez/obex/client/session1/message0";+ listing.subject = "see you there";+ listing.sender_address = "+1 (555) 123-4567";+ listing.sender_name = "Jane Doe";+ listing.timestamp = "20260816T024500Z";+ listing.type = "sms-gsm";+ listing.folder = "inbox";+ listing.read = false;++ Message m = message_from_listing(listing);+ // The handle is the stable id, not the session-scoped object path.+ EXPECT_EQ(m.handle, "0");+ EXPECT_EQ(m.object_path, listing.handle);+ EXPECT_EQ(m.body, "see you there");+ EXPECT_EQ(m.thread_key, "tel:+15551234567");+ EXPECT_EQ(m.peer_address, "+15551234567");+ EXPECT_EQ(m.peer_name, "Jane Doe");+ EXPECT_EQ(m.timestamp, 1786848300);+ EXPECT_FALSE(m.read);+ EXPECT_FALSE(m.outgoing);+}++// An Apple-ID sender arrives in the same field as a phone number, with '@' the+// only discriminator available.+TEST(MapListing, RoutesAppleIdSenderToEmailIdentity) {+ MapListing listing;+ listing.handle = "h";+ listing.sender_address = "[email protected]";+ Message m = message_from_listing(listing);+ EXPECT_EQ(m.thread_key, "email:[email protected]");+}++// A listing and a full bMessage for the same conversation must land in one+// thread, or history would split depending on how it was fetched.+TEST(MapListing, AgreesWithBMessageThreadKey) {+ MapListing listing;+ listing.handle = "h";+ listing.sender_address = "+15551234567";+ const Message from_listing = message_from_listing(listing);+ const Message from_bmessage = message_from_bmessage(parse_bmessage(INCOMING_TEL), "h2", 1);+ EXPECT_EQ(from_listing.thread_key, from_bmessage.thread_key);+}++TEST(MapListing, SentFlagMarksOutgoing) {+ MapListing listing;+ listing.handle = "h";+ listing.sender_address = "+15551234567";+ listing.sent = true;+ EXPECT_TRUE(message_from_listing(listing).outgoing);+}++// obexd's object path embeds the OBEX session number, which changes on every+// reconnect. Keying a message on the whole path makes the same message look new+// after each one, duplicating history without bound.+TEST(MapHandle, StripsTheSessionScopedPrefix) {+ EXPECT_EQ(map_handle_from_path("/org/bluez/obex/client/session5/message1086086778701665313"),+ "1086086778701665313");+ EXPECT_EQ(map_handle_from_path("/org/bluez/obex/client/session11/message1086086778701665313"),+ "1086086778701665313")+ << "a different session must yield the same handle";+}++TEST(MapHandle, PassesThroughUnexpectedShapes) {+ EXPECT_EQ(map_handle_from_path("12345"), "12345");+ EXPECT_EQ(map_handle_from_path(""), "");+}++TEST(MapListingConversion, KeepsTheObjectPathForActingOnTheMessage) {+ MapListing listing;+ listing.handle = "/org/bluez/obex/client/session5/message42";+ listing.sender_address = "+15551234567";+ listing.subject = "hi";++ Message message = message_from_listing(listing);+ EXPECT_EQ(message.handle, "42");+ EXPECT_EQ(message.object_path, "/org/bluez/obex/client/session5/message42");+}diff --git a/test/test_bmessage_build.cpp b/test/test_bmessage_build.cppnew file mode 100644index 0000000..4e7e623--- /dev/null+++ b/test/test_bmessage_build.cpp@@ -0,0 +1,207 @@+#include <gtest/gtest.h>+#include <tether/bluetooth/bmessage.hpp>++using namespace tether::bluetooth;++namespace {++ Recipient tel(const std::string& address) { return {RecipientKind::Tel, address}; }+ Recipient email(const std::string& address) { return {RecipientKind::Email, address}; }++ size_t count_occurrences(const std::string& haystack, const std::string& needle) {+ size_t count = 0;+ for (size_t at = haystack.find(needle); at != std::string::npos; at = haystack.find(needle, at + 1))+ ++count;+ return count;+ }++} // namespace++TEST(BMessageBuild, ProducesTheShapeThePhoneAccepts) {+ const std::string out = build_bmessage({tel("+15551234567")}, "on my way");++ EXPECT_NE(out.find("BEGIN:BMSG"), std::string::npos);+ EXPECT_NE(out.find("TYPE:SMS_GSM"), std::string::npos);+ EXPECT_NE(out.find("FOLDER:telecom/msg/outbox"), std::string::npos);+ EXPECT_NE(out.find("CHARSET:UTF-8"), std::string::npos);+ EXPECT_NE(out.find("TEL:+15551234567"), std::string::npos);+ EXPECT_NE(out.find("on my way"), std::string::npos);++ // The originator vCard is empty and sits before the envelope; the recipient+ // vCard sits inside it.+ const size_t originator = out.find("BEGIN:VCARD");+ const size_t envelope = out.find("BEGIN:BENV");+ const size_t recipient = out.find("TEL:+15551234567");+ ASSERT_NE(envelope, std::string::npos);+ EXPECT_LT(originator, envelope) << "originator must be outside the envelope";+ EXPECT_LT(envelope, recipient) << "recipient must be inside the envelope";+}++// iOS chooses iMessage on its own; the type never changes, and nothing here can+// force or observe that choice.+TEST(BMessageBuild, AlwaysUsesSmsGsmEvenForAppleIdRecipients) {+ const std::string out = build_bmessage({email("[email protected]")}, "hi");++ EXPECT_NE(out.find("TYPE:SMS_GSM"), std::string::npos);+ EXPECT_NE(out.find("EMAIL:[email protected]"), std::string::npos);+ EXPECT_EQ(out.find("TEL:"), std::string::npos);+}++TEST(BMessageBuild, LengthCountsTheWholeMessageBlock) {+ const std::string out = build_bmessage({tel("+15551234567")}, "hello");++ const size_t length_at = out.find("LENGTH:");+ ASSERT_NE(length_at, std::string::npos);+ const size_t declared = std::stoul(out.substr(length_at + 7));++ const size_t begin = out.find("BEGIN:MSG");+ const size_t end = out.find("END:MSG");+ ASSERT_NE(begin, std::string::npos);+ ASSERT_NE(end, std::string::npos);+ const size_t actual = (end + std::string("END:MSG\r\n").size()) - begin;+ EXPECT_EQ(declared, actual);+}++// --- The trust boundary --------------------------------------------------+//+// Every case below is an address that, interpolated verbatim, would add a+// recipient the user never chose.++TEST(BMessageBuild, RejectsNewlineInjectedRecipient) {+ std::string err;+ EXPECT_FALSE(validate_recipient(tel("+15551234567\r\nTEL:+15559999999"), err));+ EXPECT_FALSE(err.empty());++ EXPECT_FALSE(validate_recipient(tel("+15551234567\nTEL:+15559999999"), err));+ EXPECT_FALSE(validate_recipient(email("[email protected]\r\nEMAIL:[email protected]"), err));+}++TEST(BMessageBuild, RejectsVCardDelimiters) {+ std::string err;+ EXPECT_FALSE(validate_recipient(email("[email protected];TYPE=WORK"), err));+ EXPECT_FALSE(validate_recipient(email("[email protected]:x"), err));+ EXPECT_FALSE(validate_recipient(email("[email protected],[email protected]"), err));+ EXPECT_FALSE(validate_recipient(email("a\\@b.com"), err));+}++TEST(BMessageBuild, RejectsControlCharacters) {+ std::string err;+ EXPECT_FALSE(validate_recipient(tel(std::string("+1555\x01"+ "234")),+ err));+ EXPECT_FALSE(validate_recipient(email(std::string("a@b\x7f.com")), err));+ EXPECT_FALSE(validate_recipient(tel("+1555\t234"), err));+}++// The builder refuses outright rather than escaping: a message that reaches+// the wrong person cannot be taken back, so there is no partial success here.+TEST(BMessageBuild, BuildRefusesAnInvalidRecipientEntirely) {+ EXPECT_EQ(build_bmessage({tel("+15551234567\r\nTEL:+15559999999")}, "hi"), "");+ EXPECT_EQ(build_bmessage({}, "hi"), "");++ // One bad recipient poisons the whole message, including the valid one.+ EXPECT_EQ(build_bmessage({tel("+15551234567"), email("[email protected]\r\nEMAIL:[email protected]")}, "hi"), "");+}++// The end-to-end proof: whatever an attacker puts in the address, the built+// message must never contain more recipients than were asked for.+TEST(BMessageBuild, InjectedRecipientNeverSurvivesIntoAParsedMessage) {+ const std::string out = build_bmessage({tel("+15551234567")}, "hi");+ ASSERT_FALSE(out.empty());++ BMessage parsed = parse_bmessage(out);+ ASSERT_TRUE(parsed.valid);+ ASSERT_EQ(parsed.recipients.size(), 1u);+ EXPECT_EQ(parsed.recipients[0].tel, "+15551234567");+}++TEST(BMessageBuild, AcceptsAddressesPeopleActuallyWrite) {+ std::string err;+ EXPECT_TRUE(validate_recipient(tel("+1 (555) 123-4567"), err)) << err;+ EXPECT_TRUE(validate_recipient(tel("5551234567"), err)) << err;+ EXPECT_TRUE(validate_recipient(email("[email protected]"), err)) << err;+}++TEST(BMessageBuild, RejectsAddressesThatAreNotAddresses) {+ std::string err;+ EXPECT_FALSE(validate_recipient(tel(""), err));+ EXPECT_FALSE(validate_recipient(tel("no-digits-here"), err));+ EXPECT_FALSE(validate_recipient(email("missing-at-sign"), err));+ EXPECT_FALSE(validate_recipient(email("two@[email protected]"), err));+ EXPECT_FALSE(validate_recipient(email("@nolocal.com"), err));+ EXPECT_FALSE(validate_recipient(email("nodomain@"), err));+ EXPECT_FALSE(validate_recipient(tel(std::string(300, '5')), err)) << "absurd length must not reach the phone";+}++// --- Byte stuffing -------------------------------------------------------++TEST(BMessageBuild, StuffsBodyLinesThatLookStructural) {+ const std::string out = build_bmessage({tel("+15551234567")}, "END:MSG");++ // Exactly one real terminator: the body's copy is stuffed and does not end+ // the message early.+ EXPECT_EQ(count_occurrences(out, "\r\nEND:MSG\r\n"), 1u);+ EXPECT_NE(out.find(" END:MSG"), std::string::npos);+}++TEST(BMessageBuild, StuffedBodySurvivesARoundTrip) {+ for (const std::string& body : {std::string("END:MSG"),+ std::string("BEGIN:VCARD"),+ std::string("line one\nEND:BMSG\nline three"),+ std::string(" BEGIN:MSG"),+ std::string("begin:msg")}) {+ const std::string out = build_bmessage({tel("+15551234567")}, body);+ ASSERT_FALSE(out.empty()) << body;++ BMessage parsed = parse_bmessage(out);+ EXPECT_TRUE(parsed.valid) << body;+ EXPECT_EQ(parsed.body, body) << "body must survive stuffing and unstuffing unchanged";+ EXPECT_EQ(parsed.recipients.size(), 1u) << "a body that looks like a vCard must not become a recipient";+ }+}++TEST(BMessageBuild, PreservesUtf8Bodies) {+ const std::string body = "emoji \xF0\x9F\x92\xA9 and accents \xC3\xA9\xC3\xA8";+ BMessage parsed = parse_bmessage(build_bmessage({tel("+15551234567")}, body));++ EXPECT_TRUE(parsed.valid);+ EXPECT_EQ(parsed.body, body);+}++TEST(BMessageBuild, HandlesMultiLineAndEmptyBodies) {+ BMessage multi = parse_bmessage(build_bmessage({tel("+15551234567")}, "one\ntwo\nthree"));+ EXPECT_EQ(multi.body, "one\ntwo\nthree");++ BMessage empty = parse_bmessage(build_bmessage({tel("+15551234567")}, ""));+ EXPECT_TRUE(empty.valid);+ EXPECT_EQ(empty.body, "");+}++// --- Thread keys ---------------------------------------------------------++TEST(BMessageBuild, ParsesRecipientsFromThreadKeys) {+ Recipient out;+ std::string err;++ ASSERT_TRUE(recipient_from_thread_key("tel:+15551234567", out, err)) << err;+ EXPECT_EQ(out.kind, RecipientKind::Tel);+ EXPECT_EQ(out.address, "+15551234567");++ ASSERT_TRUE(recipient_from_thread_key("email:[email protected]", out, err)) << err;+ EXPECT_EQ(out.kind, RecipientKind::Email);+ EXPECT_EQ(out.address, "[email protected]");+}++// Group threads need their own routing rules, so replying to one must fail+// closed rather than guessing a recipient set.+TEST(BMessageBuild, RefusesThreadKeysItDoesNotUnderstand) {+ Recipient out;+ std::string err;++ EXPECT_FALSE(recipient_from_thread_key("group:weekend-trip", out, err));+ EXPECT_FALSE(err.empty());+ EXPECT_FALSE(recipient_from_thread_key("+15551234567", out, err));+ EXPECT_FALSE(recipient_from_thread_key("", out, err));+ EXPECT_FALSE(recipient_from_thread_key("tel:+1555\r\nTEL:+1999", out, err))+ << "an injected key must not pass just because its prefix is known";+}diff --git a/test/test_bt_diagnostics.cpp b/test/test_bt_diagnostics.cppnew file mode 100644index 0000000..087c079--- /dev/null+++ b/test/test_bt_diagnostics.cpp@@ -0,0 +1,139 @@+#include "tether/bluetooth/diagnostics.hpp"++#include <cstdlib>+#include <gtest/gtest.h>++using namespace tether::bluetooth;++TEST(BtDiagnostics, RedactsBareAddress) {+ Redactor r;+ EXPECT_EQ(r.text("connecting to 60:57:C8:30:6A:F7"), "connecting to <address-1>");+}++TEST(BtDiagnostics, RedactsDeviceNodeInObjectPath) {+ Redactor r;+ EXPECT_EQ(r.text("/org/bluez/hci0/dev_60_57_C8_30_6A_F7"), "/org/bluez/hci0/dev_<address-1>");+}++TEST(BtDiagnostics, SameDeviceGetsSamePlaceholderAcrossSpellings) {+ Redactor r;+ const std::string out = r.text("dev_60_57_C8_30_6A_F7 is 60:57:c8:30:6a:f7");+ EXPECT_EQ(out, "dev_<address-1> is <address-1>");+}++TEST(BtDiagnostics, DistinctDevicesGetDistinctPlaceholders) {+ Redactor r;+ const std::string out = r.text("AA:BB:CC:DD:EE:FF and 11:22:33:44:55:66");+ EXPECT_EQ(out, "<address-1> and <address-2>");+}++TEST(BtDiagnostics, RedactsEmailAndPhoneNumber) {+ Redactor r;+ EXPECT_EQ(r.text("sent to tel:+15035550101"), "sent to tel:<number-1>");+ EXPECT_EQ(r.text("sent to [email protected]"), "sent to <email-1>");+}++TEST(BtDiagnostics, LeavesTimestampsAndErrorCodesAlone) {+ Redactor r;+ const std::string out = r.text("2026-08-16T10:11:12 failed with 0x43 after 30000 ms");+ EXPECT_EQ(out, "2026-08-16T10:11:12 failed with 0x43 after 30000 ms");+}++TEST(BtDiagnostics, RedactsHomeAndRuntimeDirectories) {+ setenv("HOME", "/home/someone", 1);+ setenv("XDG_RUNTIME_DIR", "/run/user/1000", 1);+ Redactor r;+ EXPECT_EQ(r.text("staged /run/user/1000/tether/out.bmsg"), "staged <runtime>/tether/out.bmsg");+ EXPECT_EQ(r.text("wrote /home/someone/.config/tether/bluetooth.json"),+ "wrote <home>/.config/tether/bluetooth.json");+}++TEST(BtDiagnostics, RedactsRuntimeDirectoryWithoutTheEnvironmentVariable) {+ unsetenv("XDG_RUNTIME_DIR");+ Redactor r;+ EXPECT_EQ(r.text("/run/user/4242/tether/tetherd.sock"), "<runtime>/tether/tetherd.sock");+}++TEST(BtDiagnostics, DropsContentKeysRatherThanRedactingThem) {+ Redactor r;+ const nlohmann::json in = {+ {"command", "bt_message"},+ {"body", "meet me at the usual place"},+ {"sender", "Jane"},+ {"name", "Jane's iPhone"},+ {"address", "60:57:C8:30:6A:F7"},+ };++ const nlohmann::json out = r.value(in);+ EXPECT_FALSE(out.contains("body"));+ EXPECT_FALSE(out.contains("sender"));+ EXPECT_FALSE(out.contains("name"));+ EXPECT_EQ(out["address"], "<address-1>");+}++TEST(BtDiagnostics, RedactsNestedStructures) {+ Redactor r;+ const nlohmann::json in = {{"adapters", {{{"path", "/org/bluez/hci0"}, {"address", "AA:BB:CC:DD:EE:FF"}}}}};+ const nlohmann::json out = r.value(in);+ EXPECT_EQ(out["adapters"][0]["address"], "<address-1>");+ EXPECT_EQ(out["adapters"][0]["path"], "/org/bluez/hci0");+}++TEST(BtDiagnostics, TimelineKeepsOnlyStateEvents) {+ clear_diagnostic_timeline();+ record_diagnostic_event({{"command", "bt_pair_progress"}, {"step", "connect"}});+ record_diagnostic_event({{"command", "bt_message"}, {"body", "hello"}});+ record_diagnostic_event({{"command", "clipboard_updated"}, {"content", "hello"}});++ const auto timeline = diagnostic_timeline();+ ASSERT_EQ(timeline.size(), 1u);+ EXPECT_EQ(timeline[0]["command"], "bt_pair_progress");+}++TEST(BtDiagnostics, TimelineStripsContentAtRecordTime) {+ clear_diagnostic_timeline();+ record_diagnostic_event({{"command", "bt_send_result"}, {"success", true}, {"body", "secret"}});++ const auto timeline = diagnostic_timeline();+ ASSERT_EQ(timeline.size(), 1u);+ EXPECT_FALSE(timeline[0].contains("body"));+ EXPECT_TRUE(timeline[0]["success"]);+}++TEST(BtDiagnostics, TimelineIsOrderedAndMonotonic) {+ clear_diagnostic_timeline();+ record_diagnostic_event({{"command", "bt_pair_progress"}, {"step", "first"}});+ record_diagnostic_event({{"command", "bt_pair_progress"}, {"step", "second"}});++ const auto timeline = diagnostic_timeline();+ ASSERT_EQ(timeline.size(), 2u);+ EXPECT_EQ(timeline[0]["step"], "first");+ EXPECT_EQ(timeline[1]["step"], "second");+ EXPECT_LE(timeline[0]["at_ms"].get<int64_t>(), timeline[1]["at_ms"].get<int64_t>());+}++TEST(BtDiagnostics, TimelineIsBounded) {+ clear_diagnostic_timeline();+ for (int i = 0; i < 500; ++i)+ record_diagnostic_event({{"command", "bt_pair_progress"}, {"step", std::to_string(i)}});++ const auto timeline = diagnostic_timeline();+ EXPECT_EQ(timeline.size(), 200u);+ // The oldest entries are the ones dropped.+ EXPECT_EQ(timeline.back()["step"], "499");+}++TEST(BtDiagnostics, ReportCarriesNoAddressOrContent) {+ clear_diagnostic_timeline();+ record_diagnostic_event({{"command", "bt_connection_changed"},+ {"link_reason", "Connecting to 60:57:C8:30:6A:F7"},+ {"map_open", false}});++ const nlohmann::json status = {{"adapters", {{{"address", "AA:BB:CC:DD:EE:FF"}, {"name", "someone-laptop"}}}}};+ const nlohmann::json connection = {{"link_reason", "no route to 60:57:C8:30:6A:F7"}};++ const std::string dumped = build_diagnostics(status, connection).dump();+ EXPECT_EQ(dumped.find("60:57:C8:30:6A:F7"), std::string::npos);+ EXPECT_EQ(dumped.find("AA:BB:CC:DD:EE:FF"), std::string::npos);+ EXPECT_EQ(dumped.find("someone-laptop"), std::string::npos);+}diff --git a/test/test_groups.cpp b/test/test_groups.cppnew file mode 100644index 0000000..d73720a--- /dev/null+++ b/test/test_groups.cpp@@ -0,0 +1,293 @@+#include <gtest/gtest.h>+#include <tether/bluetooth/groups.hpp>++using namespace tether::bluetooth;++namespace {++ ContactStore contacts_with(const std::string& vcards) {+ ContactStore store;+ store.set(parse_vcards(vcards));+ return store;+ }++ MessageNotification notification(const std::string& sender,+ const std::string& subtitle,+ const std::string& body,+ int64_t received) {+ return MessageNotification{sender, subtitle, body, received};+ }++} // namespace++// --- Parsing the side channel -------------------------------------------++TEST(Groups, ParsesAnUnnamedGroupSubtitle) {+ GroupInfo info;+ ASSERT_TRUE(parse_group_notification("Alice", "To you & Bob", info));++ EXPECT_TRUE(info.is_group);+ EXPECT_FALSE(info.named);+ EXPECT_EQ(info.sender, "Alice");+ ASSERT_EQ(info.participants.size(), 1u);+ EXPECT_EQ(info.participants[0], "Bob") << "the user is a member but never a reply recipient";+}++TEST(Groups, ParsesLongerParticipantLists) {+ GroupInfo info;+ ASSERT_TRUE(parse_group_notification("Alice", "To you, Bob & Carol", info));+ ASSERT_EQ(info.participants.size(), 2u);+ EXPECT_EQ(info.participants[0], "Bob");+ EXPECT_EQ(info.participants[1], "Carol");++ ASSERT_TRUE(parse_group_notification("Alice", "To Bob, Carol & you", info));+ ASSERT_EQ(info.participants.size(), 2u);+}++TEST(Groups, ParsesANamedGroup) {+ GroupInfo info;+ ASSERT_TRUE(parse_group_notification("Alice", "Weekend Trip", info));++ EXPECT_TRUE(info.named);+ EXPECT_EQ(info.name, "Weekend Trip");+ EXPECT_TRUE(info.participants.empty()) << "a group name carries no member list";+}++TEST(Groups, TreatsAOneToOneNotificationAsNotAGroup) {+ GroupInfo info;+ EXPECT_FALSE(parse_group_notification("Alice", "", info));+ EXPECT_FALSE(parse_group_notification("Alice", "To you", info)) << "only the user means no other members";+}++// iOS supplies a name but no conversation identifier, so two groups sharing a+// name collapse into one local thread. That is a documented limitation, and the+// key has to make it visible rather than pretend otherwise.+TEST(Groups, NamedGroupsWithTheSameNameShareAKey) {+ GroupInfo first;+ GroupInfo second;+ ASSERT_TRUE(parse_group_notification("Alice", "Weekend Trip", first));+ ASSERT_TRUE(parse_group_notification("Bob", "weekend trip", second));++ EXPECT_EQ(group_thread_key(first), group_thread_key(second));+}++TEST(Groups, UnnamedGroupKeyDoesNotDependOnMemberOrder) {+ GroupInfo first;+ GroupInfo second;+ ASSERT_TRUE(parse_group_notification("Alice", "To you, Bob & Carol", first));+ ASSERT_TRUE(parse_group_notification("Carol", "To Bob, you & Alice", second));++ EXPECT_NE(group_thread_key(first), group_thread_key(second))+ << "different member sets are different conversations";++ GroupInfo reordered;+ ASSERT_TRUE(parse_group_notification("Alice", "To Carol, you & Bob", reordered));+ EXPECT_EQ(group_thread_key(first), group_thread_key(reordered));+}++// --- Correlation ---------------------------------------------------------++TEST(Groups, CorrelatesAMessageToItsNotification) {+ GroupCorrelator correlator;+ correlator.observe(notification("Alice", "To you & Bob", "dinner at seven", 100));++ GroupInfo info;+ EXPECT_EQ(correlator.correlate("dinner at seven", 105, info), Correlation::Matched);+ EXPECT_EQ(info.sender, "Alice");+}++// ANCS bodies are capped at what was requested, so a longer MAP body matches+// the notification as a prefix.+TEST(Groups, MatchesALongerBodyByItsPrefix) {+ GroupCorrelator correlator;+ correlator.observe(notification("Alice", "To you & Bob", "the first part of a long", 100));++ GroupInfo info;+ EXPECT_EQ(correlator.correlate("the first part of a long message that kept going", 101, info),+ Correlation::Matched);+}++TEST(Groups, IgnoresNotificationsOutsideTheWindow) {+ GroupCorrelator correlator;+ correlator.observe(notification("Alice", "To you & Bob", "hello", 100));++ GroupInfo info;+ EXPECT_EQ(correlator.correlate("hello", 100 + GROUP_CORRELATION_WINDOW_SECONDS + 1, info), Correlation::NoMatch);+}++// Two notifications carrying the same text cannot be told apart, and guessing+// would aim a reply at the wrong people.+TEST(Groups, RefusesAmbiguousRepeatedBodies) {+ GroupCorrelator correlator;+ correlator.observe(notification("Alice", "To you & Bob", "ok", 100));+ correlator.observe(notification("Carol", "Weekend Trip", "ok", 101));++ GroupInfo info;+ EXPECT_EQ(correlator.correlate("ok", 102, info), Correlation::Ambiguous);+}++TEST(Groups, ReportsNoMatchForAnUnrelatedMessage) {+ GroupCorrelator correlator;+ correlator.observe(notification("Alice", "To you & Bob", "hello", 100));++ GroupInfo info;+ EXPECT_EQ(correlator.correlate("something else entirely", 101, info), Correlation::NoMatch);+}++TEST(Groups, ExpiryDropsStaleNotifications) {+ GroupCorrelator correlator;+ correlator.observe(notification("Alice", "To you & Bob", "hello", 100));+ correlator.expire(100 + GROUP_CORRELATION_WINDOW_SECONDS + 1);+ EXPECT_EQ(correlator.size(), 0u);+}++// --- Reply routing -------------------------------------------------------++TEST(Groups, ResolvesAnUnnamedGroupWhenEveryNameIsUnambiguous) {+ auto contacts = contacts_with(+ "BEGIN:VCARD\nFN:Bob\nTEL:+15550000002\nEND:VCARD\n"+ "BEGIN:VCARD\nFN:Carol\nTEL:+15550000003\nEND:VCARD\n");++ GroupInfo info;+ ASSERT_TRUE(parse_group_notification("Alice", "To you, Bob & Carol", info));++ std::vector<Recipient> recipients;+ std::string reason;+ EXPECT_EQ(resolve_group_recipients(info, group_thread_key(info), contacts, GroupRoster{}, true, recipients, reason),+ ReplyEligibility::Allowed)+ << reason;+ EXPECT_EQ(recipients.size(), 2u);+}++// A name matching two contacts must never be resolved by picking one: the+// message would go to a stranger.+TEST(Groups, RefusesAnAmbiguousParticipantName) {+ auto contacts = contacts_with(+ "BEGIN:VCARD\nFN:Bob\nTEL:+15550000002\nEND:VCARD\n"+ "BEGIN:VCARD\nFN:Bob\nTEL:+15559999999\nEND:VCARD\n");++ GroupInfo info;+ ASSERT_TRUE(parse_group_notification("Alice", "To you & Bob", info));++ std::vector<Recipient> recipients;+ std::string reason;+ EXPECT_EQ(resolve_group_recipients(info, group_thread_key(info), contacts, GroupRoster{}, true, recipients, reason),+ ReplyEligibility::Unresolved);+ EXPECT_TRUE(recipients.empty()) << "a refused resolution must leave no partial recipient set";+}++TEST(Groups, RefusesAnUnknownParticipantName) {+ auto contacts = contacts_with("BEGIN:VCARD\nFN:Bob\nTEL:+15550000002\nEND:VCARD\n");++ GroupInfo info;+ ASSERT_TRUE(parse_group_notification("Alice", "To you, Bob & Dave", info));++ std::vector<Recipient> recipients;+ std::string reason;+ EXPECT_EQ(resolve_group_recipients(info, group_thread_key(info), contacts, GroupRoster{}, true, recipients, reason),+ ReplyEligibility::Unresolved);+ EXPECT_TRUE(recipients.empty());+}++// A named group identifies the conversation but gives no roster, so it stays+// read-only until the user provides one.+TEST(Groups, NamedGroupsAreReadOnlyWithoutARoster) {+ auto contacts = contacts_with("BEGIN:VCARD\nFN:Bob\nTEL:+15550000002\nEND:VCARD\n");++ GroupInfo info;+ ASSERT_TRUE(parse_group_notification("Alice", "Weekend Trip", info));++ std::vector<Recipient> recipients;+ std::string reason;+ EXPECT_EQ(resolve_group_recipients(info, group_thread_key(info), contacts, GroupRoster{}, true, recipients, reason),+ ReplyEligibility::NeedsRoster);+ EXPECT_TRUE(recipients.empty());+}++TEST(Groups, ARosterMakesANamedGroupRepliable) {+ GroupInfo info;+ ASSERT_TRUE(parse_group_notification("Alice", "Weekend Trip", info));+ const std::string key = group_thread_key(info);++ GroupRoster roster;+ roster.set(key, {"tel:+15550000002", "email:[email protected]"});++ std::vector<Recipient> recipients;+ std::string reason;+ EXPECT_EQ(resolve_group_recipients(info, key, ContactStore{}, roster, true, recipients, reason),+ ReplyEligibility::Allowed)+ << reason;+ ASSERT_EQ(recipients.size(), 2u);+ EXPECT_EQ(recipients[0].kind, RecipientKind::Tel);+ EXPECT_EQ(recipients[1].kind, RecipientKind::Email);+}++// The roster is user-supplied text, and it lands in a bMessage as structure.+TEST(Groups, RefusesARosterEntryThatCouldInjectARecipient) {+ GroupInfo info;+ ASSERT_TRUE(parse_group_notification("Alice", "Weekend Trip", info));+ const std::string key = group_thread_key(info);++ GroupRoster roster;+ roster.set(key, {"tel:+1555\r\nTEL:+15559999999"});++ std::vector<Recipient> recipients;+ std::string reason;+ EXPECT_EQ(resolve_group_recipients(info, key, ContactStore{}, roster, true, recipients, reason),+ ReplyEligibility::Unresolved);+ EXPECT_TRUE(recipients.empty());+}++// Group membership lives only in memory, so after a restart a group thread has+// no known members until the phone sends another message. Replying then would+// be routing to nobody, and must not silently succeed.+TEST(Groups, AnUnidentifiedThreadCannotBeRepliedTo) {+ std::vector<Recipient> recipients;+ std::string reason;+ EXPECT_EQ(resolve_group_recipients(+ GroupInfo{}, "group:name:weekend-trip", ContactStore{}, GroupRoster{}, true, recipients, reason),+ ReplyEligibility::NeedsRoster);+ EXPECT_TRUE(recipients.empty());+ EXPECT_FALSE(reason.empty());+}++TEST(Groups, RepliesAreOffUntilEnabled) {+ GroupInfo info;+ ASSERT_TRUE(parse_group_notification("Alice", "To you & Bob", info));++ std::vector<Recipient> recipients;+ std::string reason;+ EXPECT_EQ(+ resolve_group_recipients(info, group_thread_key(info), ContactStore{}, GroupRoster{}, false, recipients, reason),+ ReplyEligibility::Disabled);+}++// iOS reports nothing when a member is silently added, so an unfamiliar sender+// is the only evidence that a roster has gone stale.+TEST(Groups, AnUnknownSenderInvalidatesTheRoute) {+ std::vector<Recipient> recipients{{RecipientKind::Tel, "+15550000002"},+ {RecipientKind::Tel, "+15550000003"}};++ EXPECT_FALSE(sender_invalidates_route("tel:+15550000002", recipients));+ EXPECT_TRUE(sender_invalidates_route("tel:+15557654321", recipients));+ EXPECT_TRUE(sender_invalidates_route("email:[email protected]", recipients));+}++TEST(Groups, RosterSurvivesARoundTrip) {+ GroupRoster roster;+ roster.set("group:name:weekend-trip", {"tel:+15550000002"});++ GroupRoster restored = GroupRoster::deserialize(roster.serialize());+ const auto* addresses = restored.find("group:name:weekend-trip");+ ASSERT_NE(addresses, nullptr);+ ASSERT_EQ(addresses->size(), 1u);+ EXPECT_EQ((*addresses)[0], "tel:+15550000002");+}++// A corrupt roster must leave groups read-only rather than routing a reply to+// whatever happened to survive parsing.+TEST(Groups, CorruptRosterResolvesToNothing) {+ EXPECT_TRUE(GroupRoster::deserialize("{not json").empty());+ EXPECT_TRUE(GroupRoster::deserialize("[]").empty());+ EXPECT_TRUE(GroupRoster::deserialize("").empty());+}diff --git a/test/test_journal.cpp b/test/test_journal.cppnew file mode 100644index 0000000..47feec6--- /dev/null+++ b/test/test_journal.cpp@@ -0,0 +1,98 @@+#include <gtest/gtest.h>+#include <tether/bluetooth/journal.hpp>++using namespace tether::bluetooth;++namespace {++ Message make(const std::string& handle, int64_t timestamp, const std::string& body = "hi") {+ Message m;+ m.handle = handle;+ m.thread_key = "tel:+15551234567";+ m.peer_address = "+15551234567";+ m.body = body;+ m.timestamp = timestamp;+ m.folder = "inbox";+ return m;+ }++ constexpr int64_t NOW = 1786848300;+ constexpr int64_t DAY = 24 * 3600;++} // namespace++TEST(Journal, RoundTripsAMessage) {+ Message original = make("/msg/1", NOW, "hello \xF0\x9F\x92\xA9");+ original.read = true;+ original.outgoing = true;++ Message restored;+ ASSERT_TRUE(deserialize_message_line(serialize_message_line(original), restored));+ EXPECT_EQ(restored, original);+}++TEST(Journal, SerializesToASingleLine) {+ const std::string line = serialize_message_line(make("/msg/1", NOW, "two\nlines"));+ EXPECT_EQ(line.find('\n'), std::string::npos) << "an embedded newline would split one record into two";+}++// One bad write must not cost the whole history, so unreadable lines are+// skipped rather than aborting the load.+TEST(Journal, RejectsMalformedLines) {+ Message out;+ EXPECT_FALSE(deserialize_message_line("", out));+ EXPECT_FALSE(deserialize_message_line("{not json", out));+ EXPECT_FALSE(deserialize_message_line("[]", out));+ EXPECT_FALSE(deserialize_message_line("{\"body\":\"orphan\"}", out)) << "no handle means it can never dedupe";+ EXPECT_FALSE(deserialize_message_line("{\"handle\":\"/m/1\"}", out)) << "no thread key means it belongs nowhere";+}++TEST(Journal, RetentionDropsMessagesPastTheAgeLimit) {+ std::vector<Message> messages{+ make("/msg/old", NOW - 120 * DAY),+ make("/msg/recent", NOW - DAY),+ };++ auto kept = apply_retention(messages, NOW);+ ASSERT_EQ(kept.size(), 1u);+ EXPECT_EQ(kept[0].handle, "/msg/recent");+}++TEST(Journal, RetentionKeepsTheNewestWhenOverCount) {+ std::vector<Message> messages;+ for (int i = 0; i < 10; ++i)+ messages.push_back(make("/msg/" + std::to_string(i), NOW - (10 - i)));++ auto kept = apply_retention(messages, NOW, 3);+ ASSERT_EQ(kept.size(), 3u);+ EXPECT_EQ(kept[0].handle, "/msg/7");+ EXPECT_EQ(kept[2].handle, "/msg/9");+}++// MAP sometimes supplies no usable timestamp. Treating zero as 1970 would evict+// those messages instantly, which is worse than keeping them.+TEST(Journal, RetentionKeepsUndatedMessages) {+ std::vector<Message> messages{make("/msg/undated", 0)};++ auto kept = apply_retention(messages, NOW);+ ASSERT_EQ(kept.size(), 1u);+ EXPECT_EQ(kept[0].handle, "/msg/undated");+}++TEST(Journal, RetentionIsANoOpUnderBothLimits) {+ std::vector<Message> messages{make("/msg/1", NOW - DAY), make("/msg/2", NOW)};+ EXPECT_EQ(apply_retention(messages, NOW).size(), 2u);+}++// The journal is append-only and a reconnect re-lists everything, so the same+// message is written more than once. Without collapsing, history doubles on+// every reconnect.+TEST(Journal, RetentionCollapsesRepeatedHandles) {+ Message first = make("/msg/1", NOW);+ Message again = make("/msg/1", NOW);+ again.read = true;++ auto kept = apply_retention({first, again}, NOW);+ ASSERT_EQ(kept.size(), 1u);+ EXPECT_TRUE(kept[0].read) << "the newest copy carries the current read state";+}diff --git a/test/test_vcard.cpp b/test/test_vcard.cppnew file mode 100644index 0000000..8170f5e--- /dev/null+++ b/test/test_vcard.cpp@@ -0,0 +1,167 @@+#include <gtest/gtest.h>+#include <tether/bluetooth/contacts.hpp>+#include <tether/bluetooth/messages.hpp>+#include <tether/bluetooth/vcard.hpp>++using namespace tether::bluetooth;++TEST(VCard, ParsesNameTelAndEmail) {+ auto cards = parse_vcards(+ "BEGIN:VCARD\r\n"+ "VERSION:3.0\r\n"+ "FN:Ada Lovelace\r\n"+ "TEL;TYPE=CELL:+15551234567\r\n"+ "EMAIL;TYPE=INTERNET:[email protected]\r\n"+ "END:VCARD\r\n");++ ASSERT_EQ(cards.size(), 1u);+ EXPECT_EQ(cards[0].name, "Ada Lovelace");+ ASSERT_EQ(cards[0].tels.size(), 1u);+ EXPECT_EQ(cards[0].tels[0], "+15551234567");+ ASSERT_EQ(cards[0].emails.size(), 1u);+ EXPECT_EQ(cards[0].emails[0], "[email protected]");+}++// A contact reachable at several numbers is the normal case, not an edge case:+// keeping only the first would silently lose the address a thread is keyed on.+TEST(VCard, KeepsEveryTelAndEmail) {+ auto cards = parse_vcards(+ "BEGIN:VCARD\n"+ "FN:Grace Hopper\n"+ "TEL;TYPE=CELL:+15550000001\n"+ "TEL;TYPE=HOME:+15550000002\n"+ "EMAIL:[email protected]\n"+ "EMAIL:[email protected]\n"+ "END:VCARD\n");++ ASSERT_EQ(cards.size(), 1u);+ EXPECT_EQ(cards[0].tels.size(), 2u);+ EXPECT_EQ(cards[0].emails.size(), 2u);+}++TEST(VCard, ParsesMultipleCards) {+ auto cards = parse_vcards(+ "BEGIN:VCARD\nFN:One\nTEL:+1555000001\nEND:VCARD\n"+ "BEGIN:VCARD\nFN:Two\nTEL:+1555000002\nEND:VCARD\n");++ ASSERT_EQ(cards.size(), 2u);+ EXPECT_EQ(cards[0].name, "One");+ EXPECT_EQ(cards[1].name, "Two");+}++// RFC 2425 folding splits long values across lines; without unfolding, a long+// name or address is silently truncated at the fold.+TEST(VCard, UnfoldsContinuationLines) {+ auto cards = parse_vcards(+ "BEGIN:VCARD\r\n"+ "FN:A Very Long Contact\r\n"+ " Name Indeed\r\n"+ "TEL:+1555\r\n"+ " 0000001\r\n"+ "END:VCARD\r\n");++ ASSERT_EQ(cards.size(), 1u);+ EXPECT_EQ(cards[0].name, "A Very Long Contact Name Indeed");+ ASSERT_EQ(cards[0].tels.size(), 1u);+ EXPECT_EQ(cards[0].tels[0], "+15550000001");+}++TEST(VCard, FallsBackToStructuredName) {+ auto cards = parse_vcards("BEGIN:VCARD\nN:Lovelace;Ada;;;\nTEL:+1555\nEND:VCARD\n");++ ASSERT_EQ(cards.size(), 1u);+ EXPECT_EQ(cards[0].name, "Ada Lovelace");+}++TEST(VCard, PrefersFormattedNameOverStructured) {+ auto cards = parse_vcards("BEGIN:VCARD\nN:Lovelace;Ada;;;\nFN:Countess Ada\nTEL:+1555\nEND:VCARD\n");++ ASSERT_EQ(cards.size(), 1u);+ EXPECT_EQ(cards[0].name, "Countess Ada");+}++TEST(VCard, UnescapesValues) {+ auto cards = parse_vcards("BEGIN:VCARD\nFN:Smith\\, Alice\nTEL:+1555\nEND:VCARD\n");++ ASSERT_EQ(cards.size(), 1u);+ EXPECT_EQ(cards[0].name, "Smith, Alice");+}++TEST(VCard, IgnoresMalformedInput) {+ EXPECT_TRUE(parse_vcards("").empty());+ EXPECT_TRUE(parse_vcards("not a vcard at all").empty());+ EXPECT_TRUE(parse_vcards("BEGIN:VCARD\nEND:VCARD\n").empty()) << "an empty card carries nothing to store";+}++// A card cut off mid-transfer should still yield what it had rather than+// swallowing the card that follows it.+TEST(VCard, RecoversFromUnterminatedCard) {+ auto cards = parse_vcards(+ "BEGIN:VCARD\nFN:First\nTEL:+1555000001\n"+ "BEGIN:VCARD\nFN:Second\nTEL:+1555000002\nEND:VCARD\n");++ ASSERT_EQ(cards.size(), 2u);+ EXPECT_EQ(cards[0].name, "First");+ EXPECT_EQ(cards[1].name, "Second");+}++TEST(ContactStore, ResolvesNamesByTelAndEmail) {+ ContactStore store;+ store.set(parse_vcards("BEGIN:VCARD\nFN:Ada\nTEL:+1 (555) 123-4567\nEMAIL:[email protected]\nEND:VCARD\n"));++ EXPECT_EQ(store.name_for("tel:+15551234567"), "Ada");+ EXPECT_EQ(store.name_for("email:[email protected]"), "Ada");+ EXPECT_EQ(store.name_for("tel:+15559999999"), "");+}++// Tether never invents a country code, so the two forms stay distinct keys. A+// contact stored one way must not silently label the other.+TEST(ContactStore, DoesNotEquateNationalAndE164Forms) {+ ContactStore store;+ store.set(parse_vcards("BEGIN:VCARD\nFN:Ada\nTEL:+15551234567\nEND:VCARD\n"));++ EXPECT_EQ(store.name_for("tel:+15551234567"), "Ada");+ EXPECT_EQ(store.name_for("tel:5551234567"), "");+}++TEST(ContactStore, SurvivesJsonRoundTrip) {+ ContactStore store;+ store.set(parse_vcards("BEGIN:VCARD\nFN:Ada\nTEL:+15551234567\nEMAIL:[email protected]\nEND:VCARD\n"));++ ContactStore restored = deserialize_contacts(serialize_contacts(store));+ EXPECT_EQ(restored.size(), store.size());+ EXPECT_EQ(restored.name_for("tel:+15551234567"), "Ada");+ EXPECT_EQ(restored.name_for("email:[email protected]"), "Ada");+}++TEST(ContactStore, CorruptCacheYieldsEmptyStore) {+ EXPECT_EQ(deserialize_contacts("{not json").size(), 0u);+ EXPECT_EQ(deserialize_contacts("").size(), 0u);+}++// A contact with no name still contributes nothing to display, but must not+// index an empty label over a valid one.+TEST(ContactStore, SkipsUnnamedContacts) {+ ContactStore store;+ store.set(parse_vcards("BEGIN:VCARD\nTEL:+15551234567\nEND:VCARD\n"));++ EXPECT_EQ(store.name_for("tel:+15551234567"), "");+}++// A re-listing after reconnect carries the same message under a new object path.+// The store must adopt the new path, or acting on the message uses a dead one.+TEST(MessageStore, RefreshesObjectPathOnRelist) {+ MessageStore store;+ Message first;+ first.handle = "42";+ first.thread_key = "tel:+15551234567";+ first.object_path = "/org/bluez/obex/client/session5/message42";+ EXPECT_TRUE(store.add(first));++ Message again = first;+ again.object_path = "/org/bluez/obex/client/session11/message42";+ EXPECT_FALSE(store.add(again)) << "same handle is still a duplicate";++ ASSERT_NE(store.find("42"), nullptr);+ EXPECT_EQ(store.find("42")->object_path, "/org/bluez/obex/client/session11/message42");+}