@minhspark/codex-mcp-bridge 1.13.2 → 1.13.4

package/src/peer-protocol.mjs

@@ -187,9 +187,21 @@ export function listClaudeSessions({ includeDead = false, includeBridges = false
   return rows.sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0));
 }
 
-export function findClaudeSession(target) {
+export function findClaudeSession(target, { desktopOnly = false, expectedCwd } = {}) {
   const sessions = listClaudeSessions();
   const needle = String(target).trim();
+  if (desktopOnly) {
+    const byId = sessions.filter((session) => String(session.pid) === needle || session.sessionId === needle);
+    const matches = byId.length ? byId : sessions.filter((session) => session.name === needle);
+    if (!needle || matches.length === 0) return null;
+    if (matches.length !== 1) throw new Error(`Desktop-only mode requires an unambiguous sessionId or pid; "${needle}" matches multiple sessions. No message was sent.`);
+    const session = matches[0];
+    if (session.entrypoint !== "claude-desktop") {
+      throw new Error(`Desktop-only mode refuses Claude session ${session.sessionId ?? session.pid} with entrypoint ${session.entrypoint ?? "unknown"}. Open or reconnect an existing Code session in Claude Desktop for the intended project. Do not launch a replacement CLI session. No message was sent.`);
+    }
+    if (expectedCwd !== undefined) assertClaudeSessionCwd(session, expectedCwd);
+    return session;
+  }
   return (
     sessions.find((s) => String(s.pid) === needle) ??
     sessions.find((s) => s.sessionId === needle) ??
@@ -199,6 +211,24 @@ export function findClaudeSession(target) {
   );
 }
 
+export function assertClaudeSessionCwd(session, expectedCwd) {
+  if (typeof expectedCwd !== "string" || !path.isAbsolute(expectedCwd) || !session.cwd || !path.isAbsolute(session.cwd)) {
+    throw new Error("Desktop delivery requires an explicit absolute expectedCwd and an absolute session cwd. No message was sent.");
+  }
+  let expected;
+  let actual;
+  try {
+    expected = fs.realpathSync.native(expectedCwd);
+    actual = fs.realpathSync.native(session.cwd);
+  } catch {
+    throw new Error("The intended project directory or the Claude session cwd no longer exists. No message was sent.");
+  }
+  const normalize = (value) => IS_WINDOWS ? value.toLowerCase() : value;
+  if (normalize(expected) !== normalize(actual)) {
+    throw new Error(`Claude session cwd ${actual} does not match expectedCwd ${expected}. No message was sent.`);
+  }
+}
+
 /**
  * Claude Code stores a transcript at ~/.claude/projects/<slug>/<sessionId>.jsonl
  * where the slug rewrites more than just path separators (/mnt/dev_disk ->
@@ -292,6 +322,7 @@ export class PeerEndpoint {
     this.peerToken = null;
     this.permissionMode = process.env.CLAUDE_BRIDGE_PERMISSION_MODE;
     this.deliveryReceipts = new Map();
+    this.sentMessages = new Map();
     this.pendingMessages = new Map();
     this.responsePoll = null;
   }
@@ -432,7 +463,12 @@ export class PeerEndpoint {
   #receiveMessage(message) {
     const record = { ...message, receivedAt: Date.now(), sequence: ++this.messageSequence };
     this.inbox.push(record);
-    this.#removePendingReply(record.fromSocket, record.inReplyTo);
+    const key = record.inReplyTo ?? [...this.pendingMessages].find(([, entry]) => entry.targetSocket === record.fromSocket)?.[0];
+    if (key && this.pendingMessages.get(key)?.targetSocket === record.fromSocket) {
+      const sent = this.sentMessages.get(key);
+      if (sent) sent.reply = record;
+      this.#removePendingReply(record.fromSocket, key);
+    }
     this.log(`inbox <- ${record.fromSocket ?? "?"}: ${record.text.slice(0, 120)}`);
     for (const listener of [...this.listeners]) {
       try { listener(record); }
@@ -503,6 +539,7 @@ export class PeerEndpoint {
             settled = true;
             globalThis.clearTimeout(timer);
             if (error) {
+              if (connected || writeStarted) error.deliveryUncertain = true;
               reject({ error, retryable: !connected && !writeStarted });
             } else {
               resolve();
@@ -534,14 +571,15 @@ export class PeerEndpoint {
     return frame.msg_id;
   }
 
-  async sendAndWait(targetSocket, text, { timeoutMs = 120000, priority = "next", transcriptSession } = {}) {
+  async sendAndWait(targetSocket, text, { timeoutMs = 120000, priority = "next", transcriptSession, beforeSend } = {}) {
     const previous = this.requestQueues.get(targetSocket) ?? Promise.resolve();
     const pending = previous.catch(() => {}).then(async () => {
+      beforeSend?.();
       const unconfirmed = this.unconfirmedReplies.get(targetSocket) ?? 0;
-      if (timeoutMs > 0 && unconfirmed > 0) {
+      if (unconfirmed > 0) {
         const error = new Error(
           `${unconfirmed} earlier message(s) to ${targetSocket} still await a reply; this message was not sent. `
-          + "Wait for Claude's outstanding replies and check read_claude_inbox, or set waitSec to 0 to send without matching a reply.",
+          + "Inspect read_claude_delivery and wait for Claude's outstanding replies. Changing waitSec or starting another bridge must not be used to bypass a pending message.",
         );
         error.code = "PEER_REPLY_PENDING";
         throw error;
@@ -551,22 +589,31 @@ export class PeerEndpoint {
       this.unconfirmedReplies.set(targetSocket, unconfirmed + 1);
       let msgId = crypto.randomUUID();
       this.pendingMessages.set(msgId, { targetSocket, transcriptSession });
+      this.sentMessages.set(msgId, { targetSocket, transcriptSession, sentAt: since });
+      if (transcriptSession && !this.responsePoll) {
+        this.responsePoll = globalThis.setInterval(() => this.#refreshTranscriptReplies(), 250);
+        this.responsePoll.unref();
+      }
       try {
         const sentId = await this.send(targetSocket, text, { priority, msgId });
         if (sentId !== msgId) {
           const pendingMessage = this.pendingMessages.get(msgId);
           this.pendingMessages.delete(msgId);
+          this.sentMessages.set(sentId, this.sentMessages.get(msgId));
+          this.sentMessages.delete(msgId);
           msgId = sentId;
           if (pendingMessage) this.pendingMessages.set(msgId, pendingMessage);
         }
       } catch (err) {
-        this.#removePendingReply(targetSocket, msgId);
+        const sent = this.sentMessages.get(msgId);
+        if (sent) sent.error = err.message;
+        if (!err.deliveryUncertain) {
+          this.#removePendingReply(targetSocket, msgId);
+          if (sent) sent.failed = true;
+        }
+        err.msgId = msgId;
         throw err;
       }
-      if (transcriptSession && !this.responsePoll && this.pendingMessages.has(msgId)) {
-        this.responsePoll = globalThis.setInterval(() => this.#refreshTranscriptReplies(), 250);
-        this.responsePoll.unref();
-      }
       const reply = timeoutMs > 0
         ? await this.waitForReply(targetSocket, { timeoutMs, since, afterSequence, msgId })
         : null;
@@ -584,7 +631,8 @@ export class PeerEndpoint {
 
   #removePendingReply(fromSocket, msgId) {
     const key = msgId ?? [...this.pendingMessages].find(([, entry]) => entry.targetSocket === fromSocket)?.[0];
-    if (key) this.pendingMessages.delete(key);
+    if (!key || this.pendingMessages.get(key)?.targetSocket !== fromSocket) return;
+    this.pendingMessages.delete(key);
     const pending = this.unconfirmedReplies.get(fromSocket) ?? 0;
     if (pending > 1) this.unconfirmedReplies.set(fromSocket, pending - 1);
     else this.unconfirmedReplies.delete(fromSocket);
@@ -596,6 +644,7 @@ export class PeerEndpoint {
    */
   waitForReply(fromSocket, { timeoutMs = 120000, since = Date.now(), afterSequence = null, msgId } = {}) {
     const matches = (record) => record.fromSocket === fromSocket
+      && (!record.inReplyTo || !msgId || record.inReplyTo === msgId)
       && (afterSequence === null ? record.receivedAt >= since : record.sequence > afterSequence);
     const existing = this.inbox.find(matches);
     if (existing) return Promise.resolve(existing);
@@ -624,6 +673,24 @@ export class PeerEndpoint {
     return messages;
   }
 
+  readDelivery(msgId) {
+    const sent = this.sentMessages.get(msgId);
+    if (!sent) return null;
+    const delivery = this.deliveryReceipts.get(msgId);
+    const session = sent.transcriptSession;
+    return {
+      msgId,
+      status: sent.reply ? "reply_received" : sent.failed ? "send_failed" : delivery?.status ?? "sent_unconfirmed",
+      reason: delivery?.reason ?? sent.error ?? null,
+      sentAt: sent.sentAt,
+      sessionId: session?.sessionId ?? null,
+      cwd: session?.cwd ?? null,
+      entrypoint: session?.entrypoint ?? null,
+      pending: this.pendingMessages.has(msgId),
+      ...(sent.reply ? { reply: sent.reply.text, source: sent.reply.source ?? "peer" } : {}),
+    };
+  }
+
   stop() {
     globalThis.clearInterval(this.responsePoll);
     this.responsePoll = null;

package/src/platform.mjs

@@ -20,7 +20,8 @@ export const PLATFORM_LABEL = IS_MACOS
       : process.platform;
 
 const CODEX_DESKTOP_APP_MACOS = "/Applications/ChatGPT.app";
-const CODEX_DESKTOP_BIN_MACOS = `${CODEX_DESKTOP_APP_MACOS}/Contents/Resources/codex`;
+const CODEX_DESKTOP_RESOURCES_MACOS = `${CODEX_DESKTOP_APP_MACOS}/Contents/Resources`;
+const CODEX_DESKTOP_BIN_MACOS = `${CODEX_DESKTOP_RESOURCES_MACOS}/codex`;
 const CODEX_THREAD_URL_PREFIX = "codex://threads/";
 
 /**
@@ -176,6 +177,59 @@ export function resolveCodexBin(explicit) {
   return "codex";
 }
 
+/**
+ * Codex Desktop authenticates the code-signing identity of whatever process
+ * connects to its native tools pipe, and closes the connection before reading
+ * a single byte when that identity is not the vendor's - the app records
+ * `dynamic_app_tools_peer_rejected`. A companion launched by the user's own
+ * Node build carries the Node.js Foundation signature rather than OpenAI's,
+ * so the relay still reports itself installed and still creates its socket
+ * while every delivery fails; the symptom surfaces nowhere near the cause.
+ * The runtime therefore has to be the one the app ships, which is also the
+ * one the app hands its own bundled plugin through CODEX_MCP_NODE_PATH.
+ *
+ * The vendor's launcher additionally falls back to a cached runtime under
+ * ~/.cache/codex-runtimes and to a bare PATH lookup. Both are deliberately
+ * absent here: the cached binary measured on a real install is the same
+ * version and within 1.3 KB of the bundled one, yet carries the Node.js
+ * Foundation signature, so copying that list wholesale would reproduce the
+ * rejection this resolves under a different file name. For the same reason
+ * the runtime is never taken from PATH or from a version match.
+ *
+ * Only macOS ships this bundle and only macOS was measured to enforce the
+ * check, so the vendor-owned rungs are gated by platform. Every other
+ * platform keeps the runtime it has always used, and the last rung is an
+ * unconditional real path rather than a bare command name because the caller
+ * writes the result straight into client configuration.
+ */
+export function resolveCodexDesktopNodeBin(
+  explicit,
+  { env = process.env, platform = process.platform, resourcesDir = CODEX_DESKTOP_RESOURCES_MACOS } = {},
+) {
+  const bundledNode = (dir) => path.join(dir, "cua_node", "bin", platform === "win32" ? "node.exe" : "node");
+  const vendorRungs =
+    platform === "darwin"
+      ? [
+          [env.CODEX_MCP_NODE_PATH, "CODEX_MCP_NODE_PATH"],
+          [env.CODEX_BROWSER_USE_NODE_PATH, "CODEX_BROWSER_USE_NODE_PATH"],
+          [
+            env.CODEX_ELECTRON_RESOURCES_PATH && bundledNode(env.CODEX_ELECTRON_RESOURCES_PATH),
+            "CODEX_ELECTRON_RESOURCES_PATH",
+          ],
+          [bundledNode(resourcesDir), "Codex Desktop bundle"],
+        ]
+      : [];
+
+  for (const [candidate, source] of [
+    [explicit, "explicit"],
+    [env.CODEX_NATIVE_RELAY_NODE, "CODEX_NATIVE_RELAY_NODE"],
+    ...vendorRungs,
+  ]) {
+    if (candidate && isRunnable(candidate)) return { path: candidate, source };
+  }
+  return { path: process.execPath, source: "process.execPath" };
+}
+
 /**
  * The macOS and Linux `codex` launcher is a Node script with a
  * `#!/usr/bin/env node` shebang, so the spawned child needs a PATH that

package/src/runtime-state.mjs

@@ -0,0 +1,34 @@
+import { createHash } from "node:crypto";
+import { readFileSync, readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+export function createRuntimeState({ directory = path.dirname(fileURLToPath(import.meta.url)), configuration = () => null } = {}) {
+  const fingerprint = () => {
+    const hash = createHash("sha256");
+    for (const file of ["../package.json", ...readdirSync(directory).filter((file) => file.endsWith(".mjs")).sort()]) {
+      hash.update(file).update("\0").update(readFileSync(path.join(directory, file))).update("\0");
+    }
+    return hash.digest("hex");
+  };
+  const revision = fingerprint();
+  const configured = JSON.stringify(configuration());
+  const startedAt = new Date().toISOString();
+  const status = () => {
+    let diskRevision = null;
+    let reason = null;
+    try {
+      diskRevision = fingerprint();
+      if (diskRevision !== revision) reason = "Bridge source changed after this MCP process started";
+      else if (JSON.stringify(configuration()) !== configured) reason = "Bridge routing configuration changed after this MCP process started";
+    } catch {
+      reason = "Bridge source or routing configuration can no longer be read";
+    }
+    return { pid: process.pid, startedAt, revision, diskRevision, current: reason === null, reason };
+  };
+  const assertCurrent = () => {
+    const state = status();
+    if (!state.current) throw new Error(`${state.reason}. Reconnect this MCP server in the existing Desktop task before sending. No message was sent; do not create a replacement task or use an external app-server.`);
+  };
+  return { status, assertCurrent };
+}

package/src/thread-delivery.mjs

@@ -64,8 +64,9 @@ export class DesktopTaskDelivery {
 
   async withThread(threadId, operation, { deadline } = {}) {
     const previous = this.threadOperations.get(threadId) ?? Promise.resolve();
+    let expired = false;
     const current = previous.catch(() => {}).then(() => {
-      if (deadline !== undefined && this.now() >= deadline) throw new Error("The response deadline elapsed while another operation held this thread. No new prompt was sent.");
+      if (expired || (deadline !== undefined && this.now() >= deadline)) throw new Error("The response deadline elapsed while another operation held this thread. No new prompt was sent.");
       return operation();
     });
     this.threadOperations.set(threadId, current);
@@ -75,7 +76,10 @@ export class DesktopTaskDelivery {
     let timer;
     try {
       return await Promise.race([current, new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error("The Desktop response deadline elapsed. A previous operation may still be running; inspect the existing task before sending anything again.")), Math.max(1, deadline - this.now()));
+        timer = setTimeout(() => {
+          expired = true;
+          reject(new Error("The Desktop response deadline elapsed. A previous operation may still be running; inspect the existing task before sending anything again."));
+        }, Math.max(1, deadline - this.now()));
       })]);
     } finally {
       clearTimeout(timer);
@@ -129,7 +133,45 @@ export class DesktopTaskDelivery {
     if (thread?.id !== receipt.threadId || thread.hostId !== "local" || !thread.cwd || path.relative(cwd, realpathSync.native(thread.cwd))) throw new Error(`Existing Desktop task ${receipt.threadId} did not confirm the requested local workspace. No prompt was sent.`);
     this.security.assertCwd(thread.cwd);
     this.security.assertThread(thread.id, thread.cwd);
-    return { threadId: receipt.threadId, name: thread.title ?? receipt.name ?? "(unnamed)", cwd, projectId: receipt.projectId, projectName: receipt.projectName, backend: NATIVE_BACKEND, reused: true, promptChanged: receipt.promptHash !== promptHash };
+    const assignment = await this.receiptProjectAssignment(receipt, cwd, { deadline });
+    return { threadId: receipt.threadId, name: thread.title ?? receipt.name ?? "(unnamed)", cwd, ...assignment, backend: NATIVE_BACKEND, reused: true, promptChanged: receipt.promptHash !== promptHash };
+  }
+
+  async receiptProjectAssignment(receipt, cwd, { deadline }) {
+    let project;
+    try {
+      const listed = await this.request("list_projects", {}, { deadline });
+      if (!Array.isArray(listed?.projects)) throw new Error("Desktop returned no project list");
+      project = matchDesktopProject(listed.projects, cwd);
+      if (receipt.projectId && receipt.projectId !== project.projectId) throw new Error("The saved project identity changed for this directory");
+    } catch (err) {
+      throw new Error(`Existing Desktop task ${receipt.threadId}'s saved project could not be verified: ${err.message}. No prompt was resent and no duplicate task was created. Inspect this existing task and its project settings.`, { cause: err });
+    }
+    const unverified = (reason) => ({
+      expectedProjectId: project.projectId,
+      expectedProjectName: project.label,
+      projectAssignmentStatus: "unverified",
+      projectAssignmentNote: `${reason} The task's current project assignment is unverified. Its workspace and existing ID were retained; no prompt was resent and no duplicate task was created. Inspect this task in Codex Desktop.`,
+    });
+    let snapshot;
+    try {
+      snapshot = await this.request("list_threads", { limit: 50 }, { deadline });
+      if (!Array.isArray(snapshot?.threads) || !Array.isArray(snapshot?.pinnedThreads)) throw new Error("Desktop returned an invalid thread list");
+      if (snapshot.unavailableHosts?.some((host) => host === "local" || host?.hostId === "local")) throw new Error("The local Desktop host is unavailable");
+    } catch (err) {
+      return unverified(`Desktop's recent/pinned listing could not be confirmed: ${err.message}.`);
+    }
+    const observed = [...snapshot.pinnedThreads, ...snapshot.threads].filter((thread) => thread?.id === receipt.threadId && thread.kind === "codex" && thread.hostId === "local");
+    if (observed.length === 0) return unverified("This task is absent from Desktop's recent/pinned listing.");
+    for (const thread of observed) {
+      if (thread.projectId !== undefined && thread.projectId !== project.projectId) throw new Error(`Existing Desktop task ${receipt.threadId}'s project assignment changed. No prompt was resent and no duplicate task was created. Inspect its assignment in Codex Desktop.`);
+      if (thread.cwd) {
+        this.security.assertCwd(thread.cwd);
+        if (path.relative(cwd, realpathSync.native(thread.cwd))) throw new Error(`Existing Desktop task ${receipt.threadId}'s listed workspace changed. No prompt was resent and no duplicate task was created.`);
+      }
+    }
+    if (observed.some((thread) => thread.projectId === undefined || !thread.cwd)) return unverified("Desktop's listing omitted this task's project or workspace metadata.");
+    return { projectId: project.projectId, projectName: project.label, projectAssignmentStatus: "verified" };
   }
 
   async create({ cwd, prompt, name, dedupeName = name, model, effort, deadline = this.now() + DESKTOP_TOOL_BUDGET_MS }) {