replica-bridge 0.2.0 → 0.3.1

package/package.json

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

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";
                     
                                 
                                   
+                                                                                                                       
+                         
  
 
                 
@@ -187,6 +193,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 +223,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);
+}