@minhspark/codex-mcp-bridge 1.18.0 → 1.18.2

package/CHANGELOG.md

@@ -4,6 +4,20 @@ Follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and [SemVer](ht
 
 ## [Unreleased]
 
+## [1.18.2] - 2026-09-26
+
+### Fixed
+
+- Restore native relay compatibility with Codex Desktop 26.924 by including the required caller source in native tool requests, allowing pipe discovery and Desktop operations to recover automatically.
+
+## [1.18.1] - 2026-09-25
+
+### Fixed
+
+- Report npm installation completion with an unchanged version instead of claiming the package is already up to date after a same-version reinstall.
+- Discover Claude Desktop sessions when accumulated task configuration exceeds 32 MiB. Retain only bounded identity fields and SHA-256 fingerprints while preserving account isolation, duplicate detection, and concurrent-change checks.
+- Report Desktop task verification failures separately from missing peer endpoints in session discovery and bridge status.
+
 ## [1.18.0] - 2026-09-23
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minhspark/codex-mcp-bridge",
-  "version": "1.18.0",
+  "version": "1.18.2",
   "description": "Two-way MCP bridge between Claude and Codex: prompts into a live Codex thread, messages into a running Claude Code session.",
   "keywords": [
     "mcp",

package/scripts/install-native-relay.mjs

@@ -22,7 +22,7 @@ import { createReleaseSnapshot, snapshotRoot } from "../src/release-snapshot.mjs
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.18.0";
+const VERSION = "1.18.2";
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const entry = path.join(root, "src", "mcp-supervisor.mjs");
 const entryArgs = ["native-relay-companion.mjs"];

package/scripts/npm-footer.ps1

@@ -130,7 +130,7 @@ try {
     } elseif ($before.Status -eq 'missing') {
         Write-Host "Successfully installed: @minhspark/codex-mcp-bridge v$($after.Version)"
     } elseif ($before.Version -ceq $after.Version) {
-        Write-Host "Already up to date: @minhspark/codex-mcp-bridge v$($after.Version)"
+        Write-Host "Installation completed: @minhspark/codex-mcp-bridge v$($after.Version) (version unchanged)"
     } else {
         Write-Host "Successfully updated: @minhspark/codex-mcp-bridge v$($before.Version) -> v$($after.Version)"
     }

package/scripts/npm-footer.sh

@@ -70,7 +70,7 @@ npm() {
     if [ -z "$bridge_after" ] || [ "$bridge_before_verified" -ne 1 ] || [ "$bridge_after_root" != "$bridge_root" ]; then
       printf 'Warning: npm completed, but the installed @minhspark/codex-mcp-bridge version could not be verified.\n' >&2
     elif [ "$bridge_after_root" = "$bridge_root" ] && [ "$bridge_after" = "$bridge_before" ]; then
-      printf 'Already up to date: @minhspark/codex-mcp-bridge v%s\n' "$bridge_after"
+      printf 'Installation completed: @minhspark/codex-mcp-bridge v%s (version unchanged)\n' "$bridge_after"
     elif [ "$bridge_after_root" = "$bridge_root" ] && [ -n "$bridge_before" ]; then
       printf 'Successfully updated: @minhspark/codex-mcp-bridge v%s -> v%s\n' "$bridge_before" "$bridge_after"
     else

package/src/claude-bridge.mjs

@@ -26,7 +26,7 @@ import { AGENT_PROMPT_GUIDANCE, PROMPT_FIELD_HINT } from "./prompt-guidance.mjs"
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.18.0";
+const VERSION = "1.18.2";
 void import("./telemetry.mjs").then(({ startUsageReporting }) => startUsageReporting({ version: VERSION })).catch(() => {});
 const FORWARD_MIN_INTERVAL_MS = 5000;
 const FORWARD_MAX_PER_SESSION = 50;
@@ -164,6 +164,40 @@ function withDesktopContext(session, account = readClaudeAccountContext()) {
     ? { ...session, desktop: readClaudeDesktopContext(session, { account }), inbound: readClaudeInboundPolicy(session.cwd) } : session;
 }
 
+function inspectDiscovery(sessions, account, expectedCwd) {
+  const eligible = [];
+  const excluded = [];
+  let nonDesktopCount = 0;
+  let candidateCount = 0;
+  for (const session of sessions) {
+    if (rootPolicy.enabled && !rootPolicy.allows(session.cwd)) continue;
+    if (expectedCwd !== undefined) {
+      try { assertClaudeSessionCwd(session, expectedCwd); }
+      catch { continue; }
+    }
+    if (desktopOnly && session.entrypoint !== "claude-desktop") {
+      nonDesktopCount += 1;
+      continue;
+    }
+    candidateCount += 1;
+    const inspected = withDesktopContext(session, account);
+    if (!desktopOnly || inspected.desktop?.status === "matched") {
+      eligible.push(inspected);
+      continue;
+    }
+    const status = inspected.desktop?.status ?? "missing";
+    const reason = inspected.desktop?.reason ?? "The Desktop task identity could not be verified.";
+    const previous = excluded.find((entry) => entry.status === status && entry.reason === reason);
+    if (previous) previous.count += 1;
+    else excluded.push({ status, reason, count: 1 });
+  }
+  return { sessions: eligible, discovery: { candidateCount, matchedCount: eligible.length, nonDesktopCount, excluded } };
+}
+
+function discoveryDetails(discovery) {
+  return discovery.excluded.map((entry) => `Desktop task verification: ${entry.count} candidate(s) ${entry.status} - ${entry.reason}`);
+}
+
 function assertSessionRoot(session, label = "Claude session") {
   return rootPolicy.assert(session?.cwd, `${label} working directory`);
 }
@@ -340,17 +374,14 @@ registerTool(
       if (expectedCwd !== undefined) assertClaudeSessionCwd({ cwd: expectedCwd }, expectedCwd);
       const account = readClaudeAccountContext();
       if (desktopOnly && account.status !== "verified") return { ...textResult(`Claude account ${account.status}: ${account.reason} Sign in and retry discovery.`, true), structuredContent: { account: publicAccountState(account), sessions: [] } };
-      const sessions = listClaudeSessions({ includeDead: includeDead ?? false }).filter(
-        (s) => s.pid !== process.pid && (!desktopOnly || s.entrypoint === "claude-desktop"),
-      ).filter((session) => !rootPolicy.enabled || rootPolicy.allows(session.cwd)
-      ).filter((session) => {
-        if (expectedCwd === undefined) return true;
-        try { assertClaudeSessionCwd(session, expectedCwd); return true; }
-        catch { return false; }
-      }).map((session) => withDesktopContext(session, account)).filter((session) => !desktopOnly || session.desktop?.status === "matched");
-      if (!sessions.length) return textResult(desktopOnly ? missingDesktopSession : "No live Claude Code session found.");
-      return { ...textResult(`${sessions.length} Claude${desktopOnly ? " Desktop" : ""} session(s):\n\n${sessions.map(formatSessionRow).join("\n")}`),
-        structuredContent: { account: publicAccountState(account), sessions: sessions.map(({ socket, bridgeSessionId, ...session }) => session) } };
+      const { sessions, discovery } = inspectDiscovery(listClaudeSessions({ includeDead: includeDead ?? false }).filter((s) => s.pid !== process.pid), account, expectedCwd);
+      const summary = sessions.length
+        ? `${sessions.length} Claude${desktopOnly ? " Desktop" : ""} session(s):\n\n${sessions.map(formatSessionRow).join("\n")}`
+        : discovery.excluded.length
+          ? `Found ${discovery.candidateCount} registered Claude Desktop candidate(s) with messaging endpoints, but their Desktop task identities could not be verified. Delivery remains blocked.`
+          : desktopOnly ? missingDesktopSession : "No live Claude Code session found.";
+      return { ...textResult([summary, ...discoveryDetails(discovery)].join("\n")),
+        structuredContent: { account: publicAccountState(account), sessions: sessions.map(({ socket, bridgeSessionId, ...session }) => session), discovery } };
     } catch (err) {
       return failure(err);
     }
@@ -646,9 +677,7 @@ registerTool(
       await peer.start();
       const sessions = listClaudeSessions().filter((s) => s.pid !== process.pid);
       const accounts = readBridgeAccounts();
-      const eligible = sessions.filter((session) => !desktopOnly || session.entrypoint === "claude-desktop")
-        .filter((session) => !rootPolicy.enabled || rootPolicy.allows(session.cwd))
-        .filter((session) => !desktopOnly || withDesktopContext(session, accounts.claude).desktop?.status === "matched");
+      const { sessions: eligible, discovery } = inspectDiscovery(sessions, accounts.claude);
       const visibleInbox = peer.inbox.filter((record) => recordVisible(record, accounts));
       const visiblePending = [...peer.pendingMessages.keys()].filter((id) => readReceipt(id));
       const visibleForwarding = replyForwarder.status((record) => recordVisible(record, accounts));
@@ -666,7 +695,8 @@ registerTool(
         `Claude account: ${accounts.claude.status}${accounts.claude.fingerprint ? ` (${accounts.claude.fingerprint.slice(0, 12)})` : ` - ${accounts.claude.reason}`}`,
         `Codex account: ${accounts.codex.status}${accounts.codex.fingerprint ? ` (${accounts.codex.fingerprint.slice(0, 12)})` : ` - ${accounts.codex.reason}`}`,
         `live sessions: ${eligible.length}`,
-        ...(rootPolicy.enabled ? [] : [`excluded:      ${sessions.length - eligible.length} non-Desktop or inactive-account session(s)`]),
+        `excluded:      ${discovery.nonDesktopCount} non-Desktop session(s); ${discovery.candidateCount - eligible.length} Desktop candidate(s) failed task verification`,
+        ...discoveryDetails(discovery),
         `relay thread:  ${forwarding.threadId ?? "(none - use bind_codex_thread)"}`,
         `delivery:      ${delivery.describe()}`,
         `inbox:         ${visibleInbox.length} pending message(s)`,
@@ -676,7 +706,7 @@ registerTool(
       ];
       const state = runtime.status();
       lines.push(`runtime pid:   ${state.pid}`, `loaded source: ${state.revision}`, `disk source:   ${state.diskRevision ?? "unreadable"}`, `runtime state: ${state.current ? "current" : `STALE - ${state.reason}; reconnect this MCP server in the existing task`}`);
-      return { ...textResult(lines.join("\n"), !state.current), structuredContent: { runtime: state, accounts: { claude: publicAccountState(accounts.claude), codex: publicAccountState(accounts.codex) }, replyForwarding: visibleForwarding, ...(sender ? { sender } : {}) } };
+      return { ...textResult(lines.join("\n"), !state.current), structuredContent: { runtime: state, accounts: { claude: publicAccountState(accounts.claude), codex: publicAccountState(accounts.codex) }, discovery, replyForwarding: visibleForwarding, ...(sender ? { sender } : {}) } };
     } catch (err) {
       return failure(err);
     }

package/src/claude-desktop-context.mjs

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -7,7 +8,7 @@ const ACCOUNT_ID = new RegExp(`^${UUID}$`, "i");
 const TASK_FILE = new RegExp(`^(local_${UUID})\\.json$`, "i");
 const MAX_ENTRIES = 8192;
 const MAX_FILE_BYTES = 4 * 1024 * 1024;
-const MAX_TOTAL_BYTES = 32 * 1024 * 1024;
+const MAX_IDENTITY_BYTES = 32 * 1024 * 1024;
 const VERSION_FIELDS = ["size", "mtimeMs", "ctimeMs", "ino", "dev"];
 
 const sameVersion = (left, right) => VERSION_FIELDS.every((field) => left[field] === right[field]);
@@ -69,18 +70,16 @@ function readMetadata(file, budget) {
   try {
     const before = fs.fstatSync(descriptor);
     if (!before.isFile() || before.size > MAX_FILE_BYTES) throw new Error("file limit");
-    budget.bytes += before.size;
-    if (budget.bytes > MAX_TOTAL_BYTES) throw new Error("total limit");
     const bytes = Buffer.alloc(before.size);
     if (fs.readSync(descriptor, bytes, 0, bytes.length, 0) !== bytes.length) throw new Error("short read");
     const after = fs.fstatSync(descriptor);
     const current = fs.lstatSync(file);
     if (!sameVersion(before, after) || current.isSymbolicLink() || !sameVersion(current, after)) throw new Error("metadata changed");
     budget.versions.set(file, current);
-    budget.contents.set(file, bytes);
+    budget.digests.set(file, createHash("sha256").update(bytes).digest("hex"));
     const data = JSON.parse(bytes.toString("utf8"));
     if (!data || typeof data !== "object" || Array.isArray(data)) throw new Error("invalid metadata");
-    return {
+    const record = {
       taskId: data.sessionId,
       fileTaskId: TASK_FILE.exec(path.basename(file))[1],
       cliSessionId: data.cliSessionId,
@@ -90,18 +89,14 @@ function readMetadata(file, budget) {
       isArchived: data.isArchived,
       permissionMode: data.permissionMode,
     };
+    budget.bytes += Buffer.byteLength(JSON.stringify(record));
+    if (budget.bytes > MAX_IDENTITY_BYTES) throw new Error("identity limit");
+    return record;
   } finally {
     fs.closeSync(descriptor);
   }
 }
 
-/**
- * Stat fields cannot prove a record is unchanged: a same-size rewrite inside
- * one filesystem timestamp tick (about 16 ms on Windows) keeps size, times
- * and inode identical. The final consistency pass therefore compares the
- * bytes themselves; the records are small JSON files, so the extra read is
- * cheap and the check is deterministic on every platform.
- */
 function rereadMetadata(file) {
   const descriptor = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
   try {
@@ -109,7 +104,7 @@ function rereadMetadata(file) {
     if (!stat.isFile() || stat.size > MAX_FILE_BYTES) throw new Error("file limit");
     const bytes = Buffer.alloc(stat.size);
     if (fs.readSync(descriptor, bytes, 0, bytes.length, 0) !== bytes.length) throw new Error("short read");
-    return bytes;
+    return createHash("sha256").update(bytes).digest("hex");
   } finally {
     fs.closeSync(descriptor);
   }
@@ -138,8 +133,14 @@ export function readClaudeDesktopContext(session, { platform = process.platform,
     const directory = root ?? (account ? path.join(account.root, "claude-code-sessions") : sessionsRoot(platform, env));
     if (!fs.existsSync(directory)) return result("missing", "Claude Desktop task metadata is not available on this host.");
     records = readClaudeDesktopTasks({ platform, env, root, account });
-  } catch {
-    return result("mismatch", "Claude Desktop task metadata could not be read completely and consistently; no task identity is confirmed.");
+  } catch (error) {
+    const detail = {
+      "file limit": " A task metadata file exceeds the 4 MiB per-file limit.",
+      "identity limit": " Task identity fields exceed the 32 MiB retained-data limit.",
+      "scan limit": " The task directory exceeds the 8192-entry scan limit.",
+      "metadata changed": " Task metadata changed during inspection; retry discovery.",
+    }[error.message] ?? "";
+    return result("mismatch", `Claude Desktop task metadata could not be read completely and consistently; no task identity is confirmed.${detail}`);
   }
 
   const primary = records.filter((record) => record.cliSessionId === session.sessionId);
@@ -198,13 +199,13 @@ export function readClaudeDesktopTasks({ platform = process.platform, env = proc
   }
   const directory = root ?? (account ? path.join(account.root, "claude-code-sessions") : sessionsRoot(platform, env));
   const files = metadataFiles(directory, account?.accountId);
-  const budget = { bytes: 0, versions: new Map(), contents: new Map() };
+  const budget = { bytes: 0, versions: new Map(), digests: new Map() };
   const records = files.map((file) => readMetadata(file, budget));
   const currentFiles = metadataFiles(directory, account?.accountId);
   if (files.length !== currentFiles.length || files.some((file, index) => file !== currentFiles[index])) throw new Error("metadata changed");
   for (const file of files) {
     const current = fs.lstatSync(file);
-    if (!current.isFile() || !sameVersion(current, budget.versions.get(file)) || !rereadMetadata(file).equals(budget.contents.get(file))) throw new Error("metadata changed");
+    if (!current.isFile() || !sameVersion(current, budget.versions.get(file)) || rereadMetadata(file) !== budget.digests.get(file)) throw new Error("metadata changed");
   }
   return records;
 }

package/src/index.mjs

@@ -34,7 +34,7 @@ import { AGENT_PROMPT_GUIDANCE, PROMPT_FIELD_HINT } from "./prompt-guidance.mjs"
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.18.0";
+const VERSION = "1.18.2";
 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

@@ -34,7 +34,7 @@ import { createHardenedRootPolicy } from "./hardened-root-policy.mjs";
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.18.0";
+const VERSION = "1.18.2";
 const log = (msg) => process.stderr.write(`[native-relay] ${msg}\n`);
 
 function errorResponse(code, message, sent) {

package/src/native-relay.mjs

@@ -168,6 +168,7 @@ export function resolveRelayThreadId(env = process.env) {
 export function nativeDispatchParams({ executorThreadId, targetThreadId, message }) {
   return {
     arguments: { threadId: targetThreadId, prompt: message },
+    callerSource: "codex",
     callId: `codex-native-relay-${randomUUID()}`,
     namespace: "codex_app",
     threadId: executorThreadId,
@@ -246,6 +247,7 @@ export function nativeDesktopOperationParams({ executorThreadId, operation, argu
   validateDesktopOperation(operation, args);
   return {
     arguments: args,
+    callerSource: "codex",
     callId: `codex-native-relay-${randomUUID()}`,
     namespace: "codex_app",
     threadId: executorThreadId,