@minhspark/codex-mcp-bridge 1.26.8 → 1.26.10

package/src/antigravity-desktop.mjs

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import crypto from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -8,6 +9,207 @@ import { promisify } from "node:util";
 const execute = promisify(execFile);
 const SURFACES = { desktop: "antigravity", cli: "antigravity-cli" };
 const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
+const TRANSCRIPT_ROW_LIMIT = 4096;
+const TRANSCRIPT_BYTE_LIMIT = 32 * 1024 * 1024;
+const utf8 = new TextDecoder("utf-8", { fatal: true });
+const RESTART_NOTICE = "[Notice] All your subagents and background tasks have been stopped due to server restart. If you want a subagent to continue working, it needs to be revived by sending it a new message. If resuming work, please check on status and restart as needed.";
+
+function transcriptFailure(code = "ANTIGRAVITY_TRANSCRIPT_UNSUPPORTED") {
+  return Object.assign(new Error("Native Antigravity reply observation is unavailable; retain the original receipt and do not resend."), { code });
+}
+
+function protobufFields(value) {
+  if (!(value instanceof Uint8Array) || value.length > 2 * 1024 * 1024) throw transcriptFailure();
+  const buffer = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+  const fields = [];
+  let offset = 0;
+  const integer = () => {
+    let result = 0n;
+    for (let shift = 0n; shift < 70n; shift += 7n) {
+      if (offset >= buffer.length) throw transcriptFailure();
+      const byte = buffer[offset++];
+      result |= BigInt(byte & 127) << shift;
+      if (!(byte & 128)) {
+        if (result > BigInt(Number.MAX_SAFE_INTEGER)) throw transcriptFailure();
+        return Number(result);
+      }
+    }
+    throw transcriptFailure();
+  };
+  while (offset < buffer.length) {
+    if (fields.length >= 4096) throw transcriptFailure();
+    const tag = integer();
+    const field = Math.floor(tag / 8);
+    const wire = tag % 8;
+    if (!field || field > 536870911) throw transcriptFailure();
+    if (wire === 0) fields.push({ field, wire, value: integer() });
+    else {
+      const length = wire === 2 ? integer() : wire === 1 ? 8 : wire === 5 ? 4 : -1;
+      if (length < 0 || length > buffer.length - offset) throw transcriptFailure();
+      fields.push({ field, wire, value: buffer.subarray(offset, offset + length) });
+      offset += length;
+    }
+  }
+  return fields;
+}
+
+function protobufField(fields, number, wire) {
+  const matches = fields.filter((field) => field.field === number);
+  if (matches.length > 1 || matches.length && matches[0].wire !== wire) throw transcriptFailure();
+  return matches[0]?.value;
+}
+
+function protobufText(fields, number) {
+  const value = protobufField(fields, number, 2);
+  return value === undefined ? "" : utf8.decode(value);
+}
+
+function protobufTime(fields, number) {
+  const value = protobufField(fields, number, 2);
+  if (!value) return null;
+  const timestamp = protobufFields(value);
+  const seconds = protobufField(timestamp, 1, 0) ?? 0;
+  const nanos = protobufField(timestamp, 2, 0) ?? 0;
+  if (nanos >= 1e9 || seconds > 253402300799) throw transcriptFailure();
+  return seconds * 1000 + nanos / 1e6;
+}
+
+function decodeNativeStep(row) {
+  if (!Number.isSafeInteger(row.idx) || row.idx < 0 || row.step_format !== 0) throw transcriptFailure();
+  const fields = protobufFields(row.step_payload);
+  if (protobufField(fields, 1, 0) !== row.step_type || protobufField(fields, 4, 0) !== row.status) throw transcriptFailure();
+  const rawMetadata = protobufField(fields, 5, 2);
+  if (!rawMetadata || !Buffer.from(row.metadata ?? []).equals(rawMetadata)) throw transcriptFailure();
+  const metadata = protobufFields(rawMetadata);
+  const step = { index: row.idx, type: row.step_type, status: row.status, executionId: protobufText(metadata, 12), createdAt: protobufTime(metadata, 1), completedAt: protobufTime(metadata, 8) };
+  if (step.type === 101) {
+    const system = protobufFields(protobufField(fields, 114, 2));
+    const rawAgent = protobufField(system, 4, 2);
+    if (rawAgent) {
+      const agent = protobufFields(rawAgent);
+      step.message = { id: protobufText(agent, 1), recipient: protobufText(agent, 2), sender: protobufText(agent, 3), content: protobufText(agent, 4), hidden: protobufField(agent, 11, 0) === 1 };
+    }
+  }
+  if (step.type === 15) {
+    const response = protobufFields(protobufField(fields, 20, 2));
+    step.response = protobufText(response, 8) || protobufText(response, 1);
+    step.hasTools = response.some((field) => field.field === 7);
+    step.stopReason = protobufField(response, 12, 0);
+    step.finishedAt = protobufTime(metadata, 7);
+  }
+  return step;
+}
+
+async function readNativeSteps({ home, conversationId, boundaryOnly = false, afterStepIndex = -1, findRoot }) {
+  if (!UUID.test(conversationId ?? "")) throw transcriptFailure();
+  let directory = fs.realpathSync.native(home);
+  for (const segment of [".gemini", "antigravity", "conversations"]) {
+    directory = path.join(directory, segment);
+    const stat = fs.lstatSync(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) throw transcriptFailure();
+  }
+  const filename = path.join(directory, `${conversationId}.db`);
+  const before = fs.lstatSync(filename, { bigint: true });
+  if (!before.isFile() || before.isSymbolicLink() || before.nlink !== 1n || before.size > 512n * 1024n * 1024n) throw transcriptFailure();
+  for (const suffix of ["-wal", "-shm"]) {
+    try {
+      const stat = fs.lstatSync(`${filename}${suffix}`);
+      if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) throw transcriptFailure();
+    } catch (error) { if (error.code !== "ENOENT") throw error; }
+  }
+  const { DatabaseSync } = await import("node:sqlite");
+  const db = new DatabaseSync(filename, { readOnly: true });
+  try {
+    db.exec("PRAGMA query_only=ON; BEGIN");
+    const trajectory = db.prepare("SELECT trajectory_id, cascade_id FROM trajectory_meta LIMIT 2").all();
+    if (trajectory.length !== 1 || trajectory[0].cascade_id !== conversationId || !UUID.test(trajectory[0].trajectory_id ?? "")) throw transcriptFailure();
+    const maximum = db.prepare("SELECT MAX(idx) AS lastStepIndex FROM steps").get().lastStepIndex ?? -1;
+    if (!Number.isSafeInteger(maximum) || maximum < -1) throw transcriptFailure();
+    const readSteps = (lowerBound, rootsOnly = false) => {
+      const selector = rootsOnly ? "step_type = 101" : "idx > ?";
+      const parameters = rootsOnly ? [] : [lowerBound];
+      const rows = db.prepare(`SELECT idx, step_type, status, step_format, length(metadata) AS metadata_bytes, length(step_payload) AS payload_bytes FROM steps WHERE ${selector} ORDER BY idx LIMIT ?`).all(...parameters, TRANSCRIPT_ROW_LIMIT + 1);
+      if (rows.length > TRANSCRIPT_ROW_LIMIT || rows.some((row) => row.metadata_bytes > 2 * 1024 * 1024 || row.payload_bytes > 2 * 1024 * 1024)
+          || rows.reduce((sum, row) => sum + row.metadata_bytes + row.payload_bytes, 0) > TRANSCRIPT_BYTE_LIMIT) throw transcriptFailure("ANTIGRAVITY_TRANSCRIPT_LIMIT");
+      return rows.length ? db.prepare(`SELECT idx, step_type, status, step_format, metadata, step_payload FROM steps WHERE idx >= ? AND idx <= ?${rootsOnly ? " AND step_type = 101" : ""} ORDER BY idx`).all(rows[0].idx, rows.at(-1).idx).map(decodeNativeStep) : [];
+    };
+    let steps = [];
+    let roots;
+    if (!boundaryOnly) {
+      if (findRoot) {
+        roots = readSteps(-1, true).filter(findRoot);
+        if (roots.length === 1) steps = readSteps(roots[0].index - 1);
+      } else steps = readSteps(afterStepIndex);
+    }
+    const after = fs.lstatSync(filename, { bigint: true });
+    if (!after.isFile() || after.isSymbolicLink() || after.nlink !== 1n || before.dev !== after.dev || before.ino !== after.ino || before.birthtimeNs !== after.birthtimeNs) throw transcriptFailure();
+    return { trajectoryId: trajectory[0].trajectory_id, lastStepIndex: maximum, steps, ...(roots ? { roots } : {}) };
+  } finally { db.close(); }
+}
+
+export async function captureAntigravityObservation({ home = os.homedir(), conversationId, prompt, projectId }) {
+  const promptSha256 = crypto.createHash("sha256").update(prompt).digest("hex");
+  try {
+    const snapshot = await readNativeSteps({ home, conversationId, boundaryOnly: true });
+    return { version: 1, status: "ready", trajectoryId: snapshot.trajectoryId, beforeStepIndex: snapshot.lastStepIndex, promptSha256, projectId };
+  } catch {
+    return { version: 1, status: "unavailable", code: "ANTIGRAVITY_TRANSCRIPT_UNAVAILABLE", promptSha256, projectId };
+  }
+}
+
+export async function observeAntigravityDelivery(record, { home = os.homedir(), list = listAntigravityConversations } = {}) {
+  if (record?.surface !== "desktop" || !["accepted", "unknown", "sent_unconfirmed"].includes(record.status)) return record;
+  const observation = (status, code) => ({ ...record, replyObservation: { status, code, source: "native-transcript", retrySafe: false } });
+  try {
+    if (!UUID.test(record.conversationId ?? "") || !/^[a-f0-9]{64}$/.test(record.digest ?? "") || !["codex", "claude"].includes(record.sender?.provider)
+        || typeof record.sender.id !== "string" || !record.sender.id) throw transcriptFailure();
+    const matches = (await list({ home, surface: "desktop", limit: 1000 })).filter((row) => row.conversationId === record.conversationId);
+    if (matches.length !== 1 || matches[0].surface !== "desktop" || canonicalCwd(matches[0].cwd) !== canonicalCwd(record.cwd)) throw transcriptFailure("ANTIGRAVITY_REPLY_SCOPE_CHANGED");
+    const boundary = record.nativeObservation;
+    if (boundary && (boundary.version !== 1 || !["ready", "unavailable"].includes(boundary.status) || !/^[a-f0-9]{64}$/.test(boundary.promptSha256 ?? "") || boundary.projectId !== matches[0].projectId)) throw transcriptFailure();
+    if (boundary?.status === "ready" && (!Number.isSafeInteger(boundary.beforeStepIndex) || boundary.beforeStepIndex < -1 || !UUID.test(boundary.trajectoryId ?? ""))) throw transcriptFailure();
+    const createdAt = Date.parse(record.createdAt);
+    const finishedAt = Date.parse(record.finishedAt);
+    if (!Number.isFinite(createdAt) || boundary?.status !== "ready" && !Number.isFinite(finishedAt)) throw transcriptFailure();
+    const matchesRoot = (step) => {
+      if (step.type !== 101 || !step.message || step.status !== 3 || !UUID.test(step.message.id) || step.message.recipient !== record.conversationId
+          || step.createdAt === null || step.createdAt < createdAt - (boundary?.status === "ready" ? 2000 : 0) || !step.executionId) return false;
+      if (boundary?.status !== "ready" && step.createdAt > Math.min(createdAt + 120000, finishedAt + 30000)) return false;
+      const prompt = step.message.content;
+      if (boundary?.promptSha256 && crypto.createHash("sha256").update(prompt).digest("hex") !== boundary.promptSha256) return false;
+      const digest = crypto.createHash("sha256").update(JSON.stringify({ surface: "desktop", conversationId: record.conversationId, cwd: record.cwd, sender: record.sender, prompt })).digest("hex");
+      return digest === record.digest;
+    };
+    const snapshot = await readNativeSteps({ home, conversationId: record.conversationId, ...(boundary?.status === "ready" ? { afterStepIndex: boundary.beforeStepIndex } : { findRoot: matchesRoot }) });
+    if (boundary?.status === "ready" && (boundary.trajectoryId !== snapshot.trajectoryId || snapshot.lastStepIndex < boundary.beforeStepIndex)) throw transcriptFailure("ANTIGRAVITY_TRANSCRIPT_REPLACED");
+    const roots = snapshot.roots ?? snapshot.steps.filter(matchesRoot);
+    if (!roots.length) return observation("pending", "ANTIGRAVITY_MESSAGE_NOT_OBSERVED");
+    if (roots.length !== 1) return observation("ambiguous", "ANTIGRAVITY_REPLY_AMBIGUOUS");
+    const root = roots[0];
+    let reply;
+    for (const step of snapshot.steps.filter((step) => step.index > root.index)) {
+      if (step.type === 14 || step.executionId !== root.executionId) break;
+      if (step.type === 101) {
+        if (step.message?.hidden && step.message.sender === "system" && step.message.content === RESTART_NOTICE) continue;
+        if (!reply) return observation("ambiguous", "ANTIGRAVITY_REPLY_INTERLEAVED");
+        break;
+      }
+      reply = step.type === 15 && step.status === 3 && step.response && !step.hasTools && step.stopReason === 2
+        && step.finishedAt !== null && step.completedAt !== null && step.finishedAt >= root.createdAt && step.completedAt >= step.finishedAt ? step : null;
+    }
+    if (!reply) return observation("pending", "ANTIGRAVITY_REPLY_NOT_OBSERVED");
+    const current = (await list({ home, surface: "desktop", limit: 1000 })).filter((row) => row.conversationId === record.conversationId);
+    if (current.length !== 1 || current[0].surface !== "desktop" || current[0].projectId !== matches[0].projectId || canonicalCwd(current[0].cwd) !== canonicalCwd(record.cwd)) throw transcriptFailure("ANTIGRAVITY_REPLY_SCOPE_CHANGED");
+    if (current[0].status !== "CASCADE_RUN_STATUS_IDLE") return observation("pending", "ANTIGRAVITY_REPLY_STILL_RUNNING");
+    if (Buffer.byteLength(reply.response) > 256 * 1024) throw transcriptFailure("ANTIGRAVITY_REPLY_LIMIT");
+    const evidence = { source: "native-transcript", nativeMessageId: root.message.id, rootStepIndex: root.index, replyStepIndex: reply.index,
+      executionId: root.executionId, trajectoryId: snapshot.trajectoryId, replySha256: crypto.createHash("sha256").update(reply.response).digest("hex") };
+    return { ...record, status: "reply_received", replyObservation: { status: "reply_received", retrySafe: false, ...evidence },
+      result: { ...record.result, status: "reply_received", completed: true, response: reply.response, reply: reply.response, ...evidence } };
+  } catch (error) {
+    return observation("unavailable", /^ANTIGRAVITY_(?:TRANSCRIPT|REPLY)_[A-Z_]+$/.test(error.code ?? "") ? error.code : "ANTIGRAVITY_TRANSCRIPT_UNAVAILABLE");
+  }
+}
 
 function failure(code, message) {
   return Object.assign(new Error(message), { code, deliveryState: "not_sent" });
@@ -105,7 +307,7 @@ export async function runAgentApi(options) {
   }
 }
 
-async function executeAgentApi({ command, conversationId, prompt, expectedCwd, home = os.homedir(), env = process.env, executable = env.ANTIGRAVITY_AGENTAPI_EXE, run = execute, list = listAntigravityConversations }) {
+async function executeAgentApi({ command, conversationId, prompt, expectedCwd, home = os.homedir(), env = process.env, executable = env.ANTIGRAVITY_AGENTAPI_EXE, run = execute, list = listAntigravityConversations, beforeDispatch }) {
   if (!UUID.test(conversationId)) throw failure("ANTIGRAVITY_ID_INVALID", "An exact conversation UUID is required");
   if (!["metadata", "send"].includes(command)) throw new Error("Unsupported Antigravity agentapi command");
   if (!env.ANTIGRAVITY_LS_ADDRESS || !env.ANTIGRAVITY_CSRF_TOKEN) throw failure("ANTIGRAVITY_SIDECAR_REQUIRED", "Antigravity must launch the bridge sidecar before native requests are available");
@@ -141,6 +343,8 @@ async function executeAgentApi({ command, conversationId, prompt, expectedCwd, h
   if (metadata.cwd !== cwd || metadata.projectId !== before.projectId) throw failure("ANTIGRAVITY_METADATA_MISMATCH", "Native metadata does not match the selected conversation workspace and project");
   const current = await select();
   if (current.projectId !== before.projectId) throw failure("ANTIGRAVITY_METADATA_MISMATCH", "Conversation project changed during delivery preflight");
+  const nativeObservation = await captureAntigravityObservation({ home, conversationId, prompt, projectId: current.projectId });
+  await beforeDispatch?.(nativeObservation);
   await invoke(["send-message", conversationId, prompt]);
-  return { conversationId, status: "accepted", completed: false, surface: "desktop" };
+  return { conversationId, status: "accepted", completed: false, surface: "desktop", nativeObservation };
 }

package/src/antigravity-outbound-targets.mjs

@@ -236,7 +236,7 @@ export function createAntigravityOutboundTargets(options = {}) {
       await context.check();
       return { target, sessionId: recipient.sessionId, taskId, cwd: context.cwd, msgId, status: outcome.delivery?.status ?? "sent_unconfirmed", completed: false, accountContext: context.accountContext };
     } catch (error) {
-      if (error.msgId) receipts.set(error.msgId, { sender: context.identity, accountContext: context.accountContext, cwd: context.cwd });
+      if (error.msgId && error.code !== "PEER_REPLY_PENDING") receipts.set(error.msgId, { sender: context.identity, accountContext: context.accountContext, cwd: context.cwd });
       if (msgId) error.msgId = msgId;
       if (msgId || error.deliveryUncertain) error.deliveryState = "unknown";
       else if (!error.deliveryState) error.deliveryState = "not_sent";

package/src/antigravity-sidecar.mjs

@@ -3,7 +3,7 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { antigravityBridgeDirectory, serveAntigravityDesktop } from "./antigravity-ipc.mjs";
 import { AntigravityDeliveries } from "./antigravity-deliveries.mjs";
-import { listAntigravityConversations, runAgentApi, sanitizeAntigravityMetadata } from "./antigravity-desktop.mjs";
+import { listAntigravityConversations, observeAntigravityDelivery, runAgentApi, sanitizeAntigravityMetadata } from "./antigravity-desktop.mjs";
 import { exitForVersionRequest } from "./cli-version.mjs";
 import { readProcessAncestry } from "./claude-sender-context.mjs";
 
@@ -34,7 +34,7 @@ export async function createAntigravityParentGuard({ parentPid = process.ppid, i
   };
 }
 
-export async function startAntigravitySidecar({ directory = antigravityBridgeDirectory(), env = process.env, createParentGuard = createAntigravityParentGuard, serve = serveAntigravityDesktop, parentCheckIntervalMs = 5000, onParentLost = () => {} } = {}) {
+export async function startAntigravitySidecar({ directory = antigravityBridgeDirectory(), env = process.env, createParentGuard = createAntigravityParentGuard, serve = serveAntigravityDesktop, parentCheckIntervalMs = 5000, onParentLost = () => {}, runNative = runAgentApi, observeDelivery = observeAntigravityDelivery } = {}) {
   if (!env.ANTIGRAVITY_AGENTAPI_EXE || !env.ANTIGRAVITY_LS_ADDRESS) throw new Error("Antigravity must launch this sidecar. Do not run it as a replacement app server.");
   const assertParent = await createParentGuard();
   const deliveries = new AntigravityDeliveries(path.join(directory, "desktop-deliveries"));
@@ -68,7 +68,7 @@ export async function startAntigravitySidecar({ directory = antigravityBridgeDir
       const native = sanitizeAntigravityMetadata(await runAgentApi({ command: "metadata", conversationId: request.conversationId, env }), request.conversationId);
       return { ...record, ...native };
     }
-    if (request.operation === "receipt") return deliveries.read(request.requestId);
+    if (request.operation === "receipt") return deliveries.refresh(request.requestId, observeDelivery);
     if (request.operation !== "send" || typeof request.prompt !== "string" || !request.prompt.trim() || request.prompt.length > 30000 || request.prompt.includes("\0")
       || typeof request.cwd !== "string" || !path.isAbsolute(request.cwd) || !request.sender || !["codex", "claude"].includes(request.sender.provider)
       || typeof request.sender.id !== "string" || !request.sender.id) throw new Error("Invalid Antigravity delivery request");
@@ -76,7 +76,8 @@ export async function startAntigravitySidecar({ directory = antigravityBridgeDir
       await checkParent();
       if (sending.has(request.conversationId)) throw Object.assign(new Error("Another delivery is pending for this conversation"), { deliveryState: "not_sent" });
       sending.add(request.conversationId);
-      try { return await runAgentApi({ command: "send", conversationId: request.conversationId, expectedCwd: request.cwd, prompt: request.prompt, env }); }
+      try { return await runNative({ command: "send", conversationId: request.conversationId, expectedCwd: request.cwd, prompt: request.prompt, env,
+        beforeDispatch: (observation) => deliveries.captureObservation(request.requestId, observation) }); }
       finally { sending.delete(request.conversationId); }
     });
   }, { directory });

package/src/background-codex-worker.mjs

@@ -61,22 +61,29 @@ function workerEnv(env, relayEnv = {}) {
 }
 
 function binary(executable, env, platform = process.platform) {
-  const selected = executable ?? resolveCodexBin(undefined, { env, platform });
+  const selected = executable ?? env.CODEX_BIN ?? env.CODEX_CLI_PATH ?? resolveCodexBin(undefined, { env, platform });
   try {
     if (typeof selected !== "string" || !path.isAbsolute(selected) || /[\u0000-\u001f\u007f]/.test(selected)) throw new Error();
     const resolved = fs.realpathSync.native(selected);
     if (!fs.statSync(resolved).isFile() || platform === "win32" && !/\.(?:exe|com)$/i.test(resolved)) throw new Error();
     fs.accessSync(resolved, platform === "win32" ? fs.constants.R_OK : fs.constants.X_OK);
     return resolved;
-  } catch { throw failure("CLI_UNAVAILABLE", "inspect"); }
+  } catch (cause) { throw Object.assign(failure("CLI_UNAVAILABLE", "inspect"), { cause }); }
 }
 
-export async function inspectCodexWorker({ env = process.env, executable, platform = process.platform, run = execFileAsync } = {}) {
+function missingExecutable(error) {
+  return ["ENOENT", "ENOTDIR"].includes(error?.code) || ["ENOENT", "ENOTDIR"].includes(error?.cause?.code);
+}
+
+async function inspectCodexWorkerAttempt({ env, executable, platform, run, retryMissing = false }) {
   const result = { agent: "codex", available: false, authenticated: null, ready: false };
   if (!object(env) || typeof run !== "function") return { ...result, code: "INVALID_INPUT", reason: ERRORS.INVALID_INPUT };
   let selected;
   try { selected = binary(executable, env, platform); }
-  catch (error) { return { ...result, code: error.code, reason: error.message }; }
+  catch (error) {
+    if (retryMissing && missingExecutable(error)) throw error;
+    return { ...result, code: error.code, reason: error.message };
+  }
   const options = { env: workerEnv(env), windowsHide: true, shell: false, timeout: 10000, maxBuffer: MAX_CAPTURE, encoding: "utf8" };
   try {
     const version = await run(selected, ["--version"], options);
@@ -88,6 +95,8 @@ export async function inspectCodexWorker({ env = process.env, executable, platfo
       return { ...result, code: "CLI_UNSUPPORTED", reason: ERRORS.CLI_UNSUPPORTED };
     }
   } catch (error) {
+    if (retryMissing && missingExecutable(error)) throw error;
+    if (missingExecutable(error)) return { ...result, available: false, code: "CLI_UNAVAILABLE", reason: ERRORS.CLI_UNAVAILABLE };
     const code = diagnosticCode(error.stderr, result.available ? "CLI_UNSUPPORTED" : "CLI_UNAVAILABLE");
     return { ...result, code, reason: ERRORS[code] };
   }
@@ -100,11 +109,24 @@ export async function inspectCodexWorker({ env = process.env, executable, platfo
     const code = diagnosticCode(text, "AUTH_UNVERIFIED");
     return { ...result, authenticated: code === "AUTH_REQUIRED" ? false : null, code, reason: ERRORS[code] };
   } catch (error) {
+    if (retryMissing && missingExecutable(error)) throw error;
+    if (missingExecutable(error)) return { ...result, available: false, code: "CLI_UNAVAILABLE", reason: ERRORS.CLI_UNAVAILABLE };
     const code = diagnosticCode(`${error.stdout ?? ""}\n${error.stderr ?? ""}`, "AUTH_UNVERIFIED");
     return { ...result, authenticated: code === "AUTH_REQUIRED" ? false : null, code, reason: ERRORS[code] };
   }
 }
 
+export async function inspectCodexWorker({ env = process.env, executable, platform = process.platform, run = execFileAsync } = {}) {
+  const settings = { env, executable, platform, run };
+  const pinned = executable != null || env?.CODEX_BIN != null || env?.CODEX_CLI_PATH != null;
+  try { return await inspectCodexWorkerAttempt({ ...settings, retryMissing: !pinned }); }
+  catch (error) {
+    if (!missingExecutable(error)) throw error;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    return inspectCodexWorkerAttempt(settings);
+  }
+}
+
 function capture(executable, args, { cwd, env, spawn, signal, timeoutMs }) {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) return reject(failure("ABORTED", "configure"));

package/src/claude-bridge.mjs

@@ -31,7 +31,7 @@ import { BACKGROUND_WORKER_GUIDANCE, registerBackgroundTools } from "./backgroun
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.26.8";
+const VERSION = "1.26.10";
 void import("./telemetry.mjs").then(({ startUsageReporting }) => startUsageReporting({ version: VERSION })).catch(() => {});
 const FORWARD_MIN_INTERVAL_MS = 5000;
 const FORWARD_MAX_PER_SESSION = 50;

package/src/codex-mcp-registration.mjs

@@ -6,6 +6,27 @@ import { backupRegularConfigFile } from "./project-policy.mjs";
 
 const PRESERVED_FIELDS = ["enabled", "disabled_reason", "enabled_tools", "disabled_tools", "startup_timeout_sec", "tool_timeout_sec"];
 
+export const CODEX_MCP_TIMEOUT_MS = 120000;
+
+function missingServerError(error, name) {
+  const output = `${error?.stderr ?? ""}\n${error?.stdout ?? ""}\n${error?.message ?? ""}`;
+  return output.includes(`No MCP server named '${name}' found`);
+}
+
+export function readCodexMcpServer(run, name) {
+  let output;
+  try { output = run(["mcp", "get", name, "--json"]); }
+  catch (error) {
+    if (missingServerError(error, name)) return null;
+    throw error;
+  }
+  const entry = JSON.parse(output);
+  if (!entry || typeof entry !== "object" || Array.isArray(entry) || entry.name !== name) {
+    throw new Error(`Codex returned an invalid ${name} entry; existing configuration was not changed`);
+  }
+  return entry;
+}
+
 function sameEnvironment(left = {}, right = {}) {
   const keys = (value) => Object.keys(value ?? {}).sort();
   return JSON.stringify(keys(left)) === JSON.stringify(keys(right)) && keys(left).every((key) => left[key] === right[key]);

package/src/index.mjs

@@ -44,7 +44,7 @@ import { BACKGROUND_WORKER_GUIDANCE, registerBackgroundTools } from "./backgroun
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.26.8";
+const VERSION = "1.26.10";
 void import("./telemetry.mjs").then(({ startUsageReporting }) => startUsageReporting({ version: VERSION })).catch(() => {});
 const log = (msg) => process.stderr.write(`[codex-mcp-bridge] ${msg}\n`);
 

package/src/native-relay-companion.mjs

@@ -43,7 +43,7 @@ import { remoteCodexSocketPath, remoteNativeAdapter, remoteRequestResponse } fro
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.26.8";
+const VERSION = "1.26.10";
 const log = (msg) => process.stderr.write(`[native-relay] ${msg}\n`);
 
 function errorResponse(code, message, sent, details) {