@minhspark/codex-mcp-bridge 1.11.3 → 1.12.1

package/src/peer-protocol.mjs

@@ -32,7 +32,7 @@ const projectsDir = () => path.join(homeDir(), ".claude", "projects");
 
 /**
  * A Claude Code session advertises itself in ~/.claude/sessions/<pid>.json and
- * listens for peer messages on a unix socket. Messages are newline-delimited
+ * listens for peer messages on a local socket or Windows named pipe. Messages are newline-delimited
  * JSON; the wrapper element is what Claude renders in its chat surface.
  */
 export function buildFrame({ text, fromSocket, priority = "next" }) {
@@ -84,6 +84,30 @@ function isProcessAlive(pid) {
   }
 }
 
+const SESSION_READ_ATTEMPTS = 3;
+const PEER_SEND_ATTEMPTS = 3;
+const PEER_CONNECT_TIMEOUT_MS = 2000;
+const PEER_RETRY_DELAY_MS = 75;
+const RETRYABLE_PEER_ERRORS = new Set(["ECONNREFUSED", "ECONNRESET", "ENOENT", "EPIPE", "ENOTFOUND", "ETIMEDOUT"]);
+
+function readSessionEntry(file) {
+  for (let attempt = 0; attempt < SESSION_READ_ATTEMPTS; attempt += 1) {
+    try {
+      const first = fs.readFileSync(file, "utf8");
+      const second = fs.readFileSync(file, "utf8");
+      if (first !== second) continue;
+      return JSON.parse(second);
+    } catch {}
+  }
+  return null;
+}
+
+function hasMessagingEndpoint(entry) {
+  const socket = entry?.messagingSocketPath;
+  if (IS_WINDOWS && typeof socket === "string" && socket.toLowerCase().startsWith("\\\\.\\pipe\\")) return true;
+  return Boolean(socket) && fs.existsSync(socket);
+}
+
 export const BRIDGE_ENTRYPOINT = "codex-bridge";
 
 export function listClaudeSessions({ includeDead = false, includeBridges = false } = {}) {
@@ -92,15 +116,11 @@ export function listClaudeSessions({ includeDead = false, includeBridges = false
   const rows = [];
   for (const file of fs.readdirSync(dir)) {
     if (!file.endsWith(".json")) continue;
-    let entry;
-    try {
-      entry = JSON.parse(fs.readFileSync(path.join(dir, file), "utf8"));
-    } catch {
-      continue;
-    }
+    const entry = readSessionEntry(path.join(dir, file));
+    if (!entry) continue;
     if (!entry?.pid || !entry?.messagingSocketPath) continue;
     if (entry.entrypoint === BRIDGE_ENTRYPOINT && !includeBridges) continue;
-    const alive = isProcessAlive(entry.pid) && fs.existsSync(entry.messagingSocketPath);
+    const alive = isProcessAlive(entry.pid) && hasMessagingEndpoint(entry);
     if (!alive && !includeDead) continue;
     rows.push({
       pid: entry.pid,
@@ -206,12 +226,8 @@ export class PeerEndpoint {
     for (const file of fs.readdirSync(dir)) {
       if (!file.endsWith(".json")) continue;
       const registry = path.join(dir, file);
-      let entry;
-      try {
-        entry = JSON.parse(fs.readFileSync(registry, "utf8"));
-      } catch {
-        continue;
-      }
+      const entry = readSessionEntry(registry);
+      if (!entry) continue;
       if (entry?.entrypoint !== BRIDGE_ENTRYPOINT) continue;
       if (!entry.pid || entry.pid === this.pid || isProcessAlive(entry.pid)) continue;
       for (const stale of [registry, entry.messagingSocketPath, ...fs.readdirSync(dir)
@@ -328,15 +344,53 @@ export class PeerEndpoint {
 
   async send(targetSocket, text, { priority = "next" } = {}) {
     const frame = buildFrame({ text, fromSocket: this.socketPath, priority });
-    await new Promise((resolve, reject) => {
-      const client = net.connect({ path: targetSocket }, () => {
-        client.write(`${JSON.stringify(frame)}\n`, () => {
-          client.end();
-          resolve();
+    const line = JSON.stringify(frame) + "\n";
+    for (let attempt = 1; attempt <= PEER_SEND_ATTEMPTS; attempt += 1) {
+      try {
+        await new Promise((resolve, reject) => {
+          const client = net.connect({ path: targetSocket });
+          let connected = false;
+          let writeStarted = false;
+          let settled = false;
+          const timer = globalThis.setTimeout(() => {
+            const error = new Error("timed out connecting to " + targetSocket);
+            error.code = "ETIMEDOUT";
+            finish(error);
+            client.destroy();
+          }, PEER_CONNECT_TIMEOUT_MS);
+          const finish = (error) => {
+            if (settled) return;
+            settled = true;
+            globalThis.clearTimeout(timer);
+            if (error) {
+              reject({ error, retryable: !connected && !writeStarted });
+            } else {
+              resolve();
+            }
+          };
+          client.once("connect", () => {
+            connected = true;
+            writeStarted = true;
+            client.write(line, (error) => {
+              if (error) {
+                finish(error);
+                return;
+              }
+              client.end();
+              finish();
+            });
+          });
+          client.once("error", finish);
         });
-      });
-      client.on("error", reject);
-    });
+        return frame.msg_id;
+      } catch (failure) {
+        const error = failure?.error ?? failure;
+        if (!failure?.retryable || attempt === PEER_SEND_ATTEMPTS || !RETRYABLE_PEER_ERRORS.has(error?.code)) {
+          throw error;
+        }
+        await new Promise((resolve) => globalThis.setTimeout(resolve, PEER_RETRY_DELAY_MS));
+      }
+    }
     return frame.msg_id;
   }
 

package/src/platform.mjs

@@ -1,5 +1,5 @@
 import { execFile, execFileSync } from "node:child_process";
-import { accessSync, constants, existsSync } from "node:fs";
+import { accessSync, constants, existsSync, readdirSync, statSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -94,7 +94,26 @@ function isRunnable(candidate) {
 function windowsCodexCandidates() {
   const roaming = process.env.APPDATA;
   const local = process.env.LOCALAPPDATA;
+  const versionedRoot = local && path.join(local, "OpenAI", "Codex", "bin");
+  let versioned = [];
+  if (versionedRoot) {
+    try {
+      versioned = readdirSync(versionedRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(versionedRoot, entry.name, "codex.exe"))
+        .filter((candidate) => isRunnable(candidate))
+        .sort((left, right) => {
+          try {
+            return statSync(path.dirname(right)).mtimeMs - statSync(path.dirname(left)).mtimeMs;
+          } catch {
+            return 0;
+          }
+        });
+    } catch {}
+  }
   return [
+    process.env.CODEX_CLI_PATH,
+    ...versioned,
     local && path.join(local, "Programs", "OpenAI", "Codex", "bin", "codex.exe"),
     roaming && path.join(roaming, "npm", "codex.cmd"),
     process.env.ProgramFiles && path.join(process.env.ProgramFiles, "nodejs", "codex.cmd"),

package/src/thread-delivery.mjs

@@ -0,0 +1,85 @@
+import { NativeDesktopRelay } from "./native-relay.mjs";
+import { runTurn } from "./turn.mjs";
+
+/**
+ * Which backend puts a message into a Codex thread.
+ *
+ * There are two, and they are not interchangeable. The app-server path resumes
+ * the thread through a second app-server, which takes the per-thread writer
+ * lock - correct for a thread nobody else has open, and guaranteed to fail with
+ * `thread <id> already has an active writer` for a thread Codex Desktop is
+ * showing. The native path asks Codex Desktop's own app-server to deliver the
+ * message, so the app stays the single writer and the thread stays open.
+ *
+ * Naming the choice here rather than branching inside the relay keeps
+ * `claude-bridge` unaware of either mechanism: it asks for delivery and is told
+ * which backend did it.
+ */
+export const NATIVE_BACKEND = "codex-desktop-native";
+export const APP_SERVER_BACKEND = "app-server";
+const RELEASE_STATUSES = new Set(["completed", "interrupted", "failed", "disconnected"]);
+
+export function createThreadDelivery({
+  codex,
+  relay = new NativeDesktopRelay(),
+  log = () => {},
+  timeoutMs = 240000,
+  releaseAfterTurn =
+    process.env.CODEX_BRIDGE_RELEASE_AFTER_TURN !== undefined
+      ? process.env.CODEX_BRIDGE_RELEASE_AFTER_TURN === "1"
+      : process.platform === "win32",
+} = {}) {
+  let reportedUnavailable = null;
+
+  /**
+   * Falling back is right when the companion never answered - an absent relay
+   * says nothing about the target thread, and the older path is exactly as good
+   * as it was before this backend existed. It is wrong once the companion has
+   * answered: Codex has already refused, and retrying through a second
+   * app-server only spawns a process that contends for the ~/.codex state and
+   * then fails on the writer lock the native path exists to avoid.
+   */
+  async function deliver(threadId, text) {
+    const status = relay.status();
+    if (status.enabled) {
+      try {
+        const ack = await relay.sendMessage(threadId, text);
+        reportedUnavailable = null;
+        return { backend: NATIVE_BACKEND, threadId, ack };
+      } catch (err) {
+        if (err.reachedCompanion) throw err;
+        log(`native relay unreachable (${err.message}); falling back to the app-server path`);
+      }
+    } else if (status.reason !== reportedUnavailable) {
+      reportedUnavailable = status.reason;
+      log(`native relay not in use: ${status.reason}`);
+    }
+
+    if (!codex) throw new Error("No Codex app-server client is configured to deliver this message");
+    await codex.ensureThreadAttached(threadId);
+    const turn = await runTurn(codex, {
+      threadId,
+      input: [{ type: "text", text }],
+      timeoutMs,
+    });
+    if (releaseAfterTurn && RELEASE_STATUSES.has(turn.status) && typeof codex.stopServer === "function") {
+      try {
+        const released = await codex.stopServer();
+        if (released?.stillListening) log("app-server release requested but it is still listening");
+        if (released?.stopped === false) log("app-server release skipped: " + (released.reason ?? "unknown reason"));
+      } catch (err) {
+        log("app-server release failed: " + err.message);
+      }
+    }
+    return { backend: APP_SERVER_BACKEND, threadId, turn };
+  }
+
+  function describe() {
+    const status = relay.status();
+    return status.enabled
+      ? `${NATIVE_BACKEND} via ${status.socketPath}`
+      : `${APP_SERVER_BACKEND} (${status.reason})`;
+  }
+
+  return { deliver, describe };
+}