Skip to content

Linux + iPhone Continuity / iMessage / SMS

experiment: bluetooth + imessage (#9)

Zack Bartelc7cc76545be6
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 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(
json
GIT_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(
googletest
GIT_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_BINARY
install(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 available
option(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}")
# DEB
set(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/PKGBUILD
index 9f07a92..f83863c 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -1,11 +1,11 @@
pkgname=tether-git
pkgver=r1.1234
pkgrel=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.md
index 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 Transfer
Drag 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 Pairing
Securely 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`) ensuri
5. **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 support
diff --git a/docs/BLUETOOTH.md b/docs/BLUETOOTH.md
new file mode 100644
index 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.md
index 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.md
index 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 request
diff --git a/extension/build.sh b/extension/build.sh
index 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.json
index 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.json
index 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": {
- "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.json
index 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.json
index 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 file
diff --git a/extension/src/mail/extractor.js b/extension/src/mail/extractor.js
index 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 100644
index 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.service
diff --git a/scripts/bt-probe.sh b/scripts/bt-probe.sh
new file mode 100755
index 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 0
diff --git a/src/cli/main.cpp b/src/cli/main.cpp
index 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.txt
index 247bc47..d137478 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -9,6 +9,29 @@ add_library(tether STATIC
src/crypto.cpp
src/client.cpp
src/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.cpp
src/wayland.cpp
src/wayland_protocols/wayland.cpp
src/wayland_protocols/wlr-data-control-unstable-v1.cpp
diff --git a/src/core/include/tether/bluetooth/advert.hpp b/src/core/include/tether/bluetooth/advert.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/agent.hpp b/src/core/include/tether/bluetooth/agent.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/ancs/client.hpp b/src/core/include/tether/bluetooth/ancs/client.hpp
new file mode 100644
index 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::ancs
diff --git a/src/core/include/tether/bluetooth/ancs/notifications.hpp b/src/core/include/tether/bluetooth/ancs/notifications.hpp
new file mode 100644
index 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::ancs
diff --git a/src/core/include/tether/bluetooth/ancs/parser.hpp b/src/core/include/tether/bluetooth/ancs/parser.hpp
new file mode 100644
index 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::ancs
diff --git a/src/core/include/tether/bluetooth/ancs/protocol.hpp b/src/core/include/tether/bluetooth/ancs/protocol.hpp
new file mode 100644
index 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::ancs
diff --git a/src/core/include/tether/bluetooth/ancs/sequencer.hpp b/src/core/include/tether/bluetooth/ancs/sequencer.hpp
new file mode 100644
index 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::ancs
diff --git a/src/core/include/tether/bluetooth/bearer_supervisor.hpp b/src/core/include/tether/bluetooth/bearer_supervisor.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/bmessage.hpp b/src/core/include/tether/bluetooth/bmessage.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/config.hpp b/src/core/include/tether/bluetooth/config.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/connection.hpp b/src/core/include/tether/bluetooth/connection.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/contacts.hpp b/src/core/include/tether/bluetooth/contacts.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/diagnostics.hpp b/src/core/include/tether/bluetooth/diagnostics.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/groups.hpp b/src/core/include/tether/bluetooth/groups.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/journal.hpp b/src/core/include/tether/bluetooth/journal.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/map_session.hpp b/src/core/include/tether/bluetooth/map_session.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/messages.hpp b/src/core/include/tether/bluetooth/messages.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/monitor.hpp b/src/core/include/tether/bluetooth/monitor.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/obex_transfer.hpp b/src/core/include/tether/bluetooth/obex_transfer.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/objects.hpp b/src/core/include/tether/bluetooth/objects.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/pairing.hpp b/src/core/include/tether/bluetooth/pairing.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/pbap_session.hpp b/src/core/include/tether/bluetooth/pbap_session.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/profile_supervisor.hpp b/src/core/include/tether/bluetooth/profile_supervisor.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/bluetooth/vcard.hpp b/src/core/include/tether/bluetooth/vcard.hpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/include/tether/net.hpp b/src/core/include/tether/net.hpp
index 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.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/agent.cpp b/src/core/src/bluetooth/agent.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/ancs/client.cpp b/src/core/src/bluetooth/ancs/client.cpp
new file mode 100644
index 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::ancs
diff --git a/src/core/src/bluetooth/ancs/notifications.cpp b/src/core/src/bluetooth/ancs/notifications.cpp
new file mode 100644
index 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::ancs
diff --git a/src/core/src/bluetooth/ancs/parser.cpp b/src/core/src/bluetooth/ancs/parser.cpp
new file mode 100644
index 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::ancs
diff --git a/src/core/src/bluetooth/ancs/sequencer.cpp b/src/core/src/bluetooth/ancs/sequencer.cpp
new file mode 100644
index 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::ancs
diff --git a/src/core/src/bluetooth/bearer_supervisor.cpp b/src/core/src/bluetooth/bearer_supervisor.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/bmessage.cpp b/src/core/src/bluetooth/bmessage.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/config.cpp b/src/core/src/bluetooth/config.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/connection.cpp b/src/core/src/bluetooth/connection.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/contacts.cpp b/src/core/src/bluetooth/contacts.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/diagnostics.cpp b/src/core/src/bluetooth/diagnostics.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/groups.cpp b/src/core/src/bluetooth/groups.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/journal.cpp b/src/core/src/bluetooth/journal.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/map_session.cpp b/src/core/src/bluetooth/map_session.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/messages.cpp b/src/core/src/bluetooth/messages.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/monitor.cpp b/src/core/src/bluetooth/monitor.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/obex_transfer.cpp b/src/core/src/bluetooth/obex_transfer.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/objects.cpp b/src/core/src/bluetooth/objects.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/pairing.cpp b/src/core/src/bluetooth/pairing.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/pbap_session.cpp b/src/core/src/bluetooth/pbap_session.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/profile_supervisor.cpp b/src/core/src/bluetooth/profile_supervisor.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/bluetooth/vcard.cpp b/src/core/src/bluetooth/vcard.cpp
new file mode 100644
index 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::bluetooth
diff --git a/src/core/src/net.cpp b/src/core/src/net.cpp
index 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.cpp
index 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()); },
+ [&notifier](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(
+ [&notifier](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.cpp
index 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.hpp
index 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.txt
index 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-gtk
main.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.cpp
new file mode 100644
index 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::ui
diff --git a/src/gtk/daemon_client.hpp b/src/gtk/daemon_client.hpp
new file mode 100644
index 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::ui
diff --git a/src/gtk/devices_view.cpp b/src/gtk/devices_view.cpp
new file mode 100644
index 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::ui
diff --git a/src/gtk/devices_view.hpp b/src/gtk/devices_view.hpp
new file mode 100644
index 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::ui
diff --git a/src/gtk/main.cpp b/src/gtk/main.cpp
index 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");
}
+
} // namespace
int 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.cpp
new file mode 100644
index 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::ui
diff --git a/src/gtk/messages_view.hpp b/src/gtk/messages_view.hpp
new file mode 100644
index 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::ui
diff --git a/src/gtk/notifications_view.cpp b/src/gtk/notifications_view.cpp
new file mode 100644
index 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::ui
diff --git a/src/gtk/notifications_view.hpp b/src/gtk/notifications_view.hpp
new file mode 100644
index 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::ui
diff --git a/src/gtk/ui_util.cpp b/src/gtk/ui_util.cpp
new file mode 100644
index 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::ui
diff --git a/src/gtk/ui_util.hpp b/src/gtk/ui_util.hpp
new file mode 100644
index 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::ui
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 72f34d2..75ca1ac 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,5 +1,16 @@
add_executable(tether_test
test_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.cpp
test_crypto.cpp
test_discovery.cpp
test_file_transfer.cpp
diff --git a/test/test_ancs_parser.cpp b/test/test_ancs_parser.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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");
+}