replica-bridge 0.3.19 → 0.3.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replica-bridge",
-  "version": "0.3.19",
+  "version": "0.3.22",
   "description": "Lets the ChatReplica iPhone app use Codex on this computer through a relay, end-to-end encrypted.",
   "type": "module",
   "bin": {

package/src/bridge/board.js

@@ -22,8 +22,11 @@ const CHANGES_PAGE = 100;
 const CATCH_UP_PAGES = 1000;
 /** More changed tasks than this in one event, and the phone reads the whole board instead. */
 export const CHANGED_ITEMS_MAX = 200;
-/** What this bridge can do beyond reading, for board/state (PROTOCOL.md "看板"). */
-export const BOARD_CAPS = ["post", "delta", "items", "tasks"]         ;
+/**
+ * What this bridge can do beyond reading, for board/state (PROTOCOL.md "看板"). `ring`: this connection takes the
+ * ring/* frames (PROTOCOL.md "设备环：电脑一侧"), since a board connection has no resume to say it in.
+ */
+export const BOARD_CAPS = ["post", "delta", "items", "tasks", "ring"]         ;
 /** Up to this many changed tasks in one event come with their contents (`task`); past it the phone reads them itself. */
 export const CARRIED_TASKS_MAX = 50;
 /** A task bigger than this is left for the phone to read. */
@@ -39,13 +42,17 @@ const REC = "[A-Za-z0-9_.:-]+";
 /**
  * GETs (#367). /session also writes TASK.md in the task's working folder, which is what 开工 asks for; /share and /me
  * only read. From 0.3.16 also one item, a task's source (`?offset=` pages its text), as the backend's own page opens it.
- * Not /assist, /mcp, /search, /context, /changes (the bridge's own poll) or anything under /ui.
+ * From 0.3.20 also the change log, which unlike the task reads marks nothing seen: the phone counts new tasks from it
+ * for the sidebar while 看板 is closed; and the read state every client shares (agens-backend 0.15.0), which the phone
+ * reads and writes so what was looked at on the desktop is not new again on the phone.
+ * Not /assist, /mcp, /search, /context, /changes/stream (the bridge's own) or anything under /ui.
  */
 const READS = [/^\/v1\/status$/, /^\/v1\/today$/, /^\/v1\/recommendations$/, new RegExp(`^/v1/recommendations/${REC}$`),
-  new RegExp(`^/v1/recommendations/${REC}/(share|session)$`), /^\/v1\/me$/, new RegExp(`^/v1/items/${REC}$`)];
+  new RegExp(`^/v1/recommendations/${REC}/(share|session)$`), /^\/v1\/me$/, new RegExp(`^/v1/items/${REC}$`), /^\/v1\/changes$/,
+  /^\/v1\/me\/read-state$/];
 
 /** POSTs (#367): a task's follow-up actions, cancelling its preparation note, and muting a conversation. Nothing else. */
-const WRITES = [new RegExp(`^/v1/recommendations/${REC}/actions$`), new RegExp(`^/v1/recommendations/${REC}/prep/cancel$`), /^\/v1\/me\/muted$/];
+const WRITES = [new RegExp(`^/v1/recommendations/${REC}/actions$`), new RegExp(`^/v1/recommendations/${REC}/prep/cancel$`), /^\/v1\/me\/muted$/, /^\/v1\/me\/read-state$/];
 /** agens-backend src/recs.mjs ACTIONS. */
 export const BOARD_ACTIONS = ["accept", "snooze", "delegate", "dismiss", "done", "reopen"]         ;
 

package/src/bridge/main.js

@@ -11,6 +11,9 @@
 //   config [--public-url <url>]
 //   devices
 //   revoke <deviceId>
+//   ring [status]                       the device ring this computer is anchored to, and anchors waiting
+//   ring accept|reject [<n|fingerprint>] confirm or refuse a waiting anchor (lists them without an argument)
+//   ring reset [--yes]                  leave the ring, so a different one can be anchored
 import fs from "node:fs";
 import os from "node:os";
 import readline from "node:readline/promises";
@@ -20,8 +23,10 @@ import { spawnCommandSync } from "./command.js";
 import { defaultRelayURL, enroll, ensureEnrolled, ensureRelay } from "./enroll.js";
 import { PACKAGE_VERSION, clearPid, installService, logPath, pauseService, readServiceInfo, runningPid, servicePaused, servicePlan, uninstallService, writePid } from "./install.js";
 import { pair, publicRelayURL } from "./pair.js";
+import { acceptAnchor, anchorPrompt, describeAnchor, findPending, rejectAnchor, removeDevice, resetRing, ringSummary } from "./ring.js";
+                                              
 import { BridgeService } from "./service.js";
-import { loadState, saveState } from "./state.js";
+import { hostKeyPair, loadState, saveState, updateState } from "./state.js";
 
 // A leading option means no command: `replica-bridge --pair` is the default command with --pair.
 const argv = process.argv.slice(2);
@@ -53,7 +58,8 @@ const usage = `replica-bridge ${PACKAGE_VERSION}: lets the ChatReplica app use C
                                   in the background; run again for the status
   npx replica-bridge pair         pair another phone
   npx replica-bridge uninstall    stop and remove the background service
-Others: status, install, start (in this terminal), init, config, devices, revoke <id>.
+  npx replica-bridge ring accept  confirm a device ring asking to include this computer (ring reject, ring reset)
+Others: status, install, start (in this terminal), init, config, devices, revoke <id>, ring.
 The relay is ${defaultRelayURL()} unless --relay or REPLICA_RELAY says otherwise.`;
 
 // The Windows service has no terminal to write to: its output goes to the log file it names.
@@ -78,11 +84,115 @@ function startBridge()                {
     if (process.env.REPLICA_BRIDGE_SERVICE === "1" && process.platform === "win32") pauseService();
     process.exit(0);
   };
-  const service = new BridgeService({ codexPath: values.codex, loginShell: !values["no-login-shell"], streamTTLSeconds: Number(values["stream-ttl"]), onReplaced });
+  const service                = new BridgeService({
+    codexPath: values.codex, loginShell: !values["no-login-shell"], streamTTLSeconds: Number(values["stream-ttl"]), onReplaced,
+    onAnchorRequest: (prompt) => askAnchor(service, prompt),
+  });
   service.start();
   return service;
 }
 
+/** True only for y or yes: anchoring is the one question here whose default is no. */
+async function confirm(question        )                   {
+  const prompt = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try { return /^y(es)?$/i.test((await prompt.question(question)).trim()); } finally { prompt.close(); }
+}
+
+/** Anchor questions in this terminal, one at a time, once nothing else here is asking (askAnchorsHere). */
+let anchorQuestions                = Promise.resolve();
+let askAnchorsHere = false;
+
+function askAnchor(bridge               , prompt              ) {
+  if (!askAnchorsHere) {
+    console.log(`A device asks to anchor this computer to its device ring (fingerprint ${prompt.fingerprint}): run "npx replica-bridge ring accept" to confirm.`);
+    return;
+  }
+  anchorQuestions = anchorQuestions.then(async () => {
+    // Answered meanwhile with `ring accept` or `ring reject` in another terminal.
+    if (!bridge.pendingAnchors().some((p) => p.ring === prompt.ring)) return;
+    console.log(`\n${describeAnchor(prompt)}`);
+    const yes = await confirm("Anchor this computer to this ring? [y/N] ");
+    try {
+      const { removed } = bridge.answerAnchor(prompt.ring, yes);
+      console.log(yes ? `Anchored. The ring's signers can use this computer now.${removed.length ? ` Removed ${removed.join(", ")}, revoked in the ring.` : ""}` : "Rejected. The device can ask again.");
+    } catch (error) {
+      console.error(`replica-bridge: ${(error         ).message}`);
+    }
+  });
+}
+
+/** From here on this terminal asks about anchor requests, starting with any already waiting. */
+function askAnchorsInTerminal(bridge               ) {
+  if (!process.stdin.isTTY || process.env.REPLICA_BRIDGE_SERVICE === "1") return;
+  askAnchorsHere = true;
+  for (const prompt of bridge.pendingAnchors()) askAnchor(bridge, prompt);
+}
+
+/** With the background service serving the computer: ask here about the anchors it recorded (it notices the answer). */
+async function answerPendingHere() {
+  if (!process.stdin.isTTY) return;
+  for (const pending of loadState().ringPending ?? []) {
+    console.log(`\n${describeAnchor(anchorPrompt(pending))}`);
+    const yes = await confirm("Anchor this computer to this ring? [y/N] ");
+    if (yes) acceptAnchor(pending.ring, hostKeyPair(loadState()).publicKey);
+    else rejectAnchor(pending.ring);
+    console.log(yes ? "Anchored." : "Rejected.");
+    if (yes) break;
+  }
+}
+
+async function ringCommand() {
+  const sub = positionals[0] ?? "status";
+  const state = loadState();
+  if (sub === "status") {
+    for (const line of ringSummary(state)) console.log(line);
+    if (state.ringPending?.length) console.log('Confirm with "npx replica-bridge ring accept", refuse with "npx replica-bridge ring reject".');
+    return;
+  }
+  if (sub === "accept" || sub === "reject") {
+    const pending = state.ringPending ?? [];
+    if (!pending.length) { console.log("No device ring is waiting for confirmation."); return; }
+    let which = positionals[1];
+    if (!which) {
+      pending.forEach((p, i) => console.log(`\n${i + 1}. ${describeAnchor(anchorPrompt(p))}`));
+      if (!process.stdin.isTTY) throw new Error(`say which: replica-bridge ring ${sub} <number or fingerprint>`);
+      if (pending.length === 1) {
+        if (!(await confirm(`\n${sub === "accept" ? "Anchor this computer to this ring" : "Reject this request"}? [y/N] `))) return;
+        which = "1";
+      } else {
+        const prompt = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try { which = (await prompt.question(`\nWhich one (1-${pending.length}, empty to stop)? `)).trim(); } finally { prompt.close(); }
+        if (!which) return;
+      }
+    } else {
+      console.log(describeAnchor(anchorPrompt(findPending(state, which))));
+    }
+    // The ring id of what was shown, so a list that changed meanwhile cannot put another ring under the same number.
+    const shown = findPending(state, which).ring;
+    if (sub === "reject") {
+      rejectAnchor(shown);
+      console.log("Rejected. Nothing changed; the device can ask again.");
+      return;
+    }
+    const { ring, removed } = acceptAnchor(shown, hostKeyPair(state).publicKey);
+    console.log(`Anchored to ring ${ring.id}. Its signers can use this computer now; "npx replica-bridge ring reset" leaves it.`);
+    if (removed.length) console.log(`Removed ${removed.join(", ")} from the paired devices: the ring revoked them.`);
+    return;
+  }
+  if (sub === "reset") {
+    if (!state.ring && !state.ringPending?.length) { console.log("Not anchored to a device ring."); return; }
+    for (const line of ringSummary(state)) console.log(line);
+    if (!values.yes) {
+      if (!process.stdin.isTTY) throw new Error("add --yes to leave the ring without a terminal to ask in");
+      if (!(await confirm("Leave this ring? Its signers can no longer use this computer unless paired here. [y/N] "))) return;
+    }
+    resetRing();
+    console.log("Left the device ring. Phones paired here by QR code still connect; a device can ask to anchor again.");
+    return;
+  }
+  throw new Error("usage: replica-bridge ring [status | accept [<n>] | reject [<n>] | reset [--yes]]");
+}
+
 /**
  * Warns, without stopping, when Codex does not answer the way the bridge will run it (through the login shell).
  * The shell is interactive (-i) so it reads the rc file where people put Codex on PATH, and an interactive shell that
@@ -197,6 +307,7 @@ function status() {
   console.log(`Owner: ${state.owner ? `${state.owner.login} (${state.owner.provider})` : "none yet"}; paired phones: ${state.devices.map((d) => d.name).join(", ") || "none"}`);
   if (info) console.log(`Background service ${info.version}: ${pid ? `running (pid ${pid})` : "installed, not running right now"}. Log: ${logPath()}`);
   else console.log(pid ? `Running (pid ${pid}).` : `Not running: "npx replica-bridge" sets up the background service.`);
+  if (state.ring || state.ringPending?.length) for (const line of ringSummary(state)) console.log(line);
 }
 
 async function main() {
@@ -215,6 +326,7 @@ async function main() {
         if (moved || values.install || installed.version !== PACKAGE_VERSION) await install();
         if (moved || values.pair || !state.devices.length) await pairOrExplain();
         else status();
+        await answerPendingHere();
         break;
       }
       if (runningPid()) throw new Error(`a bridge already runs for this computer (pid ${runningPid()}); stop it first`);
@@ -234,6 +346,7 @@ async function main() {
       }
       for (const signal of ["SIGINT", "SIGTERM"]         ) process.on(signal, () => { bridge.stop(); process.exit(0); });
       console.log(`Running in this terminal: paired phones can use Codex on ${state.hostName} until it closes (Ctrl-C stops it).`);
+      askAnchorsInTerminal(bridge);
       if (!(await bridge.waitForRelay(RELAY_WAIT_MS))) console.warn(`Still not connected to the relay${bridge.relayProblem ? ` (${bridge.relayProblem})` : ""}: the phone shows ${state.hostName} offline until it is.`);
       break;
     }
@@ -282,6 +395,7 @@ async function main() {
       if (runningPid()) throw new Error(`a bridge already runs for this computer (pid ${runningPid()})${asService ? "" : '; "npx replica-bridge uninstall" stops the background one'}`);
       const bridge = startBridge();
       if (asService) { writePid(); process.on("exit", clearPid); }
+      askAnchorsInTerminal(bridge);
       for (const signal of ["SIGINT", "SIGTERM"]         ) process.on(signal, () => { bridge.stop(); process.exit(0); });
       break;
     }
@@ -298,11 +412,18 @@ async function main() {
       if (!deviceId) throw new Error("usage: replica-bridge revoke <deviceId>");
       const state = loadState();
       await relayRequest(state.relay, "DELETE", `/v1/host/devices/${encodeURIComponent(deviceId)}`, { token: state.hostToken });
-      state.devices = state.devices.filter((d) => d.deviceId !== deviceId);
-      saveState(state);
+      // Read again after the request: the running bridge may have stored ring entries meanwhile.
+      let name                = null;
+      const after = updateState((latest) => { name = removeDevice(latest, deviceId); });
       console.log(`Removed ${deviceId} from this computer.`);
+      if (name && after.ring) {
+        console.log(`It stays refused here even while this computer's device ring lists it as a signer. To remove "${name}" from your other computers too, remove it from the ring in the app.`);
+      }
       break;
     }
+    case "ring":
+      await ringCommand();
+      break;
     default:
       console.log(usage);
       process.exitCode = 1;

package/src/bridge/pair.js

@@ -136,6 +136,8 @@ export async function pair(options             )
     ...s,
     owner: s.owner ?? { login: info.login, provider: info.provider },
     devices: [...s.devices.filter((d) => d.deviceId !== claim .deviceId), { deviceId: claim .deviceId , publicKey: b64url(devicePublicKey), name: info.deviceName, login: info.login, pairedAt: new Date().toISOString() }],
+    // Scanning it again here is a person saying yes to this key: it is no longer refused (ring.ts removeDevice).
+    ...(s.denied ? { denied: s.denied.filter((d) => d.key !== b64url(devicePublicKey)) } : {}),
   });
   saveState(withDevice(loadState()));
   try {