@minhspark/codex-mcp-bridge 1.22.3 → 1.22.5

package/src/peer-protocol.mjs

@@ -38,9 +38,11 @@ const projectsDir = () => path.join(homeDir(), ".claude", "projects");
  * 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", permissionMode }) {
+export function buildFrame({ text, fromSocket, fromName, priority = "next", permissionMode }) {
   const msgId = crypto.randomUUID();
   const from = `uds:${fromSocket.replace(/[^A-Za-z0-9:_/.\-]/gu, (character) => Array.from(Buffer.from(character), (byte) => `%${byte.toString(16).toUpperCase().padStart(2, "0")}`).join(""))}`;
+  const displayName = typeof fromName === "string" ? fromName.replace(/["<>\p{Cf}\p{Cc}\p{Cs}\p{Zl}\p{Zp}]/gu, "").trim() : "";
+  const name = displayName ? ` from-name="${displayName}"` : "";
   const mode = ["bypass", "prompting"].includes(permissionMode) ? ` from-mode="${permissionMode}"` : "";
   return {
     msgV: PEER_PROTOCOL_VERSION,
@@ -49,7 +51,7 @@ export function buildFrame({ text, fromSocket, priority = "next", permissionMode
     type: "user",
     message: {
       role: "user",
-      content: `<cross-session-message from="${from}"${mode}>\n${text}\n</cross-session-message>`,
+      content: `<cross-session-message from="${from}"${name}${mode}>\n${text}\n</cross-session-message>`,
     },
     priority,
     from,
@@ -413,6 +415,38 @@ function isImageToolCompanion(entry, entriesById) {
         && typeof tool.id === "string" && tool.id === part.tool_use_id));
 }
 
+function compactContinuation(entry, root, entriesById, sessionId, cwd) {
+  if (entry.type !== "system" || entry.subtype !== "compact_boundary" || entry.parentUuid !== null
+      || typeof entry.logicalParentUuid !== "string") return null;
+  const sameIdentity = (record) => record?.entrypoint === "claude-desktop"
+    && record.sessionId === sessionId && record.cwd === root.cwd;
+  if (!sameIdentity(root) || !sameIdentity(entry) || typeof root.cwd !== "string"
+      || path.resolve(root.cwd) !== path.resolve(cwd)) return null;
+  const segment = entry.compactMetadata?.preservedSegment;
+  const preserved = entry.compactMetadata?.preservedMessages;
+  const ids = preserved?.uuids;
+  if (!Array.isArray(ids) || !ids.length || ids.length > 65536
+      || ids.some((id) => typeof id !== "string" || !id) || new Set(ids).size !== ids.length
+      || !Array.isArray(preserved.allUuids) || preserved.allUuids.length !== ids.length
+      || ids.some((id, index) => preserved.allUuids[index] !== id)
+      || !ids.includes(root.uuid) || segment?.headUuid !== ids[0]
+      || segment.tailUuid !== ids.at(-1) || segment.tailUuid !== entry.logicalParentUuid
+      || typeof segment.anchorUuid !== "string" || preserved.anchorUuid !== segment.anchorUuid) return null;
+  if (ids.some((id, index) => !sameIdentity(entriesById.get(id))
+      || index > 0 && entriesById.get(id).parentUuid !== ids[index - 1])
+      || ids.includes(entriesById.get(ids[0]).parentUuid)) return null;
+  const summary = entriesById.get(segment.anchorUuid);
+  if (!sameIdentity(summary) || summary.type !== "user" || summary.message?.role !== "user"
+      || summary.isCompactSummary !== true || summary.isVisibleInTranscriptOnly !== true
+      || summary.turnOrigin !== "peer" || summary.origin != null || summary.promptSource != null) return null;
+  let ancestor = entriesById.get(summary.parentUuid);
+  for (let depth = 0; depth < 64 && ancestor?.type === "attachment"; depth++) {
+    if (!sameIdentity(ancestor)) return null;
+    ancestor = entriesById.get(ancestor.parentUuid);
+  }
+  return ancestor === entry ? summary.uuid : null;
+}
+
 // Interruption closes reply observation, not execution. Never attach a later
 // user turn's answer to the original request or claim its side effects stopped.
 export function readTranscriptOutcome(sessionId, cwd, msgId) {
@@ -445,6 +479,7 @@ export function readTranscriptOutcome(sessionId, cwd, msgId) {
   const openLeaves = new Set();
   const passiveLeaves = new Set();
   const interruptions = [];
+  const compactSummaries = new Set();
   const interrupt = (entry, outstanding) => {
     if (typeof entry.uuid !== "string" || !entry.uuid.trim()) return;
     openLeaves.delete(entry.parentUuid);
@@ -452,7 +487,16 @@ export function readTranscriptOutcome(sessionId, cwd, msgId) {
   };
   for (const entry of entries) {
     if (entry === root) { descendants.set(entry.uuid, new Map()); openLeaves.add(entry.uuid); continue; }
-    if (!descendants.has(entry.parentUuid)) continue;
+    let parentUuid = entry.parentUuid;
+    if (!ambiguous && !interruptions.length && descendants.has(entry.logicalParentUuid)
+        && openLeaves.has(entry.logicalParentUuid)) {
+      const summaryId = compactContinuation(entry, root, entriesById, sessionId, cwd);
+      if (summaryId) {
+        parentUuid = entry.logicalParentUuid;
+        compactSummaries.add(summaryId);
+      }
+    }
+    if (!descendants.has(parentUuid)) continue;
     if (entry.type === "attachment" && entry.attachment?.type === "queued_command") {
       // Only a native command record is a boundary. Its text is never used as
       // proof of authorization, cancellation, or successful task completion.
@@ -469,10 +513,10 @@ export function readTranscriptOutcome(sessionId, cwd, msgId) {
     }
     const role = entry.message?.role;
     const content = entry.message?.content;
-    const outstanding = new Map(descendants.get(entry.parentUuid));
+    const outstanding = new Map(descendants.get(parentUuid));
     const toolResults = Array.isArray(content) && content.length > 0 && content.every((part) => part?.type === "tool_result");
     const imageCompanion = isImageToolCompanion(entry, entriesById);
-    if (role === "user" && !toolResults && !imageCompanion) {
+    if (role === "user" && !toolResults && !imageCompanion && !compactSummaries.has(entry.uuid)) {
       const notificationText = typeof content === "string" ? content
         : Array.isArray(content) ? content.filter((part) => typeof part?.text === "string").map((part) => part.text).join("\n") : "";
       const nativeHuman = entry.origin?.kind === "human" && entry.promptSource === "sdk" && entry.turnOrigin === "human";
@@ -524,7 +568,7 @@ export function readTranscriptOutcome(sessionId, cwd, msgId) {
       && ["hook_success", "total_tokens_reminder", "deferred_tools_record"].includes(entry.attachment?.type)) {
       passiveLeaves.add(entry.uuid);
     }
-    openLeaves.delete(entry.parentUuid);
+    openLeaves.delete(parentUuid);
     openLeaves.add(entry.uuid);
     if (role !== "assistant" || !["end_turn", "stop_sequence"].includes(entry.message.stop_reason)) continue;
     if (outstanding.size > 0) continue;
@@ -858,7 +902,7 @@ export class PeerEndpoint {
 
   async send(targetSocket, text, { priority = "next", msgId, permissionMode = this.permissionMode, beforeSend } = {}) {
     if (this.reloadPaused) throw new Error("The peer endpoint is quiesced; no message was sent");
-    const frame = buildFrame({ text, fromSocket: this.socketPath, priority, permissionMode });
+    const frame = buildFrame({ text, fromSocket: this.socketPath, fromName: this.name, priority, permissionMode });
     if (msgId) frame.uuid = frame.msg_id = msgId;
     const token = readPeerToken(targetSocket);
     const line = (token ? JSON.stringify({ type: "auth", token }) + "\n" : "") + JSON.stringify(frame) + "\n";

package/src/platform.mjs

@@ -1,5 +1,5 @@
 import { execFile, execFileSync } from "node:child_process";
-import { accessSync, constants, existsSync, readdirSync, statSync } from "node:fs";
+import { accessSync, constants, existsSync, readdirSync, realpathSync, statSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -338,7 +338,7 @@ function remapCandidates(input) {
  * checkout is unavailable locally. UNC shares are tried after local remap
  * candidates so a disconnected network location cannot stall the bridge.
  */
-export function resolveWorkspacePath(input) {
+export function resolveWorkspacePath(input, { requireUnique = false } = {}) {
   if (!input) return { path: input, remapped: false, writable: false, note: null };
   const original = input;
   const mapped = pathMapCandidates(input);
@@ -348,7 +348,11 @@ export function resolveWorkspacePath(input) {
     : [...mapped, input, ...remapped];
   const ordered = candidates.filter((candidate, index) => candidates.indexOf(candidate) === index);
 
-  const writable = ordered.find((candidate) => existsSync(candidate) && isWritableDir(candidate));
+  const usable = requireUnique ? ordered.filter((candidate) => existsSync(candidate) && isWritableDir(candidate)) : null;
+  if (usable && new Set(usable.map(candidate => realpathSync.native(candidate))).size > 1) {
+    throw new Error("Multiple usable workspace directories match; select an unambiguous project path");
+  }
+  const writable = usable ? usable[0] : ordered.find((candidate) => existsSync(candidate) && isWritableDir(candidate));
   if (writable) {
     return {
       path: path.resolve(writable),

package/src/project-policy.mjs

@@ -150,6 +150,15 @@ export function createProjectScope(file, options = {}) {
     assert: (candidate, label) => capture(candidate, label).path,
     allows(candidate) { try { capture(candidate); return true; } catch { return false; } },
     capture,
+    assertDiscoverySource(candidate) {
+      const original = canonicalPolicyPath(candidate);
+      const namespaces = [path.resolve(candidate), original];
+      const { policy } = readProjectPolicy(file);
+      if (policy.denies.some(entry => namespaces.some(source => inside(entry.path, source) || entry.worktrees?.some(root => inside(root.path, source))))) {
+        throw new Error("The original project path was revoked; relocation discovery is not authorized");
+      }
+      return original;
+    },
     recheck(binding, label = "Working directory") {
       if (!binding?.identity) throw new Error(`${label} has no original directory identity`);
       const now = capture(binding.path, label);

package/src/thread-delivery.mjs

@@ -5,7 +5,7 @@ import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { creationRequestHash } from "./native-creation-receipts.mjs";
 import { DesktopTaskReceipts } from "./desktop-task-receipts.mjs";
-import { captureCodexRolloutWatermark, inspectCodexNativeTurn, readCodexNativeTurnResponse, readCodexNativeCreationResponse } from "./codex-native-response.mjs";
+import { captureCodexRolloutWatermark, inspectCodexNativeTurn, readCodexNativeTurnResponse, readCodexNativeCreationResponse, resolveCodexNativeDispatchResponse } from "./codex-native-response.mjs";
 import { captureProjectScope, recheckProjectScope } from "./project-scope.mjs";
 import { requireClaudeSenderContext } from "./claude-sender-context.mjs";
 
@@ -59,7 +59,7 @@ export function matchDesktopProject(projects, cwd, { canonicalize = realpathSync
 }
 
 export class DesktopTaskDelivery {
-  constructor({ relay = new NativeDesktopRelay({ socketPath: desktopTaskSocketPath(), accountSocketPath: accountRelaySocketPath() }), security, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), now = Date.now, receipts = new DesktopTaskReceipts(), beforeRequest, accountContext, senderContext, captureResponse = captureCodexRolloutWatermark, readResponse = readCodexNativeTurnResponse, inspectResponse = inspectCodexNativeTurn } = {}) {
+  constructor({ relay = new NativeDesktopRelay({ socketPath: desktopTaskSocketPath(), accountSocketPath: accountRelaySocketPath() }), security, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), now = Date.now, receipts = new DesktopTaskReceipts(), beforeRequest, accountContext, senderContext, captureResponse = captureCodexRolloutWatermark, readResponse = readCodexNativeTurnResponse, inspectResponse = inspectCodexNativeTurn, resolveResponse = readResponse === readCodexNativeTurnResponse ? resolveCodexNativeDispatchResponse : null } = {}) {
     this.relay = relay;
     this.security = security;
     this.sleep = sleep;
@@ -71,6 +71,7 @@ export class DesktopTaskDelivery {
     this.captureResponse = captureResponse;
     this.readResponse = readResponse;
     this.inspectResponse = inspectResponse;
+    this.resolveResponse = resolveResponse;
     this.threadOperations = new Map();
   }
 
@@ -101,7 +102,7 @@ export class DesktopTaskDelivery {
       const projectScope = expectedScope ?? await this.mutationProjectScope(operation, args, { deadline });
       if (expectedScope) recheckProjectScope(expectedScope, this.senderProjectScope(expectedScope.recipient.input));
       const remaining = deadline === undefined ? undefined : deadline - this.now();
-      if (remaining !== undefined && remaining <= 0) throw new Error("The bridge's response deadline has elapsed; this operation was not sent");
+      if (remaining !== undefined && remaining <= 0) throw Object.assign(new Error("The bridge's response deadline has elapsed; this operation was not sent"), { code: "DESKTOP_RESPONSE_DEADLINE" });
       const accountContext = this.accountContext?.();
       const response = await this.relay.requestDesktop(operation, args, {
         ...(remaining === undefined ? {} : { timeoutMs: remaining }),
@@ -432,7 +433,7 @@ export class DesktopTaskDelivery {
     if (response?.navigated !== true) throw new Error(`Desktop did not confirm opening task ${threadId}`);
   }
 
-  async observeNativeResponse(threadId, turnId, responseObservation, { deadline } = {}) {
+  async observeNativeResponse(threadId, turnId, responseObservation, { deadline, resolveDispatch = false } = {}) {
     if (!responseObservation) return unavailableObservation("Codex Desktop completed the turn without exposing assistant response text or a pre-send observation binding.");
     const { expectedCwd } = responseObservation;
     const args = { threadId, hostId: "local", turnLimit: 1 };
@@ -445,12 +446,12 @@ export class DesktopTaskDelivery {
     };
     await recheck();
     const initial = await this.inspect(threadId, expectedCwd, { deadline });
-    if (initial.latestTurnId !== turnId) throw new Error("The selected native task changed before its response could be read; reply content was withheld");
-    const read = responseObservation.operation === "create_thread" ? readCodexNativeCreationResponse : this.readResponse;
+    if (!resolveDispatch && initial.latestTurnId !== turnId) throw new Error("The selected native task changed before its response could be read; reply content was withheld");
+    const read = resolveDispatch ? this.resolveResponse : responseObservation.operation === "create_thread" ? readCodexNativeCreationResponse : this.readResponse;
     const observed = read({ ...responseObservation, threadId, turnId, desktopEvidence: initial });
     await recheck();
     const inspected = await this.inspect(threadId, expectedCwd, { deadline });
-    if (inspected.latestTurnId !== turnId) throw new Error("The selected native task changed before its response could be confirmed; reply content was withheld");
+    if (inspected.latestTurnId !== (resolveDispatch ? initial.latestTurnId : turnId)) throw new Error("The selected native task changed before its response could be confirmed; reply content was withheld");
     await recheck();
     return observed;
   }
@@ -491,6 +492,19 @@ export class DesktopTaskDelivery {
       return { polls: [{ thread, latestTurn: result.turns?.[0] ?? null }] };
     };
     const expired = () => ({ threadId, turnId, status: "timeout", text: "", responseStatus: "unavailable", assistantItems: [], replySha256: null, activity: [], errors: [], durationMs: this.now() - startedAt });
+    const deadlineError = (error) => {
+      const cause = error.cause ?? error;
+      return this.now() - startedAt >= timeoutMs && (["DESKTOP_RESPONSE_DEADLINE", "RELAY_TIMEOUT"].includes(cause.code) ||
+        cause.code === "RELAY_UNREACHABLE" && cause.message === "The Codex Desktop relay send deadline elapsed before dispatch");
+    };
+    const observe = async (selectedTurnId, resolveDispatch = false) => {
+      try {
+        return await this.observeNativeResponse(threadId, selectedTurnId, responseObservation, { deadline: startedAt + timeoutMs, resolveDispatch });
+      } catch (error) {
+        if (deadlineError(error)) return null;
+        throw error;
+      }
+    };
     for (;;) {
       if (this.now() - startedAt >= timeoutMs) return expired();
       let response;
@@ -499,13 +513,13 @@ export class DesktopTaskDelivery {
           targets: [{ threadId, hostId: "local", ...(cursor ? { afterCursor: cursor } : {}) }], timeoutMs: 0,
         }, { deadline: startedAt + timeoutMs });
       } catch (err) {
-        if (this.now() - startedAt >= timeoutMs) return expired();
+        if (deadlineError(err)) return expired();
         if (readSnapshots || !unavailableWaitRenderer(err)) throw err;
         readSnapshots = true;
         try {
           response = await readSnapshot();
         } catch (readError) {
-          if (this.now() - startedAt >= timeoutMs) return expired();
+          if (deadlineError(readError)) return expired();
           throw readError;
         }
       }
@@ -514,15 +528,45 @@ export class DesktopTaskDelivery {
       cursor = poll.cursor;
       const turn = poll.latestTurn;
       const threadStatus = typeof poll.thread.status === "string" ? poll.thread.status : poll.thread.status?.type;
-      if (["systemError", "waitingOnApproval", "waitingOnUserInput"].includes(threadStatus)) {
-        return { threadId, turnId: turn?.id !== previousTurnId ? turn?.id ?? null : null, status: threadStatus, text: "", activity: [], errors: [], durationMs: this.now() - startedAt };
+      const needsAttention = ["systemError", "waitingOnApproval", "waitingOnUserInput"].includes(threadStatus);
+      const attention = () => ({ threadId, turnId: turn?.id !== previousTurnId ? turn?.id ?? null : null, status: threadStatus, text: "", activity: [], errors: [], durationMs: this.now() - startedAt });
+      if (this.resolveResponse && responseObservation?.watermark?.status === "available" && responseObservation.operation !== "create_thread") {
+        const observed = await observe(null, true);
+        if (!observed) return expired();
+        turnId = observed.turnId ?? null;
+        if (observed.status !== "pending") {
+          return {
+            threadId, turnId, status: observed.status === "unavailable" ? "failed" : "completed",
+            responseStatus: observed.status, observationStatus: observed.status,
+            text: observed.status === "completed" ? observed.text : "",
+            ...(observed.reason ? { observationReason: observed.reason } : {}),
+            assistantItems: observed.assistantItems ?? [], replySha256: observed.replySha256 ?? null,
+            responseSource: observed.source ?? null,
+            ...(observed.responseScope ? { responseScope: observed.responseScope } : {}),
+            activity: [], errors: [], durationMs: this.now() - startedAt,
+          };
+        }
+        if (needsAttention) return attention();
+        if (this.now() - startedAt >= timeoutMs) return expired();
+        await this.sleep(Math.min(1500, timeoutMs - (this.now() - startedAt)));
+        continue;
       }
-      if (turn?.id && turn.id !== previousTurnId) {
-        turnId = turn.id;
+      if (needsAttention) return attention();
+      const existingTurn = turn?.id === previousTurnId;
+      if (turn?.id && (!existingTurn || responseObservation?.previousTurnId === previousTurnId)) {
+        if (!existingTurn) turnId = turn.id;
         const status = turn.status;
         if (RELEASE_STATUSES.has(status)) {
-          const observed = await this.observeNativeResponse(threadId, turnId, responseObservation, { deadline: startedAt + timeoutMs });
+          const observed = await observe(turn.id);
+          if (!observed) return expired();
           const responseStatus = observed.status;
+          if (existingTurn && !observed.dispatchObserved && !["completed", "completed_no_reply"].includes(responseStatus)) {
+            turnId = null;
+            if (this.now() - startedAt >= timeoutMs) return expired();
+            await this.sleep(Math.min(1500, timeoutMs - (this.now() - startedAt)));
+            continue;
+          }
+          turnId = turn.id;
           return {
             threadId, turnId, status,
             text: responseStatus === "completed" ? observed.text : "",
@@ -532,6 +576,7 @@ export class DesktopTaskDelivery {
             assistantItems: observed.assistantItems ?? [],
             replySha256: observed.replySha256 ?? null,
             responseSource: observed.source ?? null,
+            ...(observed.responseScope ? { responseScope: observed.responseScope } : {}),
             activity: [], errors: turn.error ? [turn.error] : [], durationMs: turn.durationMs ?? this.now() - startedAt,
           };
         }