replica-bridge 0.2.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replica-bridge",
-  "version": "0.2.0",
+  "version": "0.3.2",
   "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

@@ -8,7 +8,7 @@ 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()         {

package/src/bridge/service.js

@@ -16,6 +16,8 @@ import {
 import { relaySocketURL } from "../http.js";
 import { killCommand, spawnCommand } from "./command.js";
 import { hostKeyPair, loadState } from "./state.js";
+import { annotateWriterError } from "./writer.js";
+                                          
                                               
 
                                  
@@ -33,6 +35,8 @@ import { hostKeyPair, loadState } from "./state.js";
                                                                                           
      
                           
+                                                                                          
+                                                            
  
 
                   
@@ -44,6 +48,8 @@ import { hostKeyPair, loadState } from "./state.js";
                     
                                 
                                   
+                                                                                                                       
+                         
  
 
                 
@@ -94,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
@@ -187,6 +200,10 @@ export class BridgeService {
       this.scheduleAck(stream);
     } else if (message.t === "ack") {
       conn.stream?.out.ack(message.seq);
+    } else if (message.t === "closed") {
+      // The phone is done with this stream: stop its proxy now, so the app-server unloads the threads it followed and
+      // the computer's other Codex apps can open them, rather than holding them for streamTTL.
+      if (conn.stream) this.endStream(conn.stream, "the phone closed the stream");
     }
   }
 
@@ -213,12 +230,17 @@ export class BridgeService {
 
           async openStream(deviceId        )                  {
     const appServer = await this.connectAppServer();
-    const stream         = { id: crypto.randomBytes(12).toString("base64url"), deviceId, appServer, out: new StreamBuffer(), in: new StreamBuffer(), conn: null, expiry: null, ackTimer: null };
+    const stream         = { id: crypto.randomBytes(12).toString("base64url"), deviceId, appServer, out: new StreamBuffer(), in: new StreamBuffer(), conn: null, expiry: null, ackTimer: null, relayed: Promise.resolve() };
     this.streams.set(stream.id, stream);
     appServer.on("message", (data         ) => {
-      let item;
-      try { item = stream.out.push(data.toString()); } catch { return this.endStream(stream, "the phone stayed away too long and the buffer filled up"); }
-      if (stream.conn) this.sendInner(stream.conn, { t: "msg", seq: item.seq, line: item.line });
+      const annotated = annotateWriterError(data.toString(), this.options.findWriter);
+      stream.relayed = stream.relayed.then(async () => {
+        const line = await annotated;
+        if (!this.streams.has(stream.id)) return;
+        let item;
+        try { item = stream.out.push(line); } catch { return this.endStream(stream, "the phone stayed away too long and the buffer filled up"); }
+        if (stream.conn) this.sendInner(stream.conn, { t: "msg", seq: item.seq, line: item.line });
+      });
     });
     appServer.on("close", () => this.endStream(stream, "codex app-server closed the connection"));
     appServer.on("error", (error) => this.log(`app-server stream ${stream.id}: ${error.message}`));

package/src/bridge/writer.js

@@ -0,0 +1,67 @@
+// Which app holds a thread when the app-server answers "thread <id> already has an active writer". Codex lets one
+// process write a thread at a time through a lock file, `$CODEX_HOME/thread-writer-locks/<id>.lock`, and the error
+// does not say who has it. On the computer the bridge can: whoever has the lock file open. The answer goes back to
+// the phone in the error's `data.replicaWriter`, so the app can say "the ChatGPT desktop app has this task" rather
+// than "another Codex session". Only macOS and Linux (lsof); elsewhere, or when lsof finds nothing, the error passes
+// through unchanged.
+import { execFile } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+
+/** The app holding a thread's lock, as the phone reads it. */
+                                                                                 
+
+                         
+                 
+              
+ 
+
+const ACTIVE_WRITER = /^thread ([0-9A-Za-z-]+) already has an active writer/;
+
+/**
+ * The app behind a process's command line. The ChatGPT desktop app runs its own app-server from inside its bundle
+ * (`/Applications/ChatGPT.app/Contents/Resources/codex-cli/CodexCLI.app/…/codex app-server`, observed with
+ * ChatGPT 155.0.8059.80); `codex exec` runs one for the length of the command.
+ */
+export function classifyWriter(command        )            {
+  if (/\/(ChatGPT|Codex)\.app\//.test(command)) return "chatgpt-desktop";
+  if (/(^|[\s/])codex(\.exe)?\s+(.*\s)?exec(\s|$)/.test(command)) return "codex-exec";
+  if (/(^|[\s/])codex(\.exe)?(\s|$)/.test(command)) return "codex-cli";
+  return "other";
+}
+
+function run(command        , args          )                  {
+  return new Promise((resolve) => {
+    execFile(command, args, { timeout: 3000 }, (_error, stdout) => resolve(String(stdout ?? "")));
+  });
+}
+
+/** Who has the thread's lock file open; null when nobody does or it cannot be told on this platform. */
+export async function findWriter(threadId        , codexHome = process.env.CODEX_HOME || path.join(os.homedir(), ".codex"))                         {
+  if (process.platform === "win32") return null;
+  const lock = path.join(codexHome, "thread-writer-locks", `${threadId}.lock`);
+  const pids = (await run("lsof", ["-t", "--", lock])).split(/\s+/).map(Number).filter((pid) => pid > 0 && pid !== process.pid);
+  for (const pid of pids) {
+    const command = (await run("ps", ["-o", "command=", "-p", String(pid)])).trim();
+    if (command) return { app: classifyWriter(command), pid };
+  }
+  return null;
+}
+
+/**
+ * An app-server line with the writer added to an "already has an active writer" error, or the line itself. Lines
+ * that cannot be such an error are not parsed.
+ */
+export async function annotateWriterError(line        , find                                               = findWriter)                  {
+  if (!line.includes("already has an active writer")) return line;
+  let message;
+  try { message = JSON.parse(line); } catch { return line; }
+  const error = message?.error;
+  const threadId = typeof error?.message === "string" ? ACTIVE_WRITER.exec(error.message)?.[1] : undefined;
+  if (!threadId) return line;
+  const writer = await find(threadId).catch(() => null);
+  if (!writer) return line;
+  const data = error.data && typeof error.data === "object" && !Array.isArray(error.data) ? error.data : {};
+  message.error = { ...error, data: { ...data, replicaWriter: writer } };
+  return JSON.stringify(message);
+}

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,
   };
 }