@minhspark/codex-mcp-bridge 1.13.9 → 1.15.1

package/src/native-relay-companion.mjs

@@ -11,7 +11,11 @@ import {
   MAX_FRAME_BYTES,
   NATIVE_DISPATCH_METHOD,
   NativeToolsClient,
+  NativeRelayError,
   RELAY_PROTOCOL_VERSION,
+  ACCOUNT_RELAY_PROTOCOL_VERSION,
+  accountRelaySocketPath,
+  relayAccountContext,
   relaySocketPath,
   resolveRelayThreadId,
   desktopTaskSocketPath,
@@ -20,14 +24,32 @@ import {
 } from "./native-relay.mjs";
 import { IS_WINDOWS, PLATFORM_LABEL } from "./platform.mjs";
 import { exitForVersionRequest } from "./cli-version.mjs";
+import { assertAccountIdentity } from "./bridge-account-context.mjs";
+import { createReloadControl } from "./reload-control.mjs";
+import { createRuntimeState } from "./runtime-state.mjs";
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.13.9";
+const VERSION = "1.15.1";
 const log = (msg) => process.stderr.write(`[native-relay] ${msg}\n`);
 
-function errorResponse(code, message) {
-  return { ok: false, v: RELAY_PROTOCOL_VERSION, error: { code, message } };
+function errorResponse(code, message, sent) {
+  return { ok: false, v: RELAY_PROTOCOL_VERSION, error: { code, message, ...(sent === false ? { sent: false } : {}) } };
+}
+
+function boundRequest(payload) {
+  return payload?.v === ACCOUNT_RELAY_PROTOCOL_VERSION;
+}
+
+function validProtocol(payload) {
+  return boundRequest(payload) ? Object.hasOwn(payload, "accountContext") : (payload?.v === undefined || payload.v === RELAY_PROTOCOL_VERSION) && !Object.hasOwn(payload, "accountContext");
+}
+
+async function checkAccountContext(payload, assertAccount) {
+  const accounts = relayAccountContext(payload.accountContext);
+  if (boundRequest(payload) && !accounts) throw new NativeRelayError("Protocol 2 requires the original account context", "RELAY_BAD_REQUEST");
+  if (accounts) await assertAccount(accounts);
+  return accounts;
 }
 
 /**
@@ -46,14 +68,13 @@ function errorCode(err) {
  */
 export async function handleRelayRequest(
   payload,
-  { dispatch, dispatchDesktop, resolveExecutor = resolveRelayThreadId, env = process.env } = {},
+  { dispatch, dispatchDesktop, resolveExecutor = resolveRelayThreadId, env = process.env, assertAccount = assertAccountIdentity } = {},
 ) {
   if (payload && typeof payload === "object" && Object.hasOwn(payload, "operation")) {
-    return handleDesktopRequest(payload, { dispatchDesktop, resolveExecutor, env });
+    return handleDesktopRequest(payload, { dispatchDesktop, resolveExecutor, env, assertAccount });
   }
   if (!payload || typeof payload !== "object" || Array.isArray(payload) ||
-      Object.keys(payload).some((key) => !["v", "targetThreadId", "message"].includes(key)) ||
-      (payload.v !== undefined && payload.v !== RELAY_PROTOCOL_VERSION)) {
+      Object.keys(payload).some((key) => !["v", "targetThreadId", "message", "accountContext"].includes(key)) || !validProtocol(payload)) {
     return errorResponse("RELAY_BAD_REQUEST", "expected a relay request with targetThreadId and message");
   }
   const targetThreadId = typeof payload?.targetThreadId === "string" ? payload.targetThreadId.trim() : "";
@@ -63,10 +84,12 @@ export async function handleRelayRequest(
   if (!message.trim()) return errorResponse("RELAY_BAD_REQUEST", "message must be a non-empty string");
 
   let executorThreadId;
+  let accountContext;
   try {
+    accountContext = await checkAccountContext(payload, assertAccount);
     executorThreadId = resolveExecutor(env).threadId;
   } catch (err) {
-    return errorResponse(errorCode(err), err.message);
+    return errorResponse(errorCode(err), err.message, false);
   }
 
   /**
@@ -83,24 +106,30 @@ export async function handleRelayRequest(
   }
 
   try {
-    const result = await dispatch({ executorThreadId, targetThreadId, message });
+    const result = await dispatch({ executorThreadId, targetThreadId, message }, { accountContext });
     if (result?.success !== true || result?.isError === true) {
       const detail = typeof result?.error === "string" ? result.error : result?.error?.message;
       return errorResponse("NATIVE_DISPATCH_FAILED", detail ?? "Codex Desktop did not confirm successful native dispatch");
     }
-    return { ok: true, v: RELAY_PROTOCOL_VERSION, targetThreadId, executorThreadId, result: result ?? null };
+    return { ok: true, v: boundRequest(payload) ? ACCOUNT_RELAY_PROTOCOL_VERSION : RELAY_PROTOCOL_VERSION, targetThreadId, executorThreadId, result: result ?? null };
   } catch (err) {
-    return errorResponse(errorCode(err), err?.message ?? String(err));
+    return errorResponse(errorCode(err), err?.message ?? String(err), err?.sent === false && err?.reachedCompanion !== true ? false : undefined);
   }
 }
 
-async function handleDesktopRequest(payload, { dispatchDesktop, resolveExecutor, env }) {
-  if (Array.isArray(payload) || payload.v !== RELAY_PROTOCOL_VERSION ||
-      Object.keys(payload).some((key) => !["v", "operation", "arguments"].includes(key))) {
+async function handleDesktopRequest(payload, { dispatchDesktop, resolveExecutor, env, assertAccount }) {
+  if (Array.isArray(payload) || ![RELAY_PROTOCOL_VERSION, ACCOUNT_RELAY_PROTOCOL_VERSION].includes(payload.v) || !validProtocol(payload) ||
+      Object.keys(payload).some((key) => !["v", "operation", "arguments", "accountContext"].includes(key))) {
     return errorResponse("RELAY_BAD_REQUEST", "expected an allowlisted Desktop operation");
   }
   try {
     validateDesktopOperation(payload.operation, payload.arguments);
+    let accountContext;
+    try {
+      accountContext = await checkAccountContext(payload, assertAccount);
+    } catch (error) {
+      return errorResponse(errorCode(error), error.message, false);
+    }
     if (typeof dispatchDesktop !== "function") {
       return errorResponse("NATIVE_OPERATION_UNAVAILABLE", "This companion does not support Desktop operations; reload the native relay");
     }
@@ -112,16 +141,16 @@ async function handleDesktopRequest(payload, { dispatchDesktop, resolveExecutor,
       executorThreadId,
       operation: payload.operation,
       arguments: payload.arguments,
-    });
+    }, { accountContext });
     return {
       ok: true,
-      v: RELAY_PROTOCOL_VERSION,
+      v: boundRequest(payload) ? ACCOUNT_RELAY_PROTOCOL_VERSION : RELAY_PROTOCOL_VERSION,
       operation: payload.operation,
       executorThreadId,
       result: decodeNativeToolResult(nativeResult),
     };
   } catch (err) {
-    return errorResponse(errorCode(err), err?.message ?? String(err));
+    return errorResponse(errorCode(err), err?.message ?? String(err), err?.sent === false && err?.reachedCompanion !== true ? false : undefined);
   }
 }
 
@@ -137,6 +166,8 @@ export class RelaySocketServer {
     dispatch,
     dispatchDesktop,
     resolveExecutor = resolveRelayThreadId,
+    assertAccount = assertAccountIdentity,
+    requireAccountContext = false,
     restrictSocket = (target) => {
       if (!IS_WINDOWS) fs.chmodSync(target, 0o600);
     },
@@ -146,11 +177,16 @@ export class RelaySocketServer {
     this.dispatch = dispatch;
     this.dispatchDesktop = dispatchDesktop;
     this.resolveExecutor = resolveExecutor;
+    this.assertAccount = assertAccount;
+    this.requireAccountContext = requireAccountContext;
     this.restrictSocket = restrictSocket;
     this.log = logFn;
     this.server = null;
     this.started = false;
     this.connections = new Set();
+    this.handlers = new Set();
+    this.accepting = true;
+    this.closed = Promise.resolve();
     this.processHandlers = new Map();
   }
 
@@ -248,6 +284,11 @@ export class RelaySocketServer {
   }
 
   #handleConnection(socket) {
+    if (!this.accepting) {
+      socket.on("error", () => {});
+      socket.end(`${JSON.stringify(errorResponse("RELAY_RELOADING", "The native relay is reloading; no message was sent", false))}\n`);
+      return;
+    }
     let buffer = Buffer.alloc(0);
     let handled = false;
     this.connections.add(socket);
@@ -265,7 +306,12 @@ export class RelaySocketServer {
       const index = buffer.indexOf(10);
       if (index < 0) return;
       handled = true;
-      void this.#handleLine(socket, buffer.subarray(0, index).toString("utf8"));
+      const handler = this.#handleLine(socket, buffer.subarray(0, index).toString("utf8"));
+      this.handlers.add(handler);
+      void handler.catch((error) => {
+        this.log(`relay request failed: ${error.message}`);
+        this.#reply(socket, errorResponse("NATIVE_DISPATCH_FAILED", "The native relay request failed before delivery was confirmed"));
+      }).finally(() => this.handlers.delete(handler));
       buffer = Buffer.alloc(0);
     });
   }
@@ -278,10 +324,15 @@ export class RelaySocketServer {
       this.#reply(socket, errorResponse("RELAY_BAD_REQUEST", `malformed JSON: ${err.message}`));
       return;
     }
+    if (this.requireAccountContext && !boundRequest(payload)) {
+      this.#reply(socket, errorResponse("RELAY_BAD_REQUEST", "The account relay requires protocol 2 and the original account context", false));
+      return;
+    }
     const response = await handleRelayRequest(payload, {
       dispatch: this.dispatch,
       dispatchDesktop: this.dispatchDesktop,
       resolveExecutor: this.resolveExecutor,
+      assertAccount: this.assertAccount,
     });
     if (!response.ok) this.log(`relay refused ${payload?.targetThreadId ?? "?"}: ${response.error.message}`);
     else this.log(response.operation ? `completed Desktop operation ${response.operation}` : `relayed a message into thread ${response.targetThreadId}`);
@@ -298,9 +349,12 @@ export class RelaySocketServer {
     this.processHandlers.clear();
     for (const socket of this.connections) socket.destroy();
     this.connections.clear();
-    try {
-      this.server?.close();
-    } catch {}
+    const server = this.server;
+    this.closed = new Promise((resolve) => {
+      if (!server) return resolve();
+      try { server.close(() => resolve()); }
+      catch { resolve(); }
+    });
     try {
       if (this.started && !IS_WINDOWS) fs.rmSync(this.socketPath, { force: true });
     } catch {}
@@ -314,10 +368,14 @@ export function startRelayWhenAvailable({ nativeTools, relay, log: logFn = () =>
   let delayMs = retryDelayMs;
   let resolveReady;
   const ready = new Promise((resolve) => { resolveReady = resolve; });
+  let pendingAttempt = null;
+  let nativeConnected = false;
   const attempt = async () => {
     if (stopped) return;
+    nativeConnected = false;
     try {
       await nativeTools.connect();
+      nativeConnected = true;
       if (stopped) {
         nativeTools.close();
         return;
@@ -331,8 +389,8 @@ export function startRelayWhenAvailable({ nativeTools, relay, log: logFn = () =>
       resolveReady(true);
     } catch (err) {
       if (stopped) return;
-      nativeTools.close();
-      if (!nativeTools.socketPath) {
+      if (!nativeConnected) nativeTools.close();
+      if (!nativeTools.socketPath && !nativeTools.hasDiscoveredSocket) {
         logFn(`native relay unavailable (${err.message})`);
         resolveReady(false);
         return;
@@ -340,22 +398,90 @@ export function startRelayWhenAvailable({ nativeTools, relay, log: logFn = () =>
       logFn(`native relay unavailable (${err.message}); retrying in ${delayMs}ms`);
       timer = globalThis.setTimeout(() => {
         timer = null;
-        void attempt();
+        runAttempt();
       }, delayMs);
       timer.unref();
       delayMs = Math.min(delayMs * 2, maxRetryDelayMs);
     }
   };
-  void attempt();
+  const runAttempt = () => {
+    const running = attempt();
+    pendingAttempt = running;
+    void running.finally(() => { if (pendingAttempt === running) pendingAttempt = null; });
+    return running;
+  };
+  const firstAttempt = runAttempt();
   return {
     ready,
+    firstAttempt,
+    get connected() { return nativeConnected; },
+    get busy() { return pendingAttempt !== null; },
     stop() {
-      if (stopped) return;
+      if (stopped) return pendingAttempt ?? Promise.resolve();
       stopped = true;
       globalThis.clearTimeout(timer);
       nativeTools.close();
       relay.stop();
       resolveReady(false);
+      return (pendingAttempt ?? Promise.resolve()).then(() => relay.closed);
+    },
+  };
+}
+
+export function createNativeRelayLifecycle({ nativeTools, relays, log: logFn = () => {} }) {
+  const servers = [...new Set(relays)];
+  let startups = [];
+  let ownedSockets = [];
+  const inspect = () => {
+    if (servers.some((relay) => relay.handlers.size)) return "Native relay requests are still active";
+    if (servers.some((relay) => relay.connections.size)) return "Native relay clients are still connected";
+    if (nativeTools.pending.size) return "Native Desktop dispatches are still pending";
+    if (nativeTools.connecting || startups.some((startup) => startup.busy)) return "Native relay startup is still pending";
+    return null;
+  };
+  const stop = async () => {
+    for (const relay of servers) relay.accepting = false;
+    const active = startups;
+    startups = [];
+    await Promise.all(active.map((startup) => startup.stop()));
+    for (const relay of servers) relay.stop();
+    await Promise.all(servers.map((relay) => relay.closed));
+    nativeTools.close();
+  };
+  const activate = async () => {
+    if (startups.length) {
+      for (const relay of servers) relay.accepting = true;
+      return;
+    }
+    for (const relay of servers) relay.accepting = true;
+    startups = servers.map((relay) => startRelayWhenAvailable({ nativeTools, relay, log: logFn }));
+    await Promise.all(startups.map((startup) => startup.firstAttempt));
+    const restoredListeners = await Promise.all(servers.map(async (relay, index) =>
+      !ownedSockets.includes(relay.socketPath) || startups[index].connected && await relay.isListening()));
+    if (restoredListeners.some((available) => !available)) {
+      await stop();
+      throw new Error("The replacement native relay could not reclaim its listening sockets");
+    }
+  };
+  return {
+    inspect,
+    activate,
+    stop,
+    async quiesce() {
+      for (const relay of servers) relay.accepting = false;
+      const reason = inspect();
+      if (reason) throw new Error(reason);
+      ownedSockets = servers.filter((relay) => relay.started).map((relay) => relay.socketPath);
+      await stop();
+    },
+    exportState: () => ({ ownedSockets }),
+    restore(payload) {
+      if (Object.keys(payload).some((key) => key !== "ownedSockets") || !Array.isArray(payload.ownedSockets)
+          || payload.ownedSockets.length > servers.length || new Set(payload.ownedSockets).size !== payload.ownedSockets.length
+          || payload.ownedSockets.some((socket) => typeof socket !== "string" || !servers.some((relay) => relay.socketPath === socket))) {
+        throw new Error("Native relay listener state does not match this worker");
+      }
+      ownedSockets = [...payload.ownedSockets];
     },
   };
 }
@@ -379,19 +505,29 @@ if (invokedDirectly) {
   );
 
   const nativeTools = new NativeToolsClient();
-  const dispatch = (args) => nativeTools.dispatch(args);
+  const dispatch = (args, options) => nativeTools.dispatch(args, options);
 
   const relay = new RelaySocketServer({
     socketPath: relaySocketPath(),
     dispatch,
-    dispatchDesktop: (args) => nativeTools.dispatchDesktop(args),
+    dispatchDesktop: (args, options) => nativeTools.dispatchDesktop(args, options),
     log,
   });
   const desktopRelay = desktopTaskSocketPath() === relay.socketPath ? relay : new RelaySocketServer({
     socketPath: desktopTaskSocketPath(),
-    dispatchDesktop: (args) => nativeTools.dispatchDesktop(args),
+    dispatchDesktop: (args, options) => nativeTools.dispatchDesktop(args, options),
     log,
   });
+  const accountRelay = new RelaySocketServer({
+    socketPath: accountRelaySocketPath(),
+    requireAccountContext: true,
+    dispatch,
+    dispatchDesktop: (args, options) => nativeTools.dispatchDesktop(args, options),
+    log,
+  });
+  const runtime = createRuntimeState();
+  const lifecycle = createNativeRelayLifecycle({ nativeTools, relays: [relay, desktopRelay, accountRelay], log });
+  const reload = createReloadControl({ entry: "native-relay-companion.mjs", ...lifecycle });
 
   mcp.registerTool(
     "native_relay_status",
@@ -406,7 +542,7 @@ if (invokedDirectly) {
         openWorldHint: false,
       },
     },
-    async () => {
+    async () => reload.run(async () => {
       const listening = await relay.isListening();
       let executor = "(unconfigured)";
       try {
@@ -416,14 +552,17 @@ if (invokedDirectly) {
         executor = err.message;
       }
       return {
+        structuredContent: { runtime: runtime.status() },
         content: [
           {
             type: "text",
             text: [
               `platform:       ${PLATFORM_LABEL} (${process.platform}/${process.arch})`,
               `companion:      codex-native-relay ${VERSION}`,
+              `runtime state:  ${runtime.status().current ? "current" : "stale"} (${reload.inspect().phase}, PID ${process.pid})`,
               `relay socket:   ${relay.started ? relay.socketPath : `${relay.socketPath} (${listening ? "shared companion listening" : "not listening"})`}`,
               `desktop tasks:  ${desktopRelay.socketPath} (${await desktopRelay.isListening() ? "listening" : "not listening"})`,
+              `account relay:  ${accountRelay.socketPath} (protocol ${ACCOUNT_RELAY_PROTOCOL_VERSION}, ${await accountRelay.isListening() ? "listening" : "not listening"})`,
               `executor:       ${executor}`,
               `dispatch:       ${process.env.CODEX_NATIVE_RELAY_METHOD ?? NATIVE_DISPATCH_METHOD}`,
               `native pipe:    ${nativeTools.socketPath ?? "unavailable (requires Codex Desktop)"}`,
@@ -431,12 +570,12 @@ if (invokedDirectly) {
           },
         ],
       };
-    },
+    }),
   );
 
-  const startup = startRelayWhenAvailable({ nativeTools, relay, log });
-  const desktopStartup = desktopRelay === relay ? startup : startRelayWhenAvailable({ nativeTools, relay: desktopRelay, log });
-  mcp.server.onclose = () => { startup.stop(); desktopStartup.stop(); };
+  if (!reload.staged) void lifecycle.activate().catch((error) => log(`native relay startup failed: ${error.message}`));
+  mcp.server.onclose = () => { void lifecycle.stop(); };
   await mcp.connect(new StdioServerTransport());
+  reload.listen();
   log(`ready on ${PLATFORM_LABEL} (${relay.started ? relay.socketPath : "socket down"})`);
 }

package/src/native-relay-launcher.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runSupervisor } from "./mcp-supervisor.mjs";
+await runSupervisor("native-relay-companion.mjs");