replica-bridge 0.3.1 → 0.3.3

package/package.json

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

package/src/bridge/enroll.js

@@ -2,13 +2,13 @@
 import fs from "node:fs";
 import os from "node:os";
 import { b64url, generateKeyPair } from "../protocol.js";
-import { relayRequest } from "../http.js";
+import { RelayHTTPError, relayRequest } from "../http.js";
 import { defaultEnvPath, loadRelayConfig } from "../relay/config.js";
 import { loadState, saveState } from "./state.js";
                                               
 
 /** The project's public relay, which the app also signs in to by default (Sources/Core/RelayPairing.swift). */
-export const PUBLIC_RELAY = "https://agens.office-cli.onl";
+export const PUBLIC_RELAY = "https://agensrelay.office-cli.onl";
 
 /** With no --relay: REPLICA_RELAY, else the relay on this machine over loopback, else the public relay. */
 export function defaultRelayURL()         {
@@ -25,6 +25,56 @@ export async function enroll(relay        , options
   return state;
 }
 
+/** Public relays the project ran before; a computer still set up with one moves to the default relay. */
+export const RETIRED_RELAYS = ["https://agens.office-cli.onl"];
+
+const sameURL = (a        , b        ) => a.replace(/\/+$/, "") === b.replace(/\/+$/, "");
+
+/** Whether the saved relay still serves this computer. Throws when it cannot be reached, which may pass. */
+async function checkRelay(state             )                                                     {
+  try {
+    await relayRequest(state.relay, "GET", "/v1/host/devices", { token: state.hostToken });
+    return "ok";
+  } catch (error) {
+    if (!(error instanceof RelayHTTPError)) throw new Error(`cannot reach the relay ${state.relay} (${(error         ).message}); if it moved, run again with --relay <url>`);
+    if (error.status === 401) return "unknown computer";
+    // Something answered but not with the relay's own errors: is it a relay at all? Its / says so.
+    const home = await fetch(state.relay.endsWith("/") ? state.relay : `${state.relay}/`).then((response) => response.text()).catch(() => "");
+    if (home.trim() === "replica-relay") throw error;
+    return "not a relay";
+  }
+}
+
+/**
+ * The saved state, set up afresh whenever it cannot serve a phone: nothing saved yet, --relay or REPLICA_RELAY names
+ * another relay, the saved relay is retired or no longer a relay, or it no longer knows this computer. Pairings live
+ * on one relay, so a fresh set-up has none and the phone scans again; `moved` says a running bridge must restart.
+ */
+export async function ensureRelay(relay                    , say                        , name         )                                                  {
+  let saved             ;
+  try {
+    saved = loadState();
+  } catch (error) {
+    if (!/not set up yet/.test((error         ).message)) throw error;
+    return { state: await ensureEnrolled(relay, say, name), moved: true };
+  }
+  const asked = relay ?? process.env.REPLICA_RELAY;
+  let target        ;
+  let reason        ;
+  if (asked && !sameURL(asked, saved.relay) && !(saved.publicRelay && sameURL(asked, saved.publicRelay))) {
+    [target, reason] = [asked, `it was set up with ${saved.relay}`];
+  } else if (RETIRED_RELAYS.some((url) => sameURL(url, saved.relay))) {
+    [target, reason] = [defaultRelayURL(), `${saved.relay} no longer runs a relay`];
+  } else {
+    const check = await checkRelay(saved);
+    if (check === "ok") return { state: saved, moved: false };
+    [target, reason] = check === "unknown computer" ? [saved.relay, `${saved.relay} no longer knows this computer`] : [defaultRelayURL(), `${saved.relay} is no longer a relay`];
+  }
+  const state = await enroll(target, { name: name ?? saved.hostName, publicRelay: sameURL(target, saved.relay) ? saved.publicRelay : undefined });
+  say(`Set up ${state.hostName} again with ${target} (${state.hostId}): ${reason}. Phones paired before scan the new QR code.`);
+  return { state, moved: true };
+}
+
 /** The saved state, enrolling first if this computer never has. */
 export async function ensureEnrolled(relay                    , say                        , name         )                       {
   try {

package/src/bridge/main.js

@@ -16,7 +16,7 @@ import readline from "node:readline/promises";
 import { parseArgs, format } from "node:util";
 import { relayRequest } from "../http.js";
 import { spawnCommandSync } from "./command.js";
-import { defaultRelayURL, enroll, ensureEnrolled } from "./enroll.js";
+import { defaultRelayURL, enroll, ensureEnrolled, ensureRelay } from "./enroll.js";
 import { PACKAGE_VERSION, clearPid, installService, logPath, readServiceInfo, runningPid, servicePlan, uninstallService, writePid } from "./install.js";
 import { pair, publicRelayURL } from "./pair.js";
 import { BridgeService } from "./service.js";
@@ -138,17 +138,17 @@ async function main() {
     case undefined:
     case "up": {
       const installed = readServiceInfo();
-      if (installed && !values.pair && !values.install) {
-        if (installed.version !== PACKAGE_VERSION) {
-          console.log(`Updating the background service from ${installed.version} to ${PACKAGE_VERSION}.`);
-          install();
-        }
-        status();
+      if (!installed || values.pair || values.install) checkCodex();
+      const { state, moved } = await ensureRelay(values.relay, console.log, values.name);
+      if (installed) {
+        // The background service serves the phone: restart it onto a new set-up or a newer version, then pair.
+        if (moved) console.log("Restarting the background service with the new set-up.");
+        else if (installed.version !== PACKAGE_VERSION) console.log(`Updating the background service from ${installed.version} to ${PACKAGE_VERSION}.`);
+        if (moved || values.install || installed.version !== PACKAGE_VERSION) install();
+        if (moved || values.pair || !state.devices.length) await pairOrExplain();
+        else status();
         break;
       }
-      checkCodex();
-      const state = await ensureEnrolled(values.relay, console.log, values.name);
-      if (installed && !values.install) { await pairOrExplain(); break; } // the background service serves the phone
       if (runningPid()) throw new Error(`a bridge already runs for this computer (pid ${runningPid()}); stop it first`);
       let bridge = startBridge();
       if (values.pair || !state.devices.length) await pairOrExplain();
@@ -168,7 +168,7 @@ async function main() {
       break;
     }
     case "install":
-      await ensureEnrolled(values.relay, console.log, values.name);
+      await ensureRelay(values.relay, console.log, values.name);
       install();
       break;
     case "uninstall": {
@@ -184,6 +184,7 @@ async function main() {
       const state = await enroll(relay, { name: values.name, publicRelay: values["public-url"] });
       console.log(`Set up ${state.hostName} as ${state.hostId}. Next: "npx replica-bridge".`);
       console.log("Nobody owns it yet: the first phone that scans its QR code and is approved here claims it.");
+      if (readServiceInfo()) { console.log("Restarting the background service with the new set-up."); install(); }
       break;
     }
     case "config": {
@@ -194,7 +195,10 @@ async function main() {
       break;
     }
     case "pair":
-      await ensureEnrolled(values.relay, console.log, values.name);
+      if ((await ensureRelay(values.relay, console.log, values.name)).moved && readServiceInfo()) {
+        console.log("Restarting the background service with the new set-up.");
+        install();
+      }
       await pair({ confirm: values.confirm, yes: values.yes, timeoutSeconds: Number(values.timeout), pngPath: values.png });
       if (!runningPid()) console.log(`Nothing serves this computer right now: run "npx replica-bridge" so the phone can connect.`);
       break;

package/src/bridge/pair.js

@@ -74,26 +74,36 @@ async function askTerminal(claim           )                   {
 export async function pair(options             )                                                             {
   const state = loadState();
   const say = (text        ) => { if (!options.quiet) console.log(text); };
-  const secret = crypto.randomBytes(32);
-  const { code, expiresAt } = await relayRequest                                     (state.relay, "POST", "/v1/pair/start", { token: state.hostToken, body: { secretHash: secretHash(secret) } });
-  const link = buildPairingLink({ relay: publicRelayURL(state), hostId: state.hostId, hostPublicKey: fromB64url(state.hostPublicKey), code, secret, hostName: state.hostName });
-  options.onLink?.(link, code);
-  if (!options.quiet) {
-    console.log(await QRCode.toString(link, { type: "terminal", small: true, errorCorrectionLevel: "M" }));
-    console.log(`Scan with the app (远程 › 添加连接 › 配对新设备) or the iPhone camera, or type the code: ${formatCode(code)}`);
-    console.log(`Link: ${link}`);
-    console.log(`Expires at ${new Date(expiresAt).toLocaleTimeString()}. Waiting for the phone…`);
-  }
-  if (options.pngPath) {
-    await QRCode.toFile(options.pngPath, link, { width: 512, errorCorrectionLevel: "M" });
-    say(`QR code also saved to ${options.pngPath}`);
-  }
+  // A code lives five minutes on the relay; until the timeout a fresh one replaces it, so a late scan still works.
+  const deadline = Date.now() + options.timeoutSeconds * 1000;
+  let secret        ;
+  let code        ;
+  let expiresAt        ;
+  const show = async (renewed         ) => {
+    secret = crypto.randomBytes(32);
+    ({ code, expiresAt } = await relayRequest                                     (state.relay, "POST", "/v1/pair/start", { token: state.hostToken, body: { secretHash: secretHash(secret) } }));
+    const link = buildPairingLink({ relay: publicRelayURL(state), hostId: state.hostId, hostPublicKey: fromB64url(state.hostPublicKey), code, secret, hostName: state.hostName });
+    options.onLink?.(link, code);
+    if (!options.quiet) {
+      if (renewed) console.log("The code expired; scan this new one.");
+      console.log(await QRCode.toString(link, { type: "terminal", small: true, errorCorrectionLevel: "M" }));
+      console.log(`Scan with the app (远程 › 添加连接 › 配对新设备) or the iPhone camera, or type the code: ${formatCode(code)}`);
+      console.log(`Link: ${link}`);
+      console.log(`Expires at ${new Date(expiresAt).toLocaleTimeString()}${expiresAt < deadline ? " (a new code follows until " + new Date(deadline).toLocaleTimeString() + ")" : ""}. Waiting for the phone…`);
+    }
+    if (options.pngPath) {
+      await QRCode.toFile(options.pngPath, link, { width: 512, errorCorrectionLevel: "M" });
+      say(`QR code also saved to ${options.pngPath}`);
+    }
+  };
+  await show(false);
 
-  const deadline = Math.min(expiresAt, Date.now() + options.timeoutSeconds * 1000);
   let claim                   = null;
   while (Date.now() < deadline) {
-    const view = await relayRequest           (state.relay, "GET", `/v1/pair/claim?code=${code}`, { token: state.hostToken });
+    if (Date.now() >= expiresAt ) { await show(true); continue; }
+    const view = await relayRequest           (state.relay, "GET", `/v1/pair/claim?code=${code }`, { token: state.hostToken });
     if (view.status === "claimed") { claim = view; break; }
+    if (view.status === "expired") { expiresAt = 0; continue; }
     if (view.status !== "open") throw new Error(`pairing ${view.status}`);
     await new Promise((resolve) => setTimeout(resolve, 1000));
   }
@@ -106,7 +116,7 @@ export async function pair(options             )
   };
   const decide = options.decide ?? askTerminal;
   let approve         ;
-  if (claim.proof && !verifyPairingProof(secret, code, devicePublicKey, fromB64url(claim.proof))) {
+  if (claim.proof && !verifyPairingProof(secret , code , devicePublicKey, fromB64url(claim.proof))) {
     say("The claim's proof does not match this QR code; rejecting it.");
     approve = false;
   } else if (info.safetyCode || options.confirm || (info.firstClaim && !options.yes)) {

package/src/bridge/service.js

@@ -100,7 +100,14 @@ export class BridgeService {
       try { envelope = JSON.parse(data.toString()); } catch { return; }
       this.onEnvelope(envelope);
     });
-    ws.on("unexpected-response", (_req, res) => this.log(`relay refused the host connection: HTTP ${res.statusCode}`));
+    // Something other than the relay answered (a web page where the relay used to be, a proxy error, a revoked
+    // token). With this listener ws leaves the socket half-open and emits no close, so nothing retried and the
+    // process ran out of work and exited 0, which the background services read as "replaced" and left stopped.
+    // Ending the socket goes through close and the usual backoff instead.
+    ws.on("unexpected-response", (_req, res) => {
+      this.log(`relay refused the host connection: HTTP ${res.statusCode}; retrying`);
+      ws.terminate();
+    });
     ws.on("error", (error) => this.log(`relay connection error: ${error.message}`));
     ws.on("close", (code) => {
       if (ws !== this.relay) return; // a socket this bridge already replaced itself

package/src/relay/config.js

@@ -40,6 +40,8 @@ export function readEnvFile(file        )                         {
                                     
                                    
                              
+                                                                                                                       
+                                                           
  
 
 /** "github:583231, 12345, *" → ["583231", "12345", "*"]; anything that is not a numeric id or * is refused. */
@@ -51,6 +53,30 @@ export function parseAllowedIds(text        )           {
   });
 }
 
+/** "~/repos/minim/deploy/minim.env:MINIM_ALLOW" → { file, name }. */
+export function parseAllowedFrom(text        )                                 {
+  const colon = text.lastIndexOf(":");
+  const file = text.slice(0, colon).trim();
+  const name = text.slice(colon + 1).trim();
+  if (colon < 1 || !file || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) throw new Error(`GITHUB_ALLOWED_USERS_FROM takes <env file>:<VARIABLE>, not "${text}"`);
+  return { file: expandHome(file), name };
+}
+
+/**
+ * The allowed GitHub ids: GITHUB_ALLOWED_USERS plus, when set, the list in GITHUB_ALLOWED_USERS_FROM, read again on
+ * every call so editing that file takes effect without a restart. A missing file or variable throws (nobody gets in).
+ */
+export function allowedIdsReader(config                                                             )                 {
+  const from = config.githubAllowedFrom;
+  if (!from) return () => config.githubAllowedIds;
+  return () => {
+    if (!fs.existsSync(from.file)) throw new Error(`GITHUB_ALLOWED_USERS_FROM: ${from.file} does not exist`);
+    const list = readEnvFile(from.file)[from.name];
+    if (list === undefined) throw new Error(`GITHUB_ALLOWED_USERS_FROM: ${from.file} has no ${from.name}`);
+    return [...new Set([...config.githubAllowedIds, ...parseAllowedIds(list)])];
+  };
+}
+
 const expandHome = (value        ) => (value.startsWith("~/") ? path.join(os.homedir(), value.slice(2)) : value);
 
 export function loadRelayConfig(envPath = defaultEnvPath())              {
@@ -72,5 +98,6 @@ export function loadRelayConfig(envPath = defaultEnvPath())              {
     githubClientSecret: get("GITHUB_CLIENT_SECRET"),
     githubCallbackUrl: get("GITHUB_CALLBACK_URL"),
     githubAllowedIds: parseAllowedIds(get("GITHUB_ALLOWED_USERS") ?? ""),
+    githubAllowedFrom: get("GITHUB_ALLOWED_USERS_FROM") ? parseAllowedFrom(get("GITHUB_ALLOWED_USERS_FROM") ) : null,
   };
 }