diff --git a/CLAUDE.md b/CLAUDE.md index bbf238c..e48ec3e 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -22,10 +22,18 @@ Where his data lives: `content://mms`, the telephony provider), which bubble reads and writes as the default SMS app. Don't query it over adb, and don't make an app the default SMS app yourself (it hands that app his texts). +- jai: `~/Documents/bubble-server/data/` (the relay's mailbox and token). + Everything in relay.db is sealed, but it's still his messages: don't read + it, and never print the token (`scripts/deploy-jai.sh --token` is for trav). + The desktop keeps the relay's address, token and key in + `~/.config/voip.ms Messages/relay.bin`. Test with fake data only: - Desktop: `VOIPMS_SANDBOX=/tmp/x npm run dev`. +- Relay: `server/test_bubble_relay.py` and `test/relay.test.ts` run a throwaway + local server; `DEVICE=1 npm test -- test/relay.device.test.ts` drives the dev + app on a plugged-in Rabbit through `adb reverse`. Never test against jai's. - Android: the dev app `me.teafry.voipmessages.dev` (`python3 android/build.py --dev --install`, then `python3 android/tools/push_sandbox.py` for made-up conversations). diff --git a/README.md b/README.md index 1aa281a..1bfd795 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,8 @@ A Signal Desktop–style SMS client for [voip.ms](https://voip.ms). It keeps you - **MMS**: photos, video and audio appear inline in the chat. Click a photo to view it full size or save it. You can attach up to 3 files with the paperclip, by drag-and-drop, or by pasting. Photos too big for voip.ms (the budget is 900 KB each) are shrunk automatically before sending. - **Emoji shortcodes**: type `:` and at least two letters, for example `:jo`, to get matching emoji. Pick one with ↑/↓ and Tab/Enter or by clicking it; Esc closes the list. A finished `:joy:` converts on its own. The shortcodes are Signal's and Slack's, from [emoji-datasource](https://github.com/iamcal/emoji-data); `npm run gen:emoji` regenerates them. - Alt+↑/↓ moves between conversations. -- Ctrl +/− zooms and Ctrl 0 resets. Choose Light, Dark, or System under Settings → Appearance. +- Ctrl +/− zooms and Ctrl 0 resets. Choose Light, Dark, or System under Settings → Appearance, and the dark or inverted (lighter) icon. +- **The Rabbit's SIM, from here** (Settings → Rabbit relay): with bubble as the Rabbit R1's texting app, its SIM is a third number to text from ("Rabbit SIM"), its texts show up here, and chat names and read/unread/archived stay in step with the Rabbit, no cable needed. It goes through a small relay on jai (`server/bubble_relay.py`, deployed with `scripts/deploy-jai.sh`), which only ever holds AES-256-GCM-sealed messages: the key lives on this computer and the Rabbit, never on jai. A text sent from here goes out at the Rabbit's next background check, so it can take a while; older photos come over when you open them. ## Where your data lives @@ -25,6 +26,7 @@ A Signal Desktop–style SMS client for [voip.ms](https://voip.ms). It keeps you | MMS photos and attachments (cached on arrival) | `~/Documents/voipms-desktop-data/media/` | ✅ | | API password | GNOME Keyring (via Electron `safeStorage`) → `~/.config/voipms-desktop/credentials.bin` | ❌ on purpose; you re-enter it after a restore | | Contact photo cache | `~/.config/voipms-desktop/photo-cache/` | ❌ not needed | +| Rabbit relay address, token and key | GNOME Keyring → `~/.config/voip.ms Messages/relay.bin` | ❌ on purpose; reconnect and Sync to Rabbit after a restore | The snapshots are consistent SQLite copies, made daily and whenever you quit. So even if a backup catches the live database halfway through a write, the backup still holds a clean, restorable copy. To move the data folder, go to Settings → Storage → Move…. If you point it at a folder that already holds a `messages.db`, for example one restored from backup, the app uses that history. @@ -38,6 +40,12 @@ In the voip.ms portal, go to **Main Menu → SOAP & REST/JSON API** and: Then launch the app and enter your account email and API password. +### The Rabbit relay (optional) + +1. `scripts/deploy-jai.sh` puts the relay on jai (its own folder, port 8080 on the tailscale address only); `scripts/deploy-jai.sh --token` prints its token. +2. Settings → Rabbit relay: paste the token, Connect. +3. Plug in the Rabbit and press Sync to Rabbit once: that hands it the address, token and the sealing key. + ### Apple-style emoji (optional) To look like Signal, the app uses an `Apple Color Emoji` font when one is installed, and falls back to Noto Color Emoji otherwise. To install it for your user only (about 116 MB): diff --git a/android/README.md b/android/README.md index d50738c..8d56bf5 100644 --- a/android/README.md +++ b/android/README.md @@ -87,5 +87,16 @@ Install/Sync buttons then target the dev app with the sandbox's made-up data. side, through `MmsFiles`. Long texts go as multipart SMS; photos, voice notes and group chats as MMS (needs mobile data on). The dev app's sandbox never uses the SIM. +- Relay (`Relay`, `RelayJob`): the desktop's link through jai (its + `src/main/relay.ts`, server `server/bubble_relay.py`). config.json's `relay` + (address, token, AES-256-GCM key) comes from Sync to Rabbit. The SIM's + messages go to the desktop, sends typed there go out here (each one at most + once, and not after a day), chat names and read status go both ways, and + older photos are sent when the desktop asks. For the battery it has no timer + of its own: it rides along with `PollJob`'s checks, plus one network job a few + seconds after something happens here (a text in, a send done, a swipe or + rename), and a catch-up when the app is opened (at most once a minute). Plain + http is allowed only to jai's tailscale address and localhost + (`res/xml/network_security_config.xml`). - The scroll wheel is left alone: it stays the volume control (and volume down + the side button still takes a screenshot). diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml index 03c763f..2185e50 100644 --- a/android/app/src/main/AndroidManifest.xml +++ b/android/app/src/main/AndroidManifest.xml @@ -29,7 +29,7 @@ android:icon="@drawable/ic_launcher" android:theme="@android:style/Theme.DeviceDefault.NoActionBar" android:allowBackup="false" - android:usesCleartextTraffic="false"> + android:networkSecurityConfig="@xml/network_security_config"> + diff --git a/android/app/src/main/java/me/teafry/voipmessages/Config.java b/android/app/src/main/java/me/teafry/voipmessages/Config.java index b9d0ed6..d694a46 100644 --- a/android/app/src/main/java/me/teafry/voipmessages/Config.java +++ b/android/app/src/main/java/me/teafry/voipmessages/Config.java @@ -53,6 +53,9 @@ final class Config { final List dids = new CopyOnWriteArrayList<>(); private boolean hasSim; String defaultDid; + /** The relay through jai (Relay.java): address, bearer token, and the 32-byte key that seals everything. */ + String relayUrl, relayToken; + byte[] relayKey; /** Made-up data for testing (android/tools/push_sandbox.py): never goes online. */ boolean sandbox; private final File file; @@ -120,6 +123,17 @@ final class Config { } if (cfg.gvNumber != null && !cfg.gvNumber.isEmpty()) cfg.dids.add(new Did(cfg.gvNumber, "Google Voice", true)); cfg.defaultDid = o.optString("defaultDid", null); + JSONObject r = o.optJSONObject("relay"); + if (r != null) { + String url = r.optString("url", ""), token = r.optString("token", ""); + byte[] key = android.util.Base64.decode(r.optString("key", ""), android.util.Base64.DEFAULT); + // Only the addresses network_security_config lets through, and a real key. + if (url.matches("http://(100\\.\\d+\\.\\d+\\.\\d+|127\\.0\\.0\\.1)(:\\d+)?|https://[^/]+") && !token.isEmpty() && key.length == 32) { + cfg.relayUrl = url; + cfg.relayToken = token; + cfg.relayKey = key; + } + } cfg.sandbox = o.optBoolean("sandbox", false); } catch (IOException | JSONException e) { cfg.raw = new JSONObject(); diff --git a/android/app/src/main/java/me/teafry/voipmessages/MainActivity.java b/android/app/src/main/java/me/teafry/voipmessages/MainActivity.java index a88fd9c..20c288b 100644 --- a/android/app/src/main/java/me/teafry/voipmessages/MainActivity.java +++ b/android/app/src/main/java/me/teafry/voipmessages/MainActivity.java @@ -148,6 +148,8 @@ public final class MainActivity extends BaseActivity { refresh(); } + private static long lastRelay; + private void refresh() { bg.execute(() -> { Sync.poll(this); @@ -269,6 +271,10 @@ public final class MainActivity extends BaseActivity { bg.execute(() -> { StateSync.importPending(this); Sim.syncSoon(this); + if (System.currentTimeMillis() - lastRelay > 60_000) { + lastRelay = System.currentTimeMillis(); + Relay.soon(this); + } List fresh = Store.get(this).conversations(null); Contacts.all(this); // load names here, not on the main thread while drawing rows runOnUiThread(() -> { diff --git a/android/app/src/main/java/me/teafry/voipmessages/Relay.java b/android/app/src/main/java/me/teafry/voipmessages/Relay.java new file mode 100644 index 0000000..c6c0ac1 --- /dev/null +++ b/android/app/src/main/java/me/teafry/voipmessages/Relay.java @@ -0,0 +1,399 @@ +package me.teafry.voipmessages; + +import android.app.job.JobInfo; +import android.app.job.JobScheduler; +import android.content.ComponentName; +import android.content.Context; +import android.content.SharedPreferences; +import android.database.Cursor; +import android.graphics.BitmapFactory; +import android.util.Base64; +import android.util.Log; + +import org.json.JSONArray; +import org.json.JSONObject; + +import java.io.File; +import java.nio.charset.StandardCharsets; +import java.security.SecureRandom; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.crypto.Cipher; +import javax.crypto.spec.GCMParameterSpec; +import javax.crypto.spec.SecretKeySpec; + +/** + * The relay through jai (the desktop's src/main/relay.ts; server in + * server/bubble_relay.py): the SIM's texts go to the desktop, texts typed + * there go out over the SIM here, and chat names and read/unread/archived + * stay in step without a cable. + * + * Everything is AES-256-GCM sealed with the key the desktop handed over USB + * (config.json "relay"); jai only passes blobs on. It runs with the checks + * the Rabbit already makes (PollJob) plus one network job after something + * happens here (a text, a send, a swipe), never on a timer of its own: the + * battery pays for nothing new while nothing's going on. + */ +final class Relay { + private Relay() {} + + private static final String TAG = "Relay"; + private static final int JOB_ID = 2; + private static final Object LOCK = new Object(); + private static final SecureRandom random = new SecureRandom(); + + /** A send from the desktop that waited longer than this isn't sent any more. */ + private static final long MAX_SEND_AGE = 24 * 3600_000L; + private static final int MSG_CHUNK = 300; + private static final int MAX_PUSH = 7 * 1024 * 1024; + /** New messages carry their photos; older ones (the first copy of the history) send them when asked. */ + private static final long INLINE_RECENT = 2 * 86_400_000L; + + static boolean configured(Config cfg) { + return cfg.relayUrl != null && cfg.relayToken != null && cfg.relayKey != null; + } + + private static SharedPreferences prefs(Context c) { + return c.getSharedPreferences("relay", Context.MODE_PRIVATE); + } + + // ---- sealing (relay.ts seal/unseal) ---- + static String seal(byte[] key, String author, JSONObject payload) throws Exception { + byte[] nonce = new byte[12]; + random.nextBytes(nonce); + Cipher ci = Cipher.getInstance("AES/GCM/NoPadding"); + ci.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, "AES"), new GCMParameterSpec(128, nonce)); + ci.updateAAD(("bubble-relay/1/" + author).getBytes(StandardCharsets.UTF_8)); + byte[] ct = ci.doFinal(payload.toString().getBytes(StandardCharsets.UTF_8)); + byte[] out = new byte[1 + 12 + ct.length]; + out[0] = 1; + System.arraycopy(nonce, 0, out, 1, 12); + System.arraycopy(ct, 0, out, 13, ct.length); + return Base64.encodeToString(out, Base64.NO_WRAP); + } + + /** Null for anything not sealed with our key by `author`. */ + static JSONObject unseal(byte[] key, String author, String blob) { + try { + byte[] b = Base64.decode(blob, Base64.DEFAULT); + if (b.length < 1 + 12 + 16 || b[0] != 1) return null; + Cipher ci = Cipher.getInstance("AES/GCM/NoPadding"); + ci.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, "AES"), new GCMParameterSpec(128, b, 1, 12)); + ci.updateAAD(("bubble-relay/1/" + author).getBytes(StandardCharsets.UTF_8)); + return new JSONObject(new String(ci.doFinal(b, 13, b.length - 13), StandardCharsets.UTF_8)); + } catch (Exception e) { + return null; + } + } + + // ---- what's waiting to go ---- + + /** Names or read/unread/archived changed here (StateSync): tell the desktop soon. */ + static void stateChanged(Context c) { + if (!configured(Config.get(c))) return; + prefs(c).edit().putBoolean("stateDirty", true).apply(); + soon(c); + } + + /** Something to tell the desktop: one network job, a few seconds out so a burst shares it. */ + static void soon(Context c) { + if (!configured(Config.get(c))) return; + JobInfo job = new JobInfo.Builder(JOB_ID, new ComponentName(c, RelayJob.class)) + .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY) + .setMinimumLatency(5000) + .build(); + c.getSystemService(JobScheduler.class).schedule(job); + } + + private static synchronized void addToList(Context c, String key, JSONObject item) { + try { + JSONArray a = new JSONArray(prefs(c).getString(key, "[]")); + a.put(item); + prefs(c).edit().putString(key, a.toString()).commit(); + } catch (Exception ignored) { + } + } + + private static synchronized JSONArray takeList(Context c, String key, int count) { + try { + JSONArray a = new JSONArray(prefs(c).getString(key, "[]")); + JSONArray rest = new JSONArray(); + for (int i = count; i < a.length(); i++) rest.put(a.get(i)); + prefs(c).edit().putString(key, rest.toString()).commit(); + return a; + } catch (Exception e) { + return new JSONArray(); + } + } + + private static JSONArray peekList(Context c, String key) { + try { + return new JSONArray(prefs(c).getString(key, "[]")); + } catch (Exception e) { + return new JSONArray(); + } + } + + // ---- one sync ---- + + /** One round with jai (more while there's more). Off the main thread; quiet when jai's unreachable. */ + static void sync(Context c) { + Config cfg = Config.get(c); + if (!configured(cfg)) return; + synchronized (LOCK) { + try { + for (int round = 0; round < 20; round++) + if (!syncOnce(c, cfg)) break; + prefs(c).edit().putLong("lastSync", System.currentTimeMillis()).remove("error").apply(); + } catch (Exception e) { + Log.w(TAG, "relay sync failed: " + e.getMessage()); + prefs(c).edit().putString("error", e.getMessage() == null ? e.getClass().getSimpleName() : e.getMessage()).apply(); + } + } + } + + static String status(Context c) { + SharedPreferences p = prefs(c); + String err = p.getString("error", null); + long last = p.getLong("lastSync", 0); + if (err != null) return "⚠ " + err; + return last == 0 ? "Not yet" : "Last check " + Ui.shortTime(c, last).toLowerCase(); + } + + /** Returns true if there's more to do right away. */ + private static boolean syncOnce(Context c, Config cfg) throws Exception { + SharedPreferences p = prefs(c); + Store store = Store.get(c); + List push = new ArrayList<>(); + int size = 0; + + // 1. How the desktop's sends went. + JSONArray results = peekList(c, "results"); + for (int i = 0; i < results.length(); i++) { + String b = seal(cfg.relayKey, "rabbit", results.getJSONObject(i)); + push.add(b); + size += b.length(); + } + int resultsPushed = results.length(); + + // 2. The SIM's messages we haven't passed on (both id ranges: SMS, MMS). + long smsLast = p.getLong("smsLast", Sim.SMS_BASE), mmsLast = p.getLong("mmsLast", Sim.MMS_BASE); + long[] newSms = {smsLast}, newMms = {mmsLast}; + boolean moreMsgs = false; + long now = System.currentTimeMillis(); + int[] inlineBudget = {3 * 1024 * 1024}; + for (int range = 0; range < 2; range++) { + long from = range == 0 ? smsLast : mmsLast, to = range == 0 ? Sim.MMS_BASE : Sim.FALLBACK_BASE; + JSONArray msgs = new JSONArray(); + long max = from; + int n = 0; + try (Cursor cur = store.db.rawQuery("SELECT id FROM messages WHERE did = ? AND id > ? AND id < ? ORDER BY id LIMIT " + MSG_CHUNK, + new String[] {Sim.DID, String.valueOf(from), String.valueOf(to)})) { + while (cur.moveToNext()) { + Store.Msg m = store.getMessage(cur.getLong(0)); + n++; + if (m == null) continue; + max = Math.max(max, m.id); + msgs.put(toJson(c, m, now - m.ts < INLINE_RECENT, inlineBudget)); + } + } + if (n == MSG_CHUNK) moreMsgs = true; + if (msgs.length() > 0) { + String b = seal(cfg.relayKey, "rabbit", new JSONObject().put("t", "msgs").put("msgs", msgs)); + push.add(b); + size += b.length(); + } + if (range == 0) newSms[0] = max; + else newMms[0] = max; + } + + // 3. Names and read status, if they changed here. + boolean stateDirty = p.getBoolean("stateDirty", false); + if (stateDirty) { + String b = seal(cfg.relayKey, "rabbit", new JSONObject().put("t", "state") + .put("names", store.namesExport()).put("read", store.readStateExport())); + push.add(b); + size += b.length(); + } + + // 4. Photos the desktop asked for (a few MB per round). + JSONArray wants = peekList(c, "wants"); + int wantsDone = 0; + for (int i = 0; i < wants.length() && size < MAX_PUSH; i++) { + JSONObject w = wants.getJSONObject(i); + String b = seal(cfg.relayKey, "rabbit", mediaReply(c, w.optLong("id"), w.optInt("index"))); + push.add(b); + size += b.length(); + wantsDone++; + } + + // Out, and in. + long since = p.getLong("cursor", 0); + JSONArray arr = new JSONArray(); + for (String b : push) arr.put(b); + byte[] body = new JSONObject().put("device", "rabbit").put("since", since).put("push", arr).toString().getBytes(StandardCharsets.UTF_8); + Map h = new HashMap<>(); + h.put("Authorization", "Bearer " + cfg.relayToken); + h.put("Content-Type", "application/json"); + Http.Response r = Http.request("POST", cfg.relayUrl + "/sync", h, body, 120_000); + if (r.status == 401) throw new Exception("jai turned down the token (Sync to Rabbit from the desktop again)"); + if (r.status != 200) throw new Exception("jai answered " + r.status); + JSONObject res = new JSONObject(new String(r.body, StandardCharsets.UTF_8)); + + // jai has them now. + if (resultsPushed > 0) takeList(c, "results", resultsPushed); + if (wantsDone > 0) takeList(c, "wants", wantsDone); + SharedPreferences.Editor ed = p.edit().putLong("smsLast", newSms[0]).putLong("mmsLast", newMms[0]); + if (stateDirty) ed.putBoolean("stateDirty", false); + ed.commit(); + + JSONArray events = res.getJSONArray("events"); + for (int i = 0; i < events.length(); i++) handle(c, unseal(cfg.relayKey, "desktop", events.getString(i))); + p.edit().putLong("cursor", res.getLong("cursor")).commit(); + return res.optBoolean("more") || moreMsgs || peekList(c, "wants").length() > 0 && wantsDone > 0; + } + + private static JSONObject toJson(Context c, Store.Msg m, boolean inline, int[] budget) throws Exception { + JSONObject o = new JSONObject().put("id", m.id).put("did", m.did).put("contact", m.contact).put("direction", m.direction) + .put("body", m.body == null ? "" : m.body).put("ts", m.ts).put("kind", m.kind); + if (m.sender != null) o.put("sender", m.sender); + List refs = m.media(); + if (!refs.isEmpty()) { + JSONArray media = new JSONArray(); + for (int i = 0; i < refs.size(); i++) { + JSONObject ref = refs.get(i); + JSONObject out = new JSONObject().put("mime", ref.optString("mime", "application/octet-stream")); + String url = ref.optString("url", ""); + File f = null; + if (inline || !url.startsWith("mmspart:")) f = Media.resolve(c, m.id, i); + if (f != null && (f.length() <= budget[0] || !url.startsWith("mmspart:"))) { + budget[0] -= (int) f.length(); + out.put("data", Base64.encodeToString(Media.read(f), Base64.NO_WRAP)); + if (ref.optInt("width") > 0) out.put("width", ref.optInt("width")).put("height", ref.optInt("height")); + } else if (url.startsWith("mmspart:")) { + out.put("url", url); + } else continue; + media.put(out); + } + if (media.length() > 0) o.put("media", media); + } + return o; + } + + private static JSONObject mediaReply(Context c, long id, int index) throws Exception { + JSONObject out = new JSONObject().put("t", "media").put("id", id).put("index", index); + Store.Msg m = Store.get(c).getMessage(id); + // Only the SIM's own attachments go this way. + File f = m != null && Sim.isSim(m.did) ? Media.resolve(c, id, index) : null; + if (f == null) return out.put("missing", true); + JSONObject ref = m.media().get(index); + out.put("mime", ref.optString("mime", "application/octet-stream")).put("data", Base64.encodeToString(Media.read(f), Base64.NO_WRAP)); + if (ref.optInt("width") > 0) out.put("width", ref.optInt("width")).put("height", ref.optInt("height")); + return out; + } + + // ---- what the desktop sent ---- + + private static void handle(Context c, JSONObject p) { + if (p == null) return; + try { + switch (p.optString("t")) { + case "send": onSend(c, p); break; + case "state": onState(c, p); break; + case "want": { + JSONArray items = p.optJSONArray("items"); + for (int i = 0; items != null && i < items.length(); i++) addToList(c, "wants", items.getJSONObject(i)); + break; + } + default: break; + } + } catch (Exception e) { + Log.w(TAG, "skipped a message from the desktop: " + e.getMessage()); + } + } + + private static void onState(Context c, JSONObject p) throws Exception { + Store store = Store.get(c); + JSONArray names = p.optJSONArray("names"), read = p.optJSONArray("read"); + if (names != null) store.namesImport(names); + if (read != null) store.readStateImport(read); + StateSync.export(c); + Notifier.sweep(c); + Sync.changed(); + } + + /** Each send from the desktop goes out at most once, ever: remembered before it's tried. */ + private static synchronized boolean firstTime(Context c, String id) { + SharedPreferences p = prefs(c); + Set done = new HashSet<>(p.getStringSet("sent", new HashSet<>())); + long now = System.currentTimeMillis(); + for (String e : done) if (e.startsWith(id + "\t")) return false; + // Forget ones old enough to be refused by age anyway. + done.removeIf(e -> { + try { + return now - Long.parseLong(e.substring(e.indexOf('\t') + 1)) > 2 * MAX_SEND_AGE; + } catch (Exception x) { + return true; + } + }); + done.add(id + "\t" + now); + return p.edit().putStringSet("sent", done).commit(); + } + + private static void result(Context c, String id, long msgId, String error) { + try { + JSONObject o = new JSONObject().put("t", "sent").put("id", id); + o.put("msgId", msgId != 0 ? msgId : JSONObject.NULL); + o.put("error", error != null ? error : JSONObject.NULL); + addToList(c, "results", o); + } catch (Exception ignored) { + } + soon(c); + } + + private static void onSend(Context c, JSONObject p) throws Exception { + String id = p.getString("id"); + if (!id.matches("[0-9a-fA-F-]{36}") || !firstTime(c, id)) return; + String contact = p.optString("contact", ""); + String text = p.optString("text", ""); + if (contact.isEmpty() || !contact.matches("[0-9,]+|[^,]+")) { + result(c, id, 0, "No one to send it to."); + return; + } + if (System.currentTimeMillis() - p.optLong("ts") > MAX_SEND_AGE) { + result(c, id, 0, "Waited over a day for the Rabbit, so it wasn't sent. Send it again?"); + return; + } + if (!Sim.isDefault(c)) { + result(c, id, 0, "bubble isn't the Rabbit's texting app, so it can't use the SIM."); + return; + } + List photos = new ArrayList<>(); + JSONArray media = p.optJSONArray("media"); + for (int i = 0; media != null && i < media.length(); i++) { + JSONObject a = media.getJSONObject(i); + byte[] data = Base64.decode(a.getString("data"), Base64.DEFAULT); + String mime = a.optString("mime", "application/octet-stream"); + String file = Media.save(c, data, mime); + int w = a.optInt("width"), hgt = a.optInt("height"); + if (w == 0 && mime.startsWith("image/")) { + BitmapFactory.Options o = new BitmapFactory.Options(); + o.inJustDecodeBounds = true; + BitmapFactory.decodeByteArray(data, 0, data.length, o); + w = o.outWidth; + hgt = o.outHeight; + } + photos.add(new Sender.Photo(file, mime, Math.max(0, w), Math.max(0, hgt))); + } + if (text.isEmpty() && photos.isEmpty()) { + result(c, id, 0, "It was empty."); + return; + } + Sender.send(c, Sim.DID, contact, text, photos, (msgId, error) -> result(c, id, msgId, error)); + } +} diff --git a/android/app/src/main/java/me/teafry/voipmessages/RelayJob.java b/android/app/src/main/java/me/teafry/voipmessages/RelayJob.java new file mode 100644 index 0000000..f634bc6 --- /dev/null +++ b/android/app/src/main/java/me/teafry/voipmessages/RelayJob.java @@ -0,0 +1,21 @@ +package me.teafry.voipmessages; + +import android.app.job.JobParameters; +import android.app.job.JobService; + +/** One round with the relay, after something happened here (Relay.soon). */ +public final class RelayJob extends JobService { + @Override + public boolean onStartJob(JobParameters params) { + new Thread(() -> { + Relay.sync(this); + jobFinished(params, false); + }, "relay").start(); + return true; + } + + @Override + public boolean onStopJob(JobParameters params) { + return true; + } +} diff --git a/android/app/src/main/java/me/teafry/voipmessages/Sender.java b/android/app/src/main/java/me/teafry/voipmessages/Sender.java index 0866e73..c750c64 100644 --- a/android/app/src/main/java/me/teafry/voipmessages/Sender.java +++ b/android/app/src/main/java/me/teafry/voipmessages/Sender.java @@ -55,7 +55,16 @@ final class Sender { long run() throws Exception; } + /** How a send ended: the message's id, or 0 and why not (Relay reports it to the desktop). */ + interface Done { + void done(long msgId, String error); + } + static void send(Context ctx, String did, String contact, String text, List photos) { + send(ctx, did, contact, text, photos, null); + } + + static void send(Context ctx, String did, String contact, String text, List photos, Done done) { Context c = ctx.getApplicationContext(); Config cfg = Config.get(c); if (cfg.sandbox) { @@ -63,13 +72,15 @@ final class Sender { Store.Msg m = pending(did, contact, text, photos); Store store = Store.get(c); long id = store.insertPending(m); - store.confirmPending(id, 9_000_000_000L + (System.currentTimeMillis() % 1_000_000_000L)); + long real = 9_000_000_000L + (System.currentTimeMillis() % 1_000_000_000L); + store.confirmPending(id, real); Sync.changed(); + if (done != null) done.done(real, null); return; } if (cfg.isGv(did)) { if (photos.isEmpty()) { - enqueue(c, pending(did, contact, text, null), () -> gvSend(c, did, contact, text, null), true); + enqueue(c, pending(did, contact, text, null), () -> gvSend(c, did, contact, text, null), true, done); } else { // Google Voice carries one photo per message: the text rides with the first. for (int i = 0; i < photos.size(); i++) { @@ -79,7 +90,7 @@ final class Sender { one.add(p); Store.Msg m = pending(did, contact, body, one); m.ts += i; - enqueue(c, m, () -> gvSend(c, did, contact, body, p), true); + enqueue(c, m, () -> gvSend(c, did, contact, body, p), true, i == 0 ? done : null); } } return; @@ -89,7 +100,10 @@ final class Sender { boolean mms = !photos.isEmpty() || Phone.isGroup(contact); Store.Msg m = pending(did, contact, text, photos); if (mms) m.kind = "mms"; - enqueue(c, m, () -> mms ? Sim.sendMms(c, contact, text, photos) : Sim.sendSms(c, contact, text), false); + enqueue(c, m, () -> mms ? Sim.sendMms(c, contact, text, photos) : Sim.sendSms(c, contact, text), false, (id, err) -> { + if (done != null) done.done(id, err); + Relay.soon(c); // the desktop hears about it on the next round + }); return; } boolean mms = !photos.isEmpty() || Phone.charCount(text) > Phone.SMS_TEXT_LIMIT; @@ -102,7 +116,7 @@ final class Sender { for (Photo p : photos) media.add("data:" + p.mime + ";base64," + Base64.encodeToString(Media.read(new File(Media.dir(c), p.file)), Base64.NO_WRAP)); return api.sendMms(did, contact, text, media); - }, false); + }, false, done); } private static Store.Msg pending(String did, String contact, String text, List photos) { @@ -121,34 +135,38 @@ final class Sender { return m; } - private static void enqueue(Context c, Store.Msg m, Attempt attempt, boolean gv) { + private static void enqueue(Context c, Store.Msg m, Attempt attempt, boolean gv, Done done) { Store store = Store.get(c); long tempId = store.insertPending(m); Sync.changed(); queue.execute(() -> { - deliver(c, store, tempId, attempt, gv); + long[] id = {0}; + String error = deliver(c, store, tempId, attempt, gv, id); Sync.changed(); + if (done != null) done.done(id[0], error); }); } - private static void deliver(Context c, Store store, long tempId, Attempt attempt, boolean gv) { + /** Null when it went out (its id in id[0]), else why not. */ + private static String deliver(Context c, Store store, long tempId, Attempt attempt, boolean gv, long[] id) { for (int n = 1; ; n++) { try { - store.confirmPending(tempId, attempt.run()); - return; + id[0] = attempt.run(); + store.confirmPending(tempId, id[0]); + return null; } catch (Exception e) { - if (store.getMessage(tempId) == null) return; // a check found it already sent + if (store.getMessage(tempId) == null) return null; // a check found it already sent String kind = classify(e, gv); if (kind.equals("unknown")) { for (long ms : CHECK_DELAYS) { sleep(ms); Sync.poll(c); - if (store.getMessage(tempId) == null) return; + if (store.getMessage(tempId) == null) return null; } } if (kind.equals("fatal") || n >= MAX_ATTEMPTS) { store.markFailed(tempId, e.getMessage()); - return; + return e.getMessage() == null ? "It didn't go out." : e.getMessage(); } if (kind.equals("safe")) sleep(RETRY_DELAYS[Math.min(n - 1, RETRY_DELAYS.length - 1)]); } diff --git a/android/app/src/main/java/me/teafry/voipmessages/SettingsActivity.java b/android/app/src/main/java/me/teafry/voipmessages/SettingsActivity.java index 0fec65e..920e51a 100644 --- a/android/app/src/main/java/me/teafry/voipmessages/SettingsActivity.java +++ b/android/app/src/main/java/me/teafry/voipmessages/SettingsActivity.java @@ -122,6 +122,13 @@ public final class SettingsActivity extends BaseActivity { + " the texts already on the phone come over too."); } + if (Relay.configured(cfg)) { + section("Relay (jai)"); + kv("Desktop link", Relay.status(c)); + note("Texts typed on the desktop for \"via SIM\" go out at this Rabbit's background check, and chat names and read status" + + " go both ways. Sealed with a key only the desktop and this Rabbit have."); + } + section("About"); String version = "?"; try { diff --git a/android/app/src/main/java/me/teafry/voipmessages/Sim.java b/android/app/src/main/java/me/teafry/voipmessages/Sim.java index 4845386..65dae6b 100644 --- a/android/app/src/main/java/me/teafry/voipmessages/Sim.java +++ b/android/app/src/main/java/me/teafry/voipmessages/Sim.java @@ -389,6 +389,7 @@ final class Sim { List added = sync(c); Sync.changed(); Notifier.notifyNew(c, added); + if (!added.isEmpty()) Relay.soon(c); } /** A carrier's "you have an MMS" (MmsReceiver): fetch it. */ diff --git a/android/app/src/main/java/me/teafry/voipmessages/StateSync.java b/android/app/src/main/java/me/teafry/voipmessages/StateSync.java index 653aa97..f52d275 100644 --- a/android/app/src/main/java/me/teafry/voipmessages/StateSync.java +++ b/android/app/src/main/java/me/teafry/voipmessages/StateSync.java @@ -54,6 +54,7 @@ final class StateSync { static void rename(Context c, String did, String contact, String name) { Store.get(c).setName(did, contact, name, System.currentTimeMillis()); export(c); + Relay.stateChanged(c); Sync.changed(); } @@ -61,16 +62,19 @@ final class StateSync { Store.get(c).markRead(did, contact); if (Sim.isSim(did)) Sim.markRead(c, contact); export(c); + Relay.stateChanged(c); Notifier.sweep(c); } static void markUnread(Context c, String did, String contact) { Store.get(c).markUnread(did, contact); export(c); + Relay.stateChanged(c); } static void setArchived(Context c, String did, String contact, boolean archived) { Store.get(c).setArchived(did, contact, archived); export(c); + Relay.stateChanged(c); } } diff --git a/android/app/src/main/java/me/teafry/voipmessages/Sync.java b/android/app/src/main/java/me/teafry/voipmessages/Sync.java index f5cfda3..c753673 100644 --- a/android/app/src/main/java/me/teafry/voipmessages/Sync.java +++ b/android/app/src/main/java/me/teafry/voipmessages/Sync.java @@ -93,6 +93,8 @@ final class Sync { } } store.set("last_poll", String.valueOf(System.currentTimeMillis())); + // The relay rides along with this check: no wakeups of its own. + Relay.sync(c); if (!added.isEmpty()) StateSync.export(c); // Threads read on the phone or the web came back read (see storeThread). Notifier.sweep(c); diff --git a/android/app/src/main/res/xml/network_security_config.xml b/android/app/src/main/res/xml/network_security_config.xml new file mode 100644 index 0000000..a684915 --- /dev/null +++ b/android/app/src/main/res/xml/network_security_config.xml @@ -0,0 +1,11 @@ + + + + + + 100.69.139.40 + 127.0.0.1 + + diff --git a/android/build.py b/android/build.py index ed1732b..45f3b89 100644 --- a/android/build.py +++ b/android/build.py @@ -26,8 +26,8 @@ import sys import zipfile from pathlib import Path -VERSION_NAME = "0.4.0" -VERSION_CODE = 4 +VERSION_NAME = "0.5.0" +VERSION_CODE = 5 PACKAGE = "me.teafry.voipmessages" DEV_PACKAGE = PACKAGE + ".dev" diff --git a/android/tools/push_sandbox.py b/android/tools/push_sandbox.py index ca64096..9e75193 100644 --- a/android/tools/push_sandbox.py +++ b/android/tools/push_sandbox.py @@ -5,10 +5,16 @@ Its config is marked sandbox, so the app never goes online. python3 android/build.py --dev --install && python3 android/tools/push_sandbox.py +With --relay URL (and RELAY_TOKEN / RELAY_KEY in the environment) the dev app +also gets relay settings, e.g. a throwaway local server/bubble_relay.py reached +through `adb reverse tcp:18080 tcp:` with --relay http://127.0.0.1:18080. + Uses the same copy-in mechanism as the desktop installer: files are piped through `adb shell run-as` into the app's private storage. """ +import argparse import json +import os import sqlite3 import subprocess import tempfile @@ -26,8 +32,12 @@ def push(local: Path, name: str): def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--relay", help="relay URL as the Rabbit reaches it (token and key from RELAY_TOKEN / RELAY_KEY)") + args = ap.parse_args() subprocess.run(["adb", "shell", "am", "force-stop", PKG], check=True) - subprocess.run(["adb", "shell", f"run-as {PKG} sh -c 'mkdir -p files && rm -f files/messages.db*'"], check=True) + # Fresh: no history, and no relay cursors left from an earlier run. + subprocess.run(["adb", "shell", f"run-as {PKG} sh -c 'mkdir -p files && rm -f files/messages.db* shared_prefs/relay.xml'"], check=True) with tempfile.TemporaryDirectory() as d: db = Path(d) / "messages.db" con = sqlite3.connect(db) @@ -65,6 +75,10 @@ def main(): NAMED = "5415550101,5415550140" rows.append((2**52 + 20, GV, NAMED, "in", "Booked the cabin!", now - 600 * m, "5415550140")) con.execute("INSERT INTO read_state (did, contact, last_read_ts, name, name_ts) VALUES (?, ?, 0, 'Cabin trip', ?)", (GV, NAMED, now)) + # The Rabbit's SIM (did 'sim', ids from 2^51 like Sim.java's). + SIM_BASE = 2**51 + rows.append((SIM_BASE + 1, "sim", "5415550150", "in", "Texting your SIM number now", now - 20 * m, None)) + rows.append((SIM_BASE + 2, "sim", "5415550150", "out", "Got it, this is the SIM", now - 19 * m, None)) con.executemany("INSERT INTO messages (id, did, contact, direction, body, ts, sender) VALUES (?,?,?,?,?,?,?)", rows) con.execute("INSERT INTO kv VALUES ('unread_floor', '0')") con.execute("INSERT INTO gv_threads VALUES (?, ?, 'g.demo')", (GV, GROUP)) @@ -77,6 +91,7 @@ def main(): "gvoice": {"number": GV, "cookies": {}}, "dids": [{"did": VOIP, "description": "Demo"}], "defaultDid": VOIP, + **({"relay": {"url": args.relay, "token": os.environ["RELAY_TOKEN"], "key": os.environ["RELAY_KEY"]}} if args.relay else {}), })) push(db, "messages.db") push(cfg, "config.json") diff --git a/package.json b/package.json index f87dbb4..182345b 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "voipms-desktop", "productName": "bubble", - "version": "0.4.0", + "version": "0.5.0", "description": "Signal-style desktop SMS client for voip.ms", "author": "trav ", "private": true, diff --git a/resources/android/VoipMessages.apk b/resources/android/VoipMessages.apk index 72c0d77..f577780 100644 Binary files a/resources/android/VoipMessages.apk and b/resources/android/VoipMessages.apk differ diff --git a/resources/android/VoipMessages.json b/resources/android/VoipMessages.json index b1d53bd..957e105 100644 --- a/resources/android/VoipMessages.json +++ b/resources/android/VoipMessages.json @@ -1 +1 @@ -{"version_name": "0.4.0", "version_code": 4, "package": "me.teafry.voipmessages"} +{"version_name": "0.5.0", "version_code": 5, "package": "me.teafry.voipmessages"} diff --git a/scripts/deploy-jai.sh b/scripts/deploy-jai.sh new file mode 100755 index 0000000..93c25ca --- /dev/null +++ b/scripts/deploy-jai.sh @@ -0,0 +1,33 @@ +#!/bin/bash +# Deploy bubble-relay to jai (see ~/Documents/shared-resources/jai.html#run). +# jai is production: this only ever touches ~/Documents/bubble-server and its +# own screen session, and installs nothing. +# +# scripts/deploy-jai.sh copy the code and (re)start the service +# scripts/deploy-jai.sh --stop stop it +# scripts/deploy-jai.sh --token print the bearer token, for Settings → Rabbit relay on the desktop +# +# What runs is server/run.sh, also started by jai's ~/startup.sh (re-run by its +# watchdog every 5 minutes), so it comes back after a crash or a reboot. +set -euo pipefail +HOST=${JAI_HOST:-jai-ext} +DIR=/home/jai/Documents/bubble-server +NAME=bubble-relay +cd "$(dirname "$0")/.." + +case "${1:-}" in + --token) ssh "$HOST" "cat $DIR/data/token"; echo; exit 0 ;; + --stop) ssh "$HOST" "screen -S $NAME -X quit || true"; echo "stopped"; exit 0 ;; +esac + +ssh "$HOST" "mkdir -p $DIR/app $DIR/data ~/service-logs && chmod 700 $DIR $DIR/data" +rsync -a server/bubble_relay.py server/run.sh "$HOST:$DIR/app/" +ssh "$HOST" bash -s </dev/null || true +sleep 1 +screen -dmS $NAME bash -c 'bash $DIR/app/run.sh 2>&1 | tee ~/service-logs/$NAME.log' +sleep 2 +for pid in \$(pgrep -f bubble_relay.py); do echo 1000 > /proc/\$pid/oom_score_adj; done +curl -s -m 5 http://100.69.139.40:8080/health; echo +REMOTE diff --git a/server/__pycache__/test_bubble_relay.cpython-314.pyc b/server/__pycache__/test_bubble_relay.cpython-314.pyc new file mode 100644 index 0000000..efa7b05 Binary files /dev/null and b/server/__pycache__/test_bubble_relay.cpython-314.pyc differ diff --git a/server/bubble_relay.py b/server/bubble_relay.py new file mode 100644 index 0000000..4b293fa --- /dev/null +++ b/server/bubble_relay.py @@ -0,0 +1,178 @@ +#!/usr/bin/env python3 +"""bubble-relay: a mailbox between the desktop app and the Rabbit R1. Runs on jai. + +It never sees a message: every blob is AES-256-GCM sealed by the apps with a +key jai doesn't have (the desktop makes it and hands it to the Rabbit over +USB). This only stores opaque base64 strings, hands each device what the +other one posted, and forgets them once picked up (or after KEEP_DAYS). + +Standard library only. Bind it to the tailscale address; every request but +/health needs "Authorization: Bearer " (made on first start in +/token, mode 600). + + GET /health -> {"ok": true} + POST /sync {"device": "desktop"|"rabbit", "since": , "push": ["", ...]} + -> {"cursor": , "events": ["", ...], "more": bool} + +`since` is the cursor the last answer gave; it also acknowledges everything up +to it, which the other side posted, so those are deleted. `more` = there's +more than fits in one answer: call again with the new cursor. A cursor past +anything this server ever issued (a wiped server) means "from the start". + + python3 bubble_relay.py --host 100.69.139.40 --port 8080 --data DIR +""" + +import argparse +import json +import os +import re +import secrets +import sqlite3 +import sys +import threading +import time +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer + +DEVICES = ("desktop", "rabbit") +KEEP_DAYS = 14 +MAX_BODY = 24 * 1024 * 1024 # one request +MAX_BLOB = 12 * 1024 * 1024 # one sealed blob (a few photos) +MAX_PUSH = 2000 # blobs in one request +MAX_ANSWER = 8 * 1024 * 1024 # roughly, per answer (`more` past it) +MAX_STORED = 512 * 1024 * 1024 # everything waiting; pushes past it are refused +BLOB_RE = re.compile(r"^[A-Za-z0-9+/]+={0,2}$") +LOCK = threading.Lock() + + +class Store: + def __init__(self, path): + self.db = sqlite3.connect(path, check_same_thread=False) + self.db.execute("PRAGMA journal_mode=WAL") + self.db.execute("CREATE TABLE IF NOT EXISTS events (seq INTEGER PRIMARY KEY AUTOINCREMENT," + " author TEXT NOT NULL, blob TEXT NOT NULL, size INTEGER NOT NULL, created INTEGER NOT NULL)") + self.db.commit() + + def issued(self): + """The highest cursor ever handed out (survives deletions).""" + row = self.db.execute("SELECT seq FROM sqlite_sequence WHERE name = 'events'").fetchone() + return row[0] if row else 0 + + def stored(self): + return self.db.execute("SELECT COALESCE(SUM(size), 0) FROM events").fetchone()[0] + + def sync(self, device, since, pushed): + with LOCK: + now = int(time.time()) + issued = self.issued() + if since > issued: + since = 0 + # Picked up by this device: gone. Too old for anyone: gone. + self.db.execute("DELETE FROM events WHERE author != ? AND seq <= ?", (device, since)) + self.db.execute("DELETE FROM events WHERE created < ?", (now - KEEP_DAYS * 86400,)) + if pushed: + incoming = sum(len(b) for b in pushed) + if self.stored() + incoming > MAX_STORED: + self.db.commit() + return None + self.db.executemany("INSERT INTO events (author, blob, size, created) VALUES (?, ?, ?, ?)", + [(device, b, len(b), now) for b in pushed]) + self.db.commit() + events, size, cursor, more = [], 0, since, False + for seq, blob in self.db.execute("SELECT seq, blob FROM events WHERE author != ? AND seq > ? ORDER BY seq", + (device, since)): + if events and size + len(blob) > MAX_ANSWER: + more = True + break + events.append(blob) + size += len(blob) + cursor = seq + if not more: + # Nothing left for this device: skip past the other device's own posts too. + cursor = max(cursor, self.issued()) + return {"cursor": cursor, "events": events, "more": more} + + +class Handler(BaseHTTPRequestHandler): + server_version = "bubble-relay" + sys_version = "" + timeout = 60 # a stalled client doesn't hold a thread forever + + def _send(self, code, obj): + body = json.dumps(obj, separators=(",", ":")).encode() + self.send_response(code) + self.send_header("Content-Type", "application/json") + self.send_header("Content-Length", str(len(body))) + self.send_header("Cache-Control", "no-store") + self.end_headers() + self.wfile.write(body) + + def _authed(self): + got = self.headers.get("Authorization", "") + return secrets.compare_digest(got.encode(), ("Bearer " + self.server.token).encode()) + + def do_GET(self): + if self.path == "/health": + return self._send(200, {"ok": True}) + self._send(404, {"error": "not found"}) + + def do_POST(self): + if self.path != "/sync": + return self._send(404, {"error": "not found"}) + if not self._authed(): + return self._send(401, {"error": "unauthorized"}) + try: + n = int(self.headers.get("Content-Length") or 0) + except ValueError: + return self._send(400, {"error": "bad length"}) + if n < 0 or n > MAX_BODY: + return self._send(413, {"error": "too large"}) + try: + req = json.loads(self.rfile.read(n) or b"{}") + device = req.get("device") + since = int(req.get("since", 0)) + push = req.get("push", []) + if device not in DEVICES: + raise ValueError("device") + if since < 0: + raise ValueError("since") + if not isinstance(push, list) or len(push) > MAX_PUSH: + raise ValueError("push") + for b in push: + if not isinstance(b, str) or not b or len(b) > MAX_BLOB or not BLOB_RE.match(b): + raise ValueError("blob") + except (ValueError, TypeError, AttributeError) as e: + return self._send(400, {"error": "bad request: %s" % e}) + out = self.server.store.sync(device, since, push) + if out is None: + return self._send(507, {"error": "relay full"}) + self._send(200, out) + + def log_message(self, fmt, *args): + # Method, path and status only: nothing a request carries. + sys.stderr.write("%s %s\n" % (self.log_date_time_string(), fmt % args)) + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--host", default="127.0.0.1") + ap.add_argument("--port", type=int, default=8080) + ap.add_argument("--data", required=True) + a = ap.parse_args() + os.makedirs(a.data, mode=0o700, exist_ok=True) + os.chmod(a.data, 0o700) + os.umask(0o077) + tok_path = os.path.join(a.data, "token") + if not os.path.exists(tok_path): + fd = os.open(tok_path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600) + with os.fdopen(fd, "w") as f: + f.write(secrets.token_urlsafe(32)) + srv = ThreadingHTTPServer((a.host, a.port), Handler) + srv.daemon_threads = True + srv.token = open(tok_path).read().strip() + srv.store = Store(os.path.join(a.data, "relay.db")) + print("bubble-relay on %s:%d" % (a.host, a.port), flush=True) + srv.serve_forever() + + +if __name__ == "__main__": + main() diff --git a/server/run.sh b/server/run.sh new file mode 100755 index 0000000..db40975 --- /dev/null +++ b/server/run.sh @@ -0,0 +1,4 @@ +#!/bin/bash +# The one real command line for bubble-relay on jai (~/startup.sh and scripts/deploy-jai.sh both run this). +cd /home/jai/Documents/bubble-server/app || exit 1 +exec python3 bubble_relay.py --host 100.69.139.40 --port 8080 --data /home/jai/Documents/bubble-server/data diff --git a/server/test_bubble_relay.py b/server/test_bubble_relay.py new file mode 100644 index 0000000..4341235 --- /dev/null +++ b/server/test_bubble_relay.py @@ -0,0 +1,80 @@ +"""python3 -m unittest server/test_bubble_relay.py (a real server on localhost, made-up blobs)""" +import json +import os +import socket +import subprocess +import sys +import tempfile +import time +import unittest +import urllib.error +import urllib.request + +HERE = os.path.dirname(os.path.abspath(__file__)) + + +class RelayTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.dir = tempfile.mkdtemp() + s = socket.socket() + s.bind(("127.0.0.1", 0)) + cls.port = s.getsockname()[1] + s.close() + cls.proc = subprocess.Popen([sys.executable, os.path.join(HERE, "bubble_relay.py"), "--port", str(cls.port), + "--data", cls.dir], stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL) + for _ in range(50): + try: + urllib.request.urlopen("http://127.0.0.1:%d/health" % cls.port, timeout=1) + break + except OSError: + time.sleep(0.1) + cls.token = open(os.path.join(cls.dir, "token")).read().strip() + + @classmethod + def tearDownClass(cls): + cls.proc.terminate() + cls.proc.wait() + + def call(self, body, token=None, raw=None): + data = raw if raw is not None else json.dumps(body).encode() + req = urllib.request.Request("http://127.0.0.1:%d/sync" % self.port, data=data, method="POST", + headers={"Authorization": "Bearer " + (token or self.token)}) + try: + with urllib.request.urlopen(req, timeout=5) as r: + return r.status, json.loads(r.read()) + except urllib.error.HTTPError as e: + return e.code, json.loads(e.read()) + + def test_flow(self): + st, d = self.call({"device": "desktop", "since": 0, "push": ["QUJD", "REVG"]}) + self.assertEqual(st, 200) + self.assertEqual(d["events"], []) # never your own + st, r = self.call({"device": "rabbit", "since": 0, "push": ["R0hJ"]}) + self.assertEqual(r["events"], ["QUJD", "REVG"]) + st, d2 = self.call({"device": "desktop", "since": d["cursor"]}) + self.assertEqual(d2["events"], ["R0hJ"]) + # Acknowledged by the rabbit: deleted, so nobody gets them again. + self.call({"device": "rabbit", "since": r["cursor"]}) + st, again = self.call({"device": "rabbit", "since": 0}) + self.assertEqual(again["events"], []) + # A cursor from a wiped server means "from the start". + st, w = self.call({"device": "desktop", "since": 10 ** 9}) + self.assertEqual(w["events"], ["R0hJ"]) + + def test_rejects(self): + self.assertEqual(self.call({"device": "desktop", "since": 0}, token="wrong")[0], 401) + self.assertEqual(self.call({"device": "laptop", "since": 0})[0], 400) + self.assertEqual(self.call({"device": "desktop", "since": 0, "push": ["not base64!"]})[0], 400) + self.assertEqual(self.call({"device": "desktop", "since": 0, "push": [5]})[0], 400) + self.assertEqual(self.call(None, raw=b"{nope")[0], 400) + with urllib.request.urlopen("http://127.0.0.1:%d/health" % self.port) as r: + self.assertEqual(json.loads(r.read()), {"ok": True}) + + def test_token_file_private(self): + self.assertEqual(os.stat(os.path.join(self.dir, "token")).st_mode & 0o777, 0o600) + self.assertEqual(os.stat(self.dir).st_mode & 0o777, 0o700) + + +if __name__ == "__main__": + unittest.main() diff --git a/src/main/index.ts b/src/main/index.ts index 8f812e7..18d6479 100644 --- a/src/main/index.ts +++ b/src/main/index.ts @@ -27,6 +27,7 @@ import { gvMessageId, GvSyncEngine } from './gvoice/sync' import { WaaSigner } from './gvoice/waa' import { clearNotifications, notifyNew } from './notify' import * as rabbit from './rabbit' +import { checkUrl, clearRelayConfig, loadRelayConfig, newKey, RelayEngine, saveRelayConfig, SIM_DID } from './relay' protocol.registerSchemesAsPrivileged([ { scheme: 'contact-photo', privileges: { standard: true, secure: true, supportFetchAPI: true } }, @@ -47,6 +48,8 @@ let dids: Did[] = [] let gv: GVoice | undefined let gvSync: GvSyncEngine | undefined let waa: WaaSigner | undefined +// The relay through jai: the Rabbit's SIM, names and read state (relay.ts). +let relay: RelayEngine | undefined const send = (channel: string, ...args: unknown[]): void => { if (win && !win.isDestroyed()) win.webContents.send(channel, ...args) @@ -107,13 +110,38 @@ function openFromNotification(key: { did: string; contact: string }): void { const gvNumber = (): string | undefined => db.get('gv_number') || undefined -// Every number we can text from: voip.ms's DIDs, then Google Voice's. +// Every number we can text from: voip.ms's DIDs, then Google Voice's, then +// the Rabbit's SIM (through jai). function allDids(): Did[] { const n = gvNumber() - return n ? [...dids, { did: n, description: 'Google Voice', smsEnabled: true, provider: 'gvoice' }] : dids + const out: Did[] = n ? [...dids, { did: n, description: 'Google Voice', smsEnabled: true, provider: 'gvoice' }] : [...dids] + if (relay) out.push({ did: SIM_DID, description: 'Rabbit SIM', smsEnabled: true, provider: 'sim' }) + return out } -const providerOf = (did: string): Provider => (did === gvNumber() ? 'gvoice' : 'voipms') +const providerOf = (did: string): Provider => (did === SIM_DID ? 'sim' : did === gvNumber() ? 'gvoice' : 'voipms') + +function startRelay(): void { + relay?.stop() + relay = undefined + const cfg = loadRelayConfig() + if (!cfg) return + relay = new RelayEngine(db, media, cfg, settings.pollSeconds) + relay.on('messages', onNewMessages) + relay.on('changed', () => send('conversationsChanged')) + relay.on('status', () => send('relayStatus', relay?.status())) + relay.start() +} + +// A text over the Rabbit's SIM: pending here until the Rabbit's next check +// sends it and says how it went (relay.ts). +function relaySend(contact: string, text: string, refs: MediaRef[]): void { + if (!relay) throw new Error('The Rabbit relay is off: connect it in Settings → Rabbit.') + const kind = refs.length || isGroup(contact) ? 'mms' : 'sms' + const tempId = db.insertPending({ did: SIM_DID, contact, direction: 'out', body: text, ts: Date.now(), kind, ...(refs.length ? { media: refs } : {}) }) + relay.send(tempId, contact, text, refs) + send('conversationsChanged') +} function syncStatus(): SyncStatus { const base: SyncStatus = sync?.getStatus() ?? { phase: 'unconfigured', backfillDone: false, total: db.count() } @@ -170,6 +198,10 @@ async function rabbitConfig(): Promise { ...(SANDBOX ? { sandbox: true } : {}), voipms: SANDBOX ? { username: 'sandbox', password: 'sandbox' } : creds ? { username: creds.username, password: creds.password } : null, gvoice: gv ? { number: gv, cookies: SANDBOX ? {} : await exportCookies() } : null, + relay: (() => { + const r = loadRelayConfig() + return r ? { url: r.url, token: r.token, key: r.key } : null + })(), dids: voipDids.map((d) => ({ did: d.did, description: d.description })), defaultDid: settings.defaultDid ?? voipDids[0]?.did ?? gv } @@ -393,6 +425,7 @@ async function gvSend(did: string, contact: string, text: string, ref?: MediaRef // Anything longer than one SMS goes out as a single text-only MMS (voip.ms; // Google Voice has no such limit). async function sendText(did: string, contact: string, text: string): Promise { + if (did === SIM_DID) return relaySend(contact, text, []) const from = normalizeNumber(did) const m: Omit = { did: from, contact, direction: 'out', body: text, ts: Date.now() } if (providerOf(from) === 'gvoice') return deliver(m, () => gvSend(from, contact, text)) @@ -410,6 +443,7 @@ async function sendMms(did: string, contact: string, text: string, attachments: } async function sendMmsRefs(did: string, contact: string, text: string, refs: MediaRef[]): Promise { + if (did === SIM_DID) return relaySend(contact, text, refs) const from = normalizeNumber(did) if (providerOf(from) === 'gvoice') { if (refs.some((r) => !SendMediaType[r.mime ?? ''])) throw new Error('Google Voice can only send photos.') @@ -537,20 +571,25 @@ function registerIpc(): void { // Clear the unread badge on the phone too. const thread = providerOf(did) === 'gvoice' && db.hasUnread(did, contact) ? db.getGvThread(did, contact) : undefined if (thread) gv?.markRead(thread).catch((e: Error) => console.warn('[gvoice] mark read failed:', e.message)) + const had = db.hasUnread(did, contact) db.markRead(did, contact) clearNotifications(did, contact) + if (had) relay?.stateChanged() send('conversationsChanged') }) ipcMain.handle('markUnread', (_e, did: string, contact: string) => { db.markUnread(did, contact) + relay?.stateChanged() send('conversationsChanged') }) ipcMain.handle('setArchived', (_e, did: string, contact: string, archived: boolean) => { db.setArchived(did, contact, archived) + relay?.stateChanged() send('conversationsChanged') }) ipcMain.handle('setName', (_e, did: string, contact: string, name: string | null) => { db.setName(did, contact, name) + relay?.stateChanged() send('conversationsChanged') }) ipcMain.handle('getDrafts', () => db.getDrafts()) @@ -577,8 +616,34 @@ function registerIpc(): void { clipboard.write([new ClipboardItem({ 'image/png': new Blob([png], { type: 'image/png' }) })]) ) + ipcMain.handle('relayStatus', () => relay?.status() ?? { connected: false, waiting: 0, url: loadRelayConfig()?.url }) + ipcMain.handle('relayConnect', async (_e, url: string, token: string) => { + const origin = checkUrl(url) + const tok = token.trim() + if (!/^[A-Za-z0-9_-]{20,200}$/.test(tok)) throw new Error("That doesn't look like the relay's token.") + // A harmless call that needs the token: acknowledges nothing, posts nothing. + const res = await fetch(`${origin}/sync`, { + method: 'POST', + headers: { Authorization: `Bearer ${tok}`, 'Content-Type': 'application/json' }, + body: JSON.stringify({ device: 'desktop', since: Number(db.get('relay_cursor') ?? 0), push: [] }), + signal: AbortSignal.timeout(15_000) + }).catch(() => undefined) + if (!res) throw new Error(`Couldn't reach ${origin}. Is tailscale up?`) + if (res.status === 401) throw new Error('jai turned down that token.') + if (!res.ok) throw new Error(`jai answered ${res.status}.`) + // Keep the key across reconnects so the Rabbit's copy stays good. + saveRelayConfig({ url: origin, token: tok, key: loadRelayConfig()?.key ?? newKey() }) + startRelay() + send('stateChanged') + }) + ipcMain.handle('relayDisconnect', () => { + relay?.stop() + relay = undefined + clearRelayConfig() + send('stateChanged') + }) ipcMain.handle('syncStatus', () => syncStatus()) - ipcMain.handle('pollNow', () => Promise.all([sync?.pollNow(), gvSync?.pollNow()])) + ipcMain.handle('pollNow', () => Promise.all([sync?.pollNow(), gvSync?.pollNow(), relay?.syncNow()])) ipcMain.handle('openDataFolder', () => shell.openPath(getDataDir())) ipcMain.handle('snapshotNow', () => db.snapshot(snapshotDir())) ipcMain.handle('chooseDataDir', async () => { @@ -679,7 +744,12 @@ app.whenReady().then(async () => { db = new MessageDb(path.join(getDataDir(), 'messages.db')) if (SANDBOX) seedDemo(db) dids = JSON.parse(db.get('dids') ?? '[]') as Did[] - media = new MediaStore(path.join(getDataDir(), 'media'), db, (url) => { + media = new MediaStore(path.join(getDataDir(), 'media'), db, (url, at) => { + if (url.startsWith('mmspart:')) { + // On the Rabbit: ask for it; it shows up after the Rabbit's next check. + if (at) relay?.want(at.id, at.index, url) + return Promise.reject(new Error('on the Rabbit')) + } if (!url.startsWith('gv:')) return net.fetch(url) if (!gv) return Promise.reject(new Error('Google Voice is not connected')) return gv.downloadMedia(url.slice(3)) @@ -698,6 +768,7 @@ app.whenReady().then(async () => { const creds = loadCredentials() if (creds) startSync(creds) if (gvNumber() && (await hasGvSession())) startGvSync() + startRelay() void dailySnapshot() setInterval(() => void dailySnapshot(), 60 * 60 * 1000) @@ -710,6 +781,7 @@ app.on('before-quit', (e) => { quitting = true sync?.stop() stopGv() + relay?.stop() contacts?.close() db.snapshot(snapshotDir()) .catch((err) => console.error('[snapshot] on quit failed:', err)) diff --git a/src/main/media.ts b/src/main/media.ts index 9c8a188..bc6dab3 100644 --- a/src/main/media.ts +++ b/src/main/media.ts @@ -16,7 +16,7 @@ export class MediaStore { readonly dir: string, private db: MessageDb, // How to fetch a MediaRef.url; Google Voice's gv: refs need its session. - private fetchUrl: (url: string) => Promise = (url) => net.fetch(url) + private fetchUrl: (url: string, at?: { id: number; index: number }) => Promise = (url) => net.fetch(url) ) {} filePath(file: string): string { @@ -49,7 +49,7 @@ export class MediaStore { private async download(id: number, index: number, url: string): Promise { try { - const res = await this.fetchUrl(url) + const res = await this.fetchUrl(url, { id, index }) const header = res.headers.get('content-type')?.split(';')[0].trim() // voip.ms answers expired/unknown media with a 200 HTML page. if (!res.ok || header === 'text/html') return undefined diff --git a/src/main/rabbit.ts b/src/main/rabbit.ts index 7f3b510..2366a0d 100644 --- a/src/main/rabbit.ts +++ b/src/main/rabbit.ts @@ -22,6 +22,8 @@ export interface RabbitConfig { gvoice: { number: string; cookies: Record } | null dids: Array<{ did: string; description: string }> defaultDid?: string + // The relay through jai (relay.ts): address, token, and the key that seals everything. + relay?: { url: string; token: string; key: string } | null } export interface RabbitTarget { @@ -146,6 +148,8 @@ async function historyCopy(db: MessageDb): Promise { copy.exec(` DROP TRIGGER IF EXISTS messages_ai; DROP TRIGGER IF EXISTS messages_ad; DROP TRIGGER IF EXISTS messages_au; DROP TABLE IF EXISTS messages_fts; + DROP TABLE IF EXISTS relay_outbox; + DELETE FROM kv WHERE key LIKE 'relay%'; `) copy.pragma('journal_mode = DELETE') copy.exec('VACUUM') diff --git a/src/main/relay.ts b/src/main/relay.ts new file mode 100644 index 0000000..ff2baae --- /dev/null +++ b/src/main/relay.ts @@ -0,0 +1,316 @@ +// The relay through jai: the Rabbit's SIM texts reach this computer, texts +// typed here go out over the Rabbit's SIM, and chat names and read/unread/ +// archived stay in step between the two, all without a USB cable. +// +// jai only ever holds sealed blobs: AES-256-GCM with a key made here and handed +// to the Rabbit over USB (Install/Sync to Rabbit puts it in the app's private +// config.json). The bearer token only lets a device talk to the mailbox; the +// key is what keeps jai (and anyone else on it) from reading or forging +// anything. Server: server/bubble_relay.py. Android side: Relay.java. +// +// What travels (inside the seal; `t` is the kind): +// rabbit → desktop msgs {msgs: NewMessage[] (did 'sim'), media inline as {data} or lazy {url: 'mmspart:N'}} +// sent {id, msgId | null, error | null} a send from here, done +// media {id, index, mime, data} | {.., missing: true} +// desktop → rabbit send {id (uuid), ts, contact, text, media: [{mime, data, width, height}]} +// want {items: [{id, index, url}]} a lazy photo, please +// both ways state {names, read} merged newest-wins (db.namesImport/readStateImport) +import { app, safeStorage } from 'electron' +import crypto from 'node:crypto' +import { EventEmitter } from 'node:events' +import fs from 'node:fs' +import path from 'node:path' +import type { RelayStatus } from '@shared/api' +import { SIM_DID } from '@shared/phone' +import type { MediaRef } from '@shared/types' +import type { MessageDb, NameChange, NewMessage, ReadState } from './db' +import type { MediaStore } from './media' + +export { SIM_DID } from '@shared/phone' +export const DEFAULT_URL = 'http://100.69.139.40:8080' + +export interface RelayConfig { + url: string + token: string + key: string // base64, 32 bytes +} + +// ---- the config, encrypted with the system keyring like the voip.ms login ---- +const file = (): string => path.join(app.getPath('userData'), 'relay.bin') + +export function loadRelayConfig(): RelayConfig | undefined { + try { + return JSON.parse(safeStorage.decryptString(fs.readFileSync(file()))) as RelayConfig + } catch { + return undefined + } +} + +export function saveRelayConfig(c: RelayConfig): void { + if (!safeStorage.isEncryptionAvailable()) throw new Error('No system keyring available to keep the relay key safe.') + fs.mkdirSync(path.dirname(file()), { recursive: true }) + fs.writeFileSync(file(), safeStorage.encryptString(JSON.stringify(c)), { mode: 0o600 }) +} + +export function clearRelayConfig(): void { + fs.rmSync(file(), { force: true }) +} + +export function newKey(): string { + return crypto.randomBytes(32).toString('base64') +} + +// Plain http is fine only because tailscale encrypts the hop and the payload is +// sealed anyway; still, don't send the token just anywhere. +export function checkUrl(url: string): string { + const u = new URL(url.trim()) + if (u.protocol !== 'http:' && u.protocol !== 'https:') throw new Error('The relay address should start with http:// or https://') + const host = u.hostname + const tailnet = /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.\d+\.\d+$/.test(host) || host.endsWith('.ts.net') + const local = host === '127.0.0.1' || host === 'localhost' + if (u.protocol === 'http:' && !tailnet && !local) throw new Error('Plain http only to a tailscale (100.x) address; use https otherwise.') + return u.origin +} + +// ---- sealing ---- +type Device = 'desktop' | 'rabbit' +const aad = (author: Device): Buffer => Buffer.from(`bubble-relay/1/${author}`) + +export function seal(key: Buffer, author: Device, payload: unknown): string { + const nonce = crypto.randomBytes(12) + const c = crypto.createCipheriv('aes-256-gcm', key, nonce) + c.setAAD(aad(author)) + const ct = Buffer.concat([c.update(JSON.stringify(payload), 'utf8'), c.final()]) + return Buffer.concat([Buffer.from([1]), nonce, ct, c.getAuthTag()]).toString('base64') +} + +// Undefined for anything not sealed with our key by `author` (tampered, foreign, garbage). +export function unseal(key: Buffer, author: Device, blob: string): unknown { + try { + const b = Buffer.from(blob, 'base64') + if (b.length < 1 + 12 + 16 || b[0] !== 1) return undefined + const d = crypto.createDecipheriv('aes-256-gcm', key, b.subarray(1, 13)) + d.setAAD(aad(author)) + d.setAuthTag(b.subarray(b.length - 16)) + return JSON.parse(Buffer.concat([d.update(b.subarray(13, b.length - 16)), d.final()]).toString('utf8')) + } catch { + return undefined + } +} + +// ---- payloads ---- +interface RelayMedia { + url?: string + mime?: string + data?: string + width?: number + height?: number +} +type Incoming = + | { t: 'msgs'; msgs: Array } + | { t: 'sent'; id: string; msgId: number | null; error: string | null } + | { t: 'media'; id: number; index: number; mime?: string; data?: string; width?: number; height?: number; missing?: boolean } + | { t: 'state'; names: NameChange[]; read: ReadState[] } + +const MAX_PUSH_BYTES = 8 * 1024 * 1024 +const isInt = (n: unknown): n is number => typeof n === 'number' && Number.isSafeInteger(n) + +export class RelayEngine extends EventEmitter { + private key: Buffer + private timer?: NodeJS.Timeout + private kickTimer?: NodeJS.Timeout + private running = false + private syncing?: Promise + private stateDirty = false + private wanted = new Set() + private lastSync?: number + private error?: string + + constructor( + private db: MessageDb, + private media: MediaStore, + private cfg: RelayConfig, + private pollSeconds: number + ) { + super() + this.key = Buffer.from(cfg.key, 'base64') + if (this.key.length !== 32) throw new Error('bad relay key') + db.db.exec('CREATE TABLE IF NOT EXISTS relay_outbox (seq INTEGER PRIMARY KEY AUTOINCREMENT, blob TEXT NOT NULL)') + } + + start(): void { + if (this.running) return + this.running = true + // The Rabbit should know where things stand here as soon as it can. + this.stateDirty = true + this.loop(1000) + } + + stop(): void { + this.running = false + clearTimeout(this.timer) + clearTimeout(this.kickTimer) + } + + status(): RelayStatus { + const waiting = (this.db.db.prepare(`SELECT COUNT(*) AS n FROM kv WHERE key LIKE 'relay_send:%'`).get() as { n: number }).n + return { connected: true, url: this.cfg.url, lastSync: this.lastSync, error: this.error, waiting } + } + + private loop(delay: number): void { + clearTimeout(this.timer) + if (!this.running) return + this.timer = setTimeout(() => void this.syncNow().finally(() => this.loop(Math.max(15, this.pollSeconds) * 1000)), delay) + } + + // Something to send: go soon, but gather a burst of changes into one call. + kick(): void { + clearTimeout(this.kickTimer) + this.kickTimer = setTimeout(() => void this.syncNow(), 1500) + } + + syncNow(): Promise { + this.syncing ??= this.syncLoop().finally(() => (this.syncing = undefined)) + return this.syncing + } + + // Names or read/unread/archived changed here. + stateChanged(): void { + this.stateDirty = true + this.kick() + } + + private queue(payload: unknown): void { + this.db.db.prepare('INSERT INTO relay_outbox (blob) VALUES (?)').run(seal(this.key, 'desktop', payload)) + } + + // A pending message (already in the db as `tempId`) to go out over the Rabbit's SIM. + send(tempId: number, contact: string, text: string, refs: MediaRef[]): void { + const id = crypto.randomUUID() + const media = refs.map((r) => ({ + mime: r.mime ?? 'application/octet-stream', + data: fs.readFileSync(this.media.filePath(r.file!)).toString('base64'), + ...(r.width ? { width: r.width, height: r.height } : {}) + })) + this.db.set(`relay_send:${id}`, String(tempId)) + this.queue({ t: 'send', id, ts: Date.now(), contact, text, media }) + this.kick() + } + + // A photo the Rabbit has but we don't (history comes over without them). + want(id: number, index: number, url: string): void { + const k = `${id}/${index}` + if (this.wanted.has(k)) return + this.wanted.add(k) + this.queue({ t: 'want', items: [{ id, index, url }] }) + this.kick() + } + + private async syncLoop(): Promise { + try { + if (this.stateDirty) { + this.stateDirty = false + this.queue({ t: 'state', names: this.db.namesExport(), read: this.db.readStateExport() }) + } + for (let round = 0; round < 50 && this.running; round++) { + const rows = this.db.db.prepare('SELECT seq, blob FROM relay_outbox ORDER BY seq').all() as Array<{ seq: number; blob: string }> + const push: typeof rows = [] + let size = 0 + for (const r of rows) { + if (push.length && size + r.blob.length > MAX_PUSH_BYTES) break + push.push(r) + size += r.blob.length + } + const since = Number(this.db.get('relay_cursor') ?? 0) + const res = await fetch(`${this.cfg.url}/sync`, { + method: 'POST', + headers: { Authorization: `Bearer ${this.cfg.token}`, 'Content-Type': 'application/json' }, + body: JSON.stringify({ device: 'desktop', since, push: push.map((r) => r.blob) }), + signal: AbortSignal.timeout(120_000) + }) + if (res.status === 401) throw new Error('jai turned down the token. Check it in Settings → Rabbit.') + if (!res.ok) throw new Error(`jai answered ${res.status}`) + const body = (await res.json()) as { cursor: number; events: string[]; more: boolean } + // Only now that jai has them: out of the outbox. + if (push.length) this.db.db.prepare('DELETE FROM relay_outbox WHERE seq <= ?').run(push.at(-1)!.seq) + for (const blob of body.events) this.handle(unseal(this.key, 'rabbit', blob) as Incoming | undefined) + this.db.set('relay_cursor', String(body.cursor)) + if (!body.more && rows.length === push.length) break + } + this.lastSync = Date.now() + this.error = undefined + } catch (e) { + // Can't reach jai: an ordinary, quiet outcome; try again next round. + this.error = (e as Error).name === 'TimeoutError' ? "jai didn't answer" : (e as Error).message + } + this.emit('status', this.status()) + } + + private handle(p: Incoming | undefined): void { + if (!p || typeof p !== 'object') return + try { + if (p.t === 'msgs' && Array.isArray(p.msgs)) this.onMsgs(p.msgs) + else if (p.t === 'sent') this.onSent(p) + else if (p.t === 'media') this.onMedia(p) + else if (p.t === 'state') { + const n = this.db.namesImport(Array.isArray(p.names) ? p.names : []) + this.db.readStateImport(Array.isArray(p.read) ? p.read : []) + if (n) this.emit('changed', 'state') + } + } catch (e) { + console.warn('[relay] skipped a message from the Rabbit:', (e as Error).message) + } + } + + private onMsgs(raw: Array): void { + const msgs: NewMessage[] = [] + for (const m of raw) { + // Only the SIM's own conversations come this way, whatever a message claims. + if (!isInt(m.id) || m.did !== SIM_DID || typeof m.contact !== 'string' || !m.contact || !isInt(m.ts)) continue + if (m.direction !== 'in' && m.direction !== 'out') continue + const media: MediaRef[] = [] + for (const r of Array.isArray(m.media) ? m.media : []) { + const mime = typeof r.mime === 'string' ? r.mime : 'application/octet-stream' + if (typeof r.data === 'string') { + const ref: MediaRef = { file: this.media.save(Buffer.from(r.data, 'base64'), mime), mime } + if (isInt(r.width) && isInt(r.height)) Object.assign(ref, { width: r.width, height: r.height }) + media.push(ref) + } else if (typeof r.url === 'string' && r.url.startsWith('mmspart:')) media.push({ url: r.url, mime }) + } + msgs.push({ + id: m.id, + did: SIM_DID, + contact: m.contact, + direction: m.direction, + body: typeof m.body === 'string' ? m.body : '', + ts: m.ts, + kind: m.kind === 'mms' ? 'mms' : 'sms', + ...(media.length ? { media } : {}), + ...(typeof m.sender === 'string' ? { sender: m.sender } : {}) + }) + } + const added = this.db.upsertMessages(msgs) + if (added.length) this.emit('messages', added) + } + + private onSent(p: { id: string; msgId: number | null; error: string | null }): void { + const key = `relay_send:${p.id}` + const temp = this.db.get(key) + if (temp === undefined || temp === null) return + const tempId = Number(temp) + if (isInt(p.msgId)) this.db.confirmPending(tempId, p.msgId) + else this.db.markFailed(tempId, typeof p.error === 'string' ? `Rabbit: ${p.error}` : "The Rabbit couldn't send it.") + this.db.db.prepare('DELETE FROM kv WHERE key = ?').run(key) + this.emit('changed', 'sent') + } + + private onMedia(p: { id: number; index: number; mime?: string; data?: string; width?: number; height?: number; missing?: boolean }): void { + if (!isInt(p.id) || !isInt(p.index)) return + this.wanted.delete(`${p.id}/${p.index}`) + if (typeof p.data !== 'string') return + const mime = typeof p.mime === 'string' ? p.mime : 'application/octet-stream' + const patch: MediaRef = { file: this.media.save(Buffer.from(p.data, 'base64'), mime), mime } + if (isInt(p.width) && isInt(p.height)) Object.assign(patch, { width: p.width, height: p.height }) + this.db.setMediaFile(p.id, p.index, patch) + this.emit('changed', 'media') + } +} diff --git a/src/preload/index.ts b/src/preload/index.ts index 9026ab6..8dbda6b 100644 --- a/src/preload/index.ts +++ b/src/preload/index.ts @@ -22,6 +22,10 @@ const api: Api = { rabbitInstall: (mode) => ipcRenderer.invoke('rabbitInstall', mode), rabbitSync: () => ipcRenderer.invoke('rabbitSync'), onRabbitProgress: (cb) => on('rabbitProgress', cb), + relayStatus: () => ipcRenderer.invoke('relayStatus'), + relayConnect: (url, token) => ipcRenderer.invoke('relayConnect', url, token), + relayDisconnect: () => ipcRenderer.invoke('relayDisconnect'), + onRelayStatus: (cb) => on('relayStatus', cb), listContacts: () => ipcRenderer.invoke('listContacts'), listAddressBooks: () => ipcRenderer.invoke('listAddressBooks'), diff --git a/src/renderer/src/App.tsx b/src/renderer/src/App.tsx index 088312d..3e818bc 100644 --- a/src/renderer/src/App.tsx +++ b/src/renderer/src/App.tsx @@ -72,7 +72,7 @@ export function App() { const all = state?.dids.filter((d) => d.smsEnabled) ?? [] const chosen = state?.settings.dids ?? [] // The sync list is voip.ms's; Google Voice is on whenever it's connected. - return chosen.length ? all.filter((d) => d.provider === 'gvoice' || chosen.includes(d.did)) : all + return chosen.length ? all.filter((d) => d.provider === 'gvoice' || d.provider === 'sim' || chosen.includes(d.did)) : all }, [state]) const open = useCallback((key: ConvKey, jumpTo?: number) => { diff --git a/src/renderer/src/components/ChatView.tsx b/src/renderer/src/components/ChatView.tsx index bd0f93d..ec38d1b 100644 --- a/src/renderer/src/components/ChatView.tsx +++ b/src/renderer/src/components/ChatView.tsx @@ -1,6 +1,6 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react' import { Virtuoso, type VirtuosoHandle } from 'react-virtuoso' -import { formatNumber, groupMembers, isGroup } from '@shared/phone' +import { formatNumber, groupMembers, isGroup, didName } from '@shared/phone' import type { ContactInfo, Conversation, Did, Message, SearchHit } from '@shared/types' import type { ConvKey, Jump } from '../App' import { chatsWith, convName, dayLabel, sameDay, senderName, senderShortName } from '../format' @@ -70,7 +70,7 @@ export function ChatView({ conv, contact, contactMap, conversations, onOpen, nam if (!chats.length) return [{ label: `No other chats with ${senderShortName(number, contactMap)}`, onSelect: () => undefined, disabled: true }] return chats.map((c) => ({ label: - (isGroup(c.contact) ? convName(c.contact, contactMap, c.name) : `${senderName(c.contact, contactMap)} (just you two, from ${formatNumber(c.did)})`) + + (isGroup(c.contact) ? convName(c.contact, contactMap, c.name) : `${senderName(c.contact, contactMap)} (just you two, from ${didName(c.did)})`) + (c.archived ? ' — archived' : ''), onSelect: () => onOpen({ did: c.did, contact: c.contact }) })) diff --git a/src/renderer/src/components/Composer.tsx b/src/renderer/src/components/Composer.tsx index af2338f..92ae01a 100644 --- a/src/renderer/src/components/Composer.tsx +++ b/src/renderer/src/components/Composer.tsx @@ -1,5 +1,5 @@ import { useEffect, useImperativeHandle, useLayoutEffect, useRef, useState, type ChangeEvent, type Ref } from 'react' -import { charCount, formatNumber, isGroup, SMS_TEXT_LIMIT } from '@shared/phone' +import { charCount, formatNumber, isGroup, SMS_TEXT_LIMIT, didName, groupsFrom, SIM_DID } from '@shared/phone' import type { Did } from '@shared/types' import type { ConvKey } from '../App' import { emojiQuery, exactEmoji, searchEmoji } from '../emoji' @@ -37,8 +37,8 @@ export function Composer({ conv, isNew, smsDids, gvNumber, onChangeDid, ref }: P const key = conv.contact // Google Voice: no SMS/MMS split to count toward, and photos only. const gv = conv.did === gvNumber - // A group thread lives on Google Voice; it can't switch numbers. - const fromDids = isGroup(conv.contact) ? smsDids.filter((d) => d.did === gvNumber) : smsDids + // A group lives on Google Voice or the Rabbit's SIM; only those can carry it. + const fromDids = isGroup(conv.contact) ? smsDids.filter((d) => groupsFrom(d.did, gvNumber)) : smsDids const [text, setText] = useState(() => drafts.get(key) ?? '') const [attachments, setAttachments] = useState(() => attachmentDrafts.get(key) ?? []) const [preparing, setPreparing] = useState(0) @@ -187,8 +187,8 @@ export function Composer({ conv, isNew, smsDids, gvNumber, onChangeDid, ref }: P diff --git a/src/renderer/src/components/MessageBubble.tsx b/src/renderer/src/components/MessageBubble.tsx index b5b36ee..ab83757 100644 --- a/src/renderer/src/components/MessageBubble.tsx +++ b/src/renderer/src/components/MessageBubble.tsx @@ -42,6 +42,8 @@ function Attachment({ id, index, media, onOpen, onMenu, onLoad }: { id: number; const [broken, setBroken] = useState(false) const src = mediaSrc(id, index) const kind = mediaKind(media) + // Still on the Rabbit (relayed history): asked for, it arrives after the Rabbit's next check. + if (broken && media.url?.startsWith('mmspart:') && !media.file) return
On the Rabbit — it'll appear after its next check
if (broken) return
Media unavailable
if (kind === 'image') return ( @@ -107,7 +109,7 @@ export const MessageBubble = memo(function MessageBubble({ m, sender, onSenderMe {media.length > 0 && (
{media.map((ref, i) => ( - onOpenMedia(m.id, i)} onMenu={(e) => onMediaMenu(m.id, i, e)} onLoad={onMediaLoad} /> + onOpenMedia(m.id, i)} onMenu={(e) => onMediaMenu(m.id, i, e)} onLoad={onMediaLoad} /> ))}
)} diff --git a/src/renderer/src/components/NewChat.tsx b/src/renderer/src/components/NewChat.tsx index 2d0dfae..ef2337c 100644 --- a/src/renderer/src/components/NewChat.tsx +++ b/src/renderer/src/components/NewChat.tsx @@ -1,5 +1,5 @@ import { useEffect, useMemo, useRef, useState } from 'react' -import { formatNumber, groupKey, normalizeNumber } from '@shared/phone' +import { formatNumber, groupKey, normalizeNumber, didName, groupsFrom, SIM_DID } from '@shared/phone' import type { ContactInfo, Conversation, Did } from '@shared/types' import type { ConvKey } from '../App' import { Avatar } from './Avatar' @@ -26,7 +26,9 @@ export function NewChat({ contacts, conversations, smsDids, gvNumber, defaultDid const [members, setMembers] = useState([]) const inputRef = useRef(null) const listRef = useRef(null) - const canGroup = !!from && from === gvNumber + const canGroup = groupsFrom(from, gvNumber) + // Where a new group goes from: Google Voice if it's connected, else the Rabbit's SIM. + const groupDid = gvNumber ?? smsDids.find((d) => d.did === SIM_DID)?.did useEffect(() => inputRef.current?.focus(), []) @@ -66,10 +68,10 @@ export function NewChat({ contacts, conversations, smsDids, gvNumber, defaultDid onPick({ did: existing?.did ?? from, contact }) } - // Groups only exist on Google Voice, so starting one sends from there. + // Groups go from Google Voice or the Rabbit's SIM (voip.ms has none). const startGroup = (): void => { - if (!gvNumber) return - setFrom(gvNumber) + if (!groupDid) return + if (!groupsFrom(from, gvNumber)) setFrom(groupDid) setFromChosen(true) setGrouping(true) setQ('') @@ -111,7 +113,7 @@ export function NewChat({ contacts, conversations, smsDids, gvNumber, defaultDid onChange={(e) => { setFrom(e.target.value) setFromChosen(true) - if (e.target.value !== gvNumber) { + if (!groupsFrom(e.target.value, gvNumber)) { setMembers([]) setGrouping(false) } @@ -119,8 +121,8 @@ export function NewChat({ contacts, conversations, smsDids, gvNumber, defaultDid > {smsDids.map((d) => ( ))} @@ -164,8 +166,8 @@ export function NewChat({ contacts, conversations, smsDids, gvNumber, defaultDid {!grouping && !q.trim() && ( diff --git a/src/renderer/src/components/SettingsDialog.tsx b/src/renderer/src/components/SettingsDialog.tsx index 68b2f27..d866d38 100644 --- a/src/renderer/src/components/SettingsDialog.tsx +++ b/src/renderer/src/components/SettingsDialog.tsx @@ -1,6 +1,6 @@ import { useEffect, useState } from 'react' -import type { AppState, RabbitStatus } from '@shared/api' -import { formatNumber } from '@shared/phone' +import type { AppState, RabbitStatus, RelayStatus } from '@shared/api' +import { didName, formatNumber } from '@shared/phone' import type { AddressBook, GvStatus, IconStyle, Settings, SyncStatus, Theme } from '@shared/types' import { CloseIcon } from './Icons' @@ -35,7 +35,7 @@ export function SettingsDialog({ state, sync, onClose, onChanged }: Props) { } const synced = s.dids.length ? s.dids : smsDids.map((d) => d.did) - const sendFrom = state.gvoiceNumber ? [...synced, state.gvoiceNumber] : synced + const sendFrom = [...synced, ...(state.gvoiceNumber ? [state.gvoiceNumber] : []), ...state.dids.filter((d) => d.provider === 'sim').map((d) => d.did)] return (
e.target === e.currentTarget && onClose()}> @@ -129,6 +129,7 @@ export function SettingsDialog({ state, sync, onClose, onChanged }: Props) { setS({ ...s, contactBook })} /> + {smsDids.length > 0 && (
@@ -153,7 +154,7 @@ export function SettingsDialog({ state, sync, onClose, onChanged }: Props) { setUrl(e.target.value)} spellCheck={false} /> + + +
+ +
+ + )} + {done &&

{done}

} + {error &&

{error}

} +
+ ) +} diff --git a/src/renderer/src/components/Via.tsx b/src/renderer/src/components/Via.tsx index 9634d7e..701336c 100644 --- a/src/renderer/src/components/Via.tsx +++ b/src/renderer/src/components/Via.tsx @@ -1,7 +1,13 @@ -import { formatNumber } from '@shared/phone' +import { formatNumber, SIM_DID } from '@shared/phone' // "via ", with a GV tag when it's the Google Voice number. export function Via({ did, gvNumber }: { did: string; gvNumber?: string }) { + if (did === SIM_DID) + return ( + <> + via SIMRabbit + + ) return ( <> via {did === gvNumber && GV} diff --git a/src/shared/api.ts b/src/shared/api.ts index 0880b1e..d908c52 100644 --- a/src/shared/api.ts +++ b/src/shared/api.ts @@ -17,6 +17,14 @@ export interface RabbitStatus { device?: { serial: string; model: string; installedVersion?: string } } +export interface RelayStatus { + connected: boolean + url?: string + lastSync?: number + error?: string + waiting: number // texts sent here via the Rabbit's SIM, not yet done +} + export interface Api { getState(): Promise testCredentials(creds: Credentials): Promise @@ -32,6 +40,10 @@ export interface Api { rabbitStatus(): Promise rabbitInstall(mode?: 'full' | 'update'): Promise // update: app only, keeps its data rabbitSync(): Promise + relayStatus(): Promise + relayConnect(url: string, token: string): Promise + relayDisconnect(): Promise + onRelayStatus(cb: (s: RelayStatus) => void): () => void onRabbitProgress(cb: (step: string) => void): () => void listContacts(): Promise diff --git a/src/shared/phone.ts b/src/shared/phone.ts index fd093f0..fb047df 100644 --- a/src/shared/phone.ts +++ b/src/shared/phone.ts @@ -8,6 +8,20 @@ export function normalizeNumber(raw: string): string { return digits } +// The Rabbit's SIM, reached through jai (main/relay.ts): a number we text +// from that isn't a phone number here. +export const SIM_DID = 'sim' + +// A number to send from, as pickers and "via" show it. +export function didName(did: string): string { + return did === SIM_DID ? 'Rabbit SIM' : formatNumber(did) +} + +// Group chats: Google Voice threads, or MMS over the Rabbit's SIM. +export function groupsFrom(did: string | undefined, gvNumber: string | undefined): boolean { + return !!did && (did === gvNumber || did === SIM_DID) +} + export function formatNumber(n: string): string { const d = normalizeNumber(n) if (d.length === 10) return `(${d.slice(0, 3)}) ${d.slice(3, 6)}-${d.slice(6)}` diff --git a/src/shared/types.ts b/src/shared/types.ts index d9b6757..da13c17 100644 --- a/src/shared/types.ts +++ b/src/shared/types.ts @@ -96,7 +96,7 @@ export interface SearchHit { snippet: string // contains  /  markers around matched text } -export type Provider = 'voipms' | 'gvoice' +export type Provider = 'voipms' | 'gvoice' | 'sim' export interface Did { did: string diff --git a/test/relay.device.test.ts b/test/relay.device.test.ts new file mode 100644 index 0000000..00d0557 --- /dev/null +++ b/test/relay.device.test.ts @@ -0,0 +1,88 @@ +// The relay against the dev app on a plugged-in Rabbit (DEVICE=1 npm test -- +// test/relay.device.test.ts). A throwaway local relay, reached from the Rabbit +// through adb reverse; the dev app's made-up data (tools/push_sandbox.py). +// Never the real app, never jai. +import { execFileSync, spawn, type ChildProcess } from 'node:child_process' +import fs from 'node:fs' +import net from 'node:net' +import os from 'node:os' +import path from 'node:path' +import { afterAll, describe, expect, it, vi } from 'vitest' + +const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'relay-device-')) +vi.mock('electron', () => ({ + app: { getPath: () => tmp }, + safeStorage: { isEncryptionAvailable: () => true, encryptString: (s: string) => Buffer.from(s), decryptString: (b: Buffer) => b.toString() }, + nativeImage: { createFromBuffer: () => ({ getSize: () => ({ width: 0, height: 0 }) }) }, + net: { fetch: () => Promise.reject(new Error('no network in tests')) } +})) + +const { MessageDb } = await import('../src/main/db') +const { MediaStore } = await import('../src/main/media') +const { newKey, RelayEngine } = await import('../src/main/relay') + +const PKG = 'me.teafry.voipmessages.dev' +const DEVICE_PORT = 18080 +let server: ChildProcess | undefined +afterAll(() => { + server?.kill() + try { + execFileSync('adb', ['reverse', '--remove', `tcp:${DEVICE_PORT}`]) + } catch { + /* gone already */ + } +}) + +const sleep = (ms: number): Promise => new Promise((r) => setTimeout(r, ms)) + +describe.skipIf(!process.env['DEVICE'])('relay with the dev app on the Rabbit', () => { + it('seals in Java and opens in Node, and back', { timeout: 240_000 }, async () => { + const port = await new Promise((resolve) => { + const s = net.createServer().listen(0, '127.0.0.1', () => { + const p = (s.address() as net.AddressInfo).port + s.close(() => resolve(p)) + }) + }) + const data = path.join(tmp, 'server') + server = spawn('python3', [path.join(__dirname, '../server/bubble_relay.py'), '--port', String(port), '--data', data], { stdio: 'ignore' }) + const url = `http://127.0.0.1:${port}` + for (let i = 0; i < 50 && !(await fetch(`${url}/health`).then((r) => r.ok).catch(() => false)); i++) await sleep(100) + const token = fs.readFileSync(path.join(data, 'token'), 'utf8').trim() + const key = newKey() + execFileSync('adb', ['reverse', `tcp:${DEVICE_PORT}`, `tcp:${port}`]) + execFileSync('python3', [path.join(__dirname, '../android/tools/push_sandbox.py'), '--relay', `http://127.0.0.1:${DEVICE_PORT}`], { + env: { ...process.env, RELAY_TOKEN: token, RELAY_KEY: key }, + stdio: 'ignore' + }) + + const db = new MessageDb(path.join(tmp, 'messages.db')) + const media = new MediaStore(path.join(tmp, 'media'), db) + const engine = new RelayEngine(db, media, { url, token, key }, 30) + ;(engine as unknown as { running: boolean }).running = true + db.setName('sim', '5415550150', 'Made-up SIM friend') + engine.stateChanged() + const tempId = db.insertPending({ did: 'sim', contact: '5415550150', direction: 'out', body: 'from the desk', ts: Date.now() }) + engine.send(tempId, '5415550150', 'from the desk', []) + await engine.syncNow() + + // Opening the app has it check the relay (a job a few seconds later). + execFileSync('adb', ['shell', 'am', 'start', '-n', `${PKG}/me.teafry.voipmessages.MainActivity`]) + let simIds: number[] = [] + for (let i = 0; i < 40; i++) { + await sleep(4000) + await engine.syncNow() + simIds = db.getConversationMessages('sim', '5415550150').map((m) => m.id) + if (simIds.includes(2 ** 51 + 1) && db.getMessage(tempId)?.status === 'failed') break + // The send's answer comes on the Rabbit's next round: nudge it. + if (i % 5 === 4) execFileSync('adb', ['shell', 'am', 'start', '-S', '-n', `${PKG}/me.teafry.voipmessages.MainActivity`]) + } + // The made-up SIM history came over, decrypted. + expect(simIds).toEqual(expect.arrayContaining([2 ** 51 + 1, 2 ** 51 + 2])) + expect(db.getConversationMessages('sim', '5415550150').find((m) => m.id === 2 ** 51 + 1)?.body).toBe('Texting your SIM number now') + // The send was read and answered (the dev app isn't the default SMS app, so: a reason). + expect(db.getMessage(tempId)?.status).toBe('failed') + expect(db.getMessage(tempId)?.error).toMatch(/texting app/) + engine.stop() + db.close() + }) +}) diff --git a/test/relay.test.ts b/test/relay.test.ts new file mode 100644 index 0000000..bf98764 --- /dev/null +++ b/test/relay.test.ts @@ -0,0 +1,151 @@ +// The relay end to end: the real server (server/bubble_relay.py) on localhost, +// the desktop's RelayEngine on a scratch database, and the Rabbit's side played +// here with the same sealing. Made-up numbers and texts only. +import { spawn, type ChildProcess } from 'node:child_process' +import fs from 'node:fs' +import net from 'node:net' +import os from 'node:os' +import path from 'node:path' +import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest' + +const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'relay-test-')) +vi.mock('electron', () => ({ + app: { getPath: () => tmp }, + safeStorage: { isEncryptionAvailable: () => true, encryptString: (s: string) => Buffer.from(s), decryptString: (b: Buffer) => b.toString() }, + nativeImage: { createFromBuffer: () => ({ getSize: () => ({ width: 0, height: 0 }) }) }, + net: { fetch: () => Promise.reject(new Error('no network in tests')) } +})) + +const { MessageDb } = await import('../src/main/db') +const { MediaStore } = await import('../src/main/media') +const { checkUrl, newKey, RelayEngine, seal, unseal } = await import('../src/main/relay') + +let server: ChildProcess +let url = '' +let token = '' + +async function freePort(): Promise { + return new Promise((resolve) => { + const s = net.createServer().listen(0, '127.0.0.1', () => { + const p = (s.address() as net.AddressInfo).port + s.close(() => resolve(p)) + }) + }) +} + +beforeAll(async () => { + const port = await freePort() + const data = path.join(tmp, 'server') + server = spawn('python3', [path.join(__dirname, '../server/bubble_relay.py'), '--port', String(port), '--data', data], { stdio: 'ignore' }) + url = `http://127.0.0.1:${port}` + for (let i = 0; i < 50; i++) { + const ok = await fetch(`${url}/health`).then((r) => r.ok).catch(() => false) + if (ok) break + await new Promise((r) => setTimeout(r, 100)) + } + token = fs.readFileSync(path.join(data, 'token'), 'utf8').trim() +}) +afterAll(() => server?.kill()) + +// The Rabbit's half: one sync call with its sealed posts; returns what it got. +let rabbitCursor = 0 +async function rabbit(key: Buffer, push: unknown[] = [], raw: string[] = []): Promise>> { + const res = await fetch(`${url}/sync`, { + method: 'POST', + headers: { Authorization: `Bearer ${token}` }, + body: JSON.stringify({ device: 'rabbit', since: rabbitCursor, push: [...push.map((p) => seal(key, 'rabbit', p)), ...raw] }) + }) + const body = (await res.json()) as { cursor: number; events: string[] } + rabbitCursor = body.cursor + return body.events.map((b) => unseal(key, 'desktop', b) as Record) +} + +describe('relay', () => { + it('seals so that only the right key and author open it', () => { + const k = Buffer.from(newKey(), 'base64') + const blob = seal(k, 'desktop', { t: 'x', n: 1 }) + expect(unseal(k, 'desktop', blob)).toEqual({ t: 'x', n: 1 }) + expect(unseal(k, 'rabbit', blob)).toBeUndefined() // a reflected blob isn't the other side's + expect(unseal(Buffer.from(newKey(), 'base64'), 'desktop', blob)).toBeUndefined() + const b = Buffer.from(blob, 'base64') + b[20] ^= 1 + expect(unseal(k, 'desktop', b.toString('base64'))).toBeUndefined() + }) + + it('only sends the token to tailscale or https', () => { + expect(checkUrl('http://100.69.139.40:8080/')).toBe('http://100.69.139.40:8080') + expect(() => checkUrl('http://example.com')).toThrow() + expect(checkUrl('https://example.com')).toBe('https://example.com') + }) + + it('carries texts, photos, sends and chat names both ways', async () => { + const db = new MessageDb(path.join(tmp, 'messages.db')) + const media = new MediaStore(path.join(tmp, 'media'), db, (u, at) => { + if (u.startsWith('mmspart:') && at) engine.want(at.id, at.index, u) + return Promise.reject(new Error('on the Rabbit')) + }) + const cfg = { url, token, key: newKey() } + const key = Buffer.from(cfg.key, 'base64') + const engine = new RelayEngine(db, media, cfg, 30) + const got: number[] = [] + engine.on('messages', (m: Array<{ id: number }>) => got.push(...m.map((x) => x.id))) + ;(engine as unknown as { running: boolean }).running = true + + // Desktop → Rabbit: a text and a photo over the SIM; the state goes too. + engine.stateChanged() + const photo = media.save(Buffer.from('fake jpeg'), 'image/jpeg') + const tempId = db.insertPending({ did: 'sim', contact: '5415550101', direction: 'out', body: 'hi from the desk', ts: Date.now(), kind: 'mms', media: [{ file: photo, mime: 'image/jpeg' }] }) + engine.send(tempId, '5415550101', 'hi from the desk', [{ file: photo, mime: 'image/jpeg' }]) + await engine.syncNow() + const toRabbit = await rabbit(key) + const sendReq = toRabbit.find((p) => p.t === 'send')! + expect(sendReq).toMatchObject({ contact: '5415550101', text: 'hi from the desk' }) + expect(Buffer.from((sendReq.media as Array<{ data: string }>)[0].data, 'base64').toString()).toBe('fake jpeg') + expect(toRabbit.some((p) => p.t === 'state')).toBe(true) + + // Rabbit → desktop: it went out (as message 2^51+7), a text came in, an old photo stays on the Rabbit, a group got a name. + const sentId = 2 ** 51 + 7 + const inId = 2 ** 51 + 8 + const oldMms = 2 ** 51 + 2 ** 49 + 3 + await rabbit( + key, + [ + { t: 'sent', id: sendReq.id, msgId: sentId, error: null }, + { + t: 'msgs', + msgs: [ + { id: sentId, did: 'sim', contact: '5415550101', direction: 'out', body: 'hi from the desk', ts: Date.now(), kind: 'mms' }, + { id: inId, did: 'sim', contact: '5415550101', direction: 'in', body: 'hey!', ts: Date.now() + 1, kind: 'sms' }, + { id: oldMms, did: 'sim', contact: '5415550102', direction: 'in', body: '', ts: Date.now() - 86_400_000, kind: 'mms', media: [{ url: 'mmspart:44', mime: 'image/png' }] }, + { id: 99, did: '5415550100', contact: '5415550103', direction: 'in', body: 'not a SIM message', ts: Date.now() } + ] + }, + { t: 'state', names: [{ did: 'sim', contact: '5415550101,5415550102', name: 'Made-up group', ts: Date.now() }], read: [] } + ], + ['AAAA'] // garbage from a stranger: ignored + ) + await engine.syncNow() + expect(db.getMessage(tempId)).toBeUndefined() + expect(db.getMessage(sentId)?.status).toBe('delivered') + expect(db.getMessage(sentId)?.media?.[0].file).toBe(photo) // our copy kept + expect(db.getConversationMessages('sim', '5415550101').map((m) => m.id)).toEqual([sentId, inId]) + expect(db.getMessage(99)).toBeUndefined() // only did 'sim' comes this way + expect(got).toContain(inId) + expect(db.getName('sim', '5415550101,5415550102')).toBe('Made-up group') + + // The old photo: asked for when shown, delivered by the Rabbit's next check. + expect(await media.resolve(oldMms, 0)).toBeUndefined() + await engine.syncNow() + const want = (await rabbit(key)).find((p) => p.t === 'want')! + expect(want.items).toEqual([{ id: oldMms, index: 0, url: 'mmspart:44' }]) + await rabbit(key, [{ t: 'media', id: oldMms, index: 0, mime: 'image/png', data: Buffer.from('fake png').toString('base64') }]) + await engine.syncNow() + const ref = await media.resolve(oldMms, 0) + expect(fs.readFileSync(media.filePath(ref!.file!)).toString()).toBe('fake png') + + // Picked up = gone from jai. + expect(await rabbit(key)).toEqual([]) + engine.stop() + db.close() + }) +})