cli-wechat-bridge 1.1.2 → 1.1.4

package/dist/bridge/bridge-adapters.codex.js

@@ -10,6 +10,7 @@ import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV, LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
 const { CODEX_APP_SERVER_HOST, CODEX_APP_SERVER_READY_TIMEOUT_MS, CODEX_FINAL_REPLY_SETTLE_DELAY_MS, CODEX_RECENT_SESSION_KEY_LIMIT, CODEX_RPC_CONNECT_RETRY_MS, CODEX_RPC_RECONNECT_TIMEOUT_MS, CODEX_SESSION_FALLBACK_SCAN_INTERVAL_MS, CODEX_SESSION_LOCAL_MIRROR_FALLBACK_WINDOW_MS, CODEX_SESSION_POLL_INTERVAL_MS, CODEX_STARTUP_WARMUP_MS, CODEX_THREAD_SIGNAL_TTL_MS, INTERRUPT_SETTLE_DELAY_MS, appendBoundedLog, buildCodexApprovalRequest, buildCodexCliArgs, buildCodexDynamicToolCallFailureResponse, buildCodexMcpServerElicitationDeclineResponse, buildCodexPermissionsRequestApprovalResponse, buildCodexUserInputRequest, coerceWebSocketMessageData, delay, describeUnknownError, extractCodexFinalTextFromItem, extractCodexThreadFollowIdFromStatusChanged, extractCodexThreadStartedThreadId, extractCodexUserMessageText, findCodexSessionFile, findRecentCodexSessionFileForCwd, getCodexRpcRequestId, getCodexApprovalAutoResponse, getCodexWechatOutboundAttachmentDenyMessage, getNotificationThreadId, getNotificationTurnId, isRecord, isRecentIsoTimestamp, listCodexResumeSessions, normalizeComparablePath, normalizeCodexRpcError, reserveLocalPort, resolveSpawnTarget, shouldAutoCompleteCodexWechatTurnAfterFinalReply, shouldIgnoreCodexSessionReplayEntry, shouldRecoverCodexStaleBusyState, waitForTcpPort, } = shared;
 const CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS = 150;
+const CODEX_NON_BLOCKING_USER_INPUT_TIMEOUT_MS = 120_000;
 export class CodexPtyAdapter extends AbstractPtyAdapter {
     runtimeKind = "codex_runtime_host";
     appServer = null;
@@ -38,6 +39,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     pendingThreadFollowId = null;
     pendingApprovalRequests = [];
     pendingUserInputRequest = null;
+    pendingUserInputTimer = null;
+    userInputAutoResolutionDelayMs = CODEX_NON_BLOCKING_USER_INPUT_TIMEOUT_MS;
     queuedTurnNotifications = [];
     queuedTurnServerRequests = [];
     mirroredUserInputTurnIds = new Set();
@@ -526,6 +529,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 this.sessionPartialLine = "";
             }
             if (stat.size === this.sessionReadOffset) {
+                this.flushCompleteSessionPartialLine();
                 return;
             }
             const fd = fs.openSync(this.sessionFilePath, "r");
@@ -551,6 +555,22 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         for (const line of lines) {
             this.handleSessionLogLine(line);
         }
+        this.flushCompleteSessionPartialLine();
+    }
+    flushCompleteSessionPartialLine() {
+        const line = this.sessionPartialLine.trim();
+        if (!line) {
+            this.sessionPartialLine = "";
+            return;
+        }
+        try {
+            JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        this.sessionPartialLine = "";
+        this.handleSessionLogLine(line);
     }
     seedSessionReplayCutoff(startedAtMs) {
         if (this.sessionIgnoreBeforeMs !== null ||
@@ -1166,6 +1186,14 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 Date.now() < reconnectDeadline) {
                 try {
                     await this.connectRpcClient();
+                    // The new connection starts with an empty subscription set.
+                    // Resubscribe the shared thread so turn notifications and approval
+                    // requests keep flowing: without this, a mid-turn reconnect
+                    // silently stops delivery, and approvals answered over the new
+                    // connection (with the old request id) are ignored by the server.
+                    if (this.state.sharedThreadId) {
+                        await this.tryEnsureSharedThreadSubscribed(this.state.sharedThreadId);
+                    }
                     return true;
                 }
                 catch (error) {
@@ -1211,6 +1239,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             },
             capabilities: {
                 experimentalApi: true,
+                requestAttestation: false,
             },
         });
     }
@@ -1243,8 +1272,6 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             approvalsReviewer: "user",
             sandbox: "workspace-write",
             serviceName: "wechat-bridge",
-            experimentalRawEvents: false,
-            persistExtendedHistory: true,
         });
         const threadId = this.extractThreadIdFromResponse(response);
         if (!threadId) {
@@ -1375,7 +1402,20 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 this.state.status !== "awaiting_input") {
                 return;
             }
-            this.resetTurnTracking({ preserveThread: true });
+            // Remember the interrupted turn as completed before resetting: the
+            // server may still deliver a late turn/completed for it, and without
+            // this entry it would be tracked as a brand-new local turn — emitting a
+            // duplicate task_complete (or a ghost reply) for work we already
+            // reported as interrupted.
+            const interruptedTurnId = this.activeTurn?.turnId;
+            this.resetTurnTracking({
+                preserveThread: true,
+                preserveCompletedTurns: true,
+            });
+            if (interruptedTurnId) {
+                this.rememberCompletedTurn(interruptedTurnId);
+                this.bridgeOwnedTurnIds.add(interruptedTurnId);
+            }
             this.setStatus("idle", "Codex task interrupted.");
             this.emit({
                 type: "task_complete",
@@ -1444,9 +1484,11 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.turnErrorById.clear();
         this.turnLastActivityAtMs.clear();
         this.mirroredUserInputTurnIds.clear();
-        this.bridgeOwnedTurnIds.clear();
-        this.completedTurnIds.clear();
-        this.completedTurnOrder = [];
+        if (!options.preserveCompletedTurns) {
+            this.bridgeOwnedTurnIds.clear();
+            this.completedTurnIds.clear();
+            this.completedTurnOrder = [];
+        }
         this.pendingInjectedInputs = [];
         this.recentBridgeThreadSignalAtById.clear();
         this.sessionFinalText = null;
@@ -1640,6 +1682,10 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.state.pendingApprovalOrigin = undefined;
     }
     clearPendingUserInputState() {
+        if (this.pendingUserInputTimer) {
+            clearTimeout(this.pendingUserInputTimer);
+            this.pendingUserInputTimer = null;
+        }
         this.pendingUserInputRequest = null;
         this.state.pendingUserInput = null;
         this.state.pendingUserInputOrigin = undefined;
@@ -1816,6 +1862,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId || !turnId) {
             return null;
         }
+        if (this.hasCompletedTurn(turnId)) {
+            return null;
+        }
         if (this.bridgeOwnedTurnIds.has(turnId)) {
             return {
                 threadId,
@@ -1926,6 +1975,15 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
     }
     handleRpcServerRequest(requestId, method, params) {
+        if (method === "currentTime/read") {
+            this.sendRpcMessage({
+                id: requestId,
+                result: {
+                    currentTimeAt: Math.floor(Date.now() / 1_000),
+                },
+            });
+            return;
+        }
         if (method === "mcpServer/elicitation/request") {
             this.sendRpcMessage({
                 id: requestId,
@@ -2076,6 +2134,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             threadId: trackedTurn.threadId,
             turnId: trackedTurn.turnId,
             origin: trackedTurn.origin,
+            isBlocking: params.isBlocking !== false,
         };
         this.state.pendingUserInput = request;
         this.state.pendingUserInputOrigin = trackedTurn.origin;
@@ -2086,6 +2145,26 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             request,
             timestamp: nowIso(),
         });
+        if (this.pendingUserInputRequest.isBlocking) {
+            return;
+        }
+        const pendingRequest = this.pendingUserInputRequest;
+        this.pendingUserInputTimer = setTimeout(() => {
+            if (this.pendingUserInputRequest !== pendingRequest) {
+                return;
+            }
+            this.sendRpcMessage({
+                id: pendingRequest.requestId,
+                result: {
+                    answers: {},
+                },
+            });
+            this.clearPendingUserInputState();
+            if (this.state.status === "awaiting_input") {
+                this.setStatus("busy", "Codex non-blocking user input timed out.");
+            }
+        }, this.userInputAutoResolutionDelayMs);
+        this.pendingUserInputTimer.unref?.();
     }
     handleThreadStatusChanged(params) {
         const threadId = extractCodexThreadFollowIdFromStatusChanged(params);

package/dist/bridge/bridge-adapters.core.js

@@ -1,4 +1,5 @@
 import net from "node:net";
+import path from "node:path";
 import { spawn as spawnPty } from "node-pty";
 import { t } from "../i18n/index.js";
 import { attachLocalCompanionMessageListener, buildLocalCompanionToken, clearLocalCompanionEndpoint, clearLocalCompanionOccupancy, sendLocalCompanionMessage, updateLocalCompanionOccupancy, writeLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
@@ -6,12 +7,46 @@ import { detectCliApproval, normalizeOutput, nowIso, truncatePreview, } from "./
 import * as shared from "./bridge-adapters.shared.js";
 import { LOCAL_CLIENT_PROTOCOL_VERSION } from "../runtime/runtime-types.js";
 const { CODEX_APP_SERVER_HOST, INTERRUPT_SETTLE_DELAY_MS, buildCliEnvironment, buildPtySpawnOptions, buildSpawnDiagnostic, getLocalCompanionCommandName, getSharedSessionIdFromAdapterState, LOCAL_COMPANION_RECONNECT_GRACE_MS, resolveSpawnTarget, spawnFallbackProcess, } = shared;
+/**
+ * On Windows, node-pty (ConPTY) uses CreateProcess which can execute .cmd/.bat
+ * files directly — no need for the cmd.exe wrapper that resolveSpawnTarget adds
+ * for child_process.spawn compatibility.  The wrapper causes double-quoting when
+ * the script path contains spaces: node-pty quotes the already-quoted path,
+ * making cmd.exe treat the literal quotes as part of the filename.
+ */
+function unwrapCmdExeForPty(rawTarget) {
+    if (process.platform !== "win32") {
+        return rawTarget;
+    }
+    const fileName = path.basename(rawTarget.file).toLowerCase();
+    if (fileName !== "cmd.exe") {
+        return rawTarget;
+    }
+    const args = rawTarget.args;
+    if (args.length < 4 || args[0] !== "/d" || args[1] !== "/s" || args[2] !== "/c") {
+        return rawTarget;
+    }
+    // Strip surrounding double-quotes from the /c argument to recover the
+    // actual script path.  quoteForCmd wraps paths containing spaces in
+    // double-quotes, so we reverse that here.
+    const commandLine = args[3] ?? "";
+    const actualScript = commandLine.replace(/^"(.*)"$/s, "$1");
+    // Remaining args beyond the /c handler (args[4..]) are extra arguments
+    // that were passed through wrapWithCmdExe; forward them as the new target's
+    // args so they stay prepended before buildSpawnArgs().
+    return {
+        file: actualScript,
+        args: args.slice(4),
+    };
+}
 export class LocalCompanionProxyAdapter {
     options;
     state;
     eventSink = () => undefined;
     server = null;
     socket = null;
+    // Pending senders waiting for the companion's first state frame.
+    readyWaiters = new Set();
     detachMessageListener = null;
     requestCounter = 0;
     endpoint = null;
@@ -35,7 +70,7 @@ export class LocalCompanionProxyAdapter {
             sharedThreadId: options.kind === "codex" || options.kind === "opencode"
                 ? initialSharedSessionId
                 : undefined,
-            activeRuntimeSessionId: options.kind === "claude" || options.kind === "opencode"
+            activeRuntimeSessionId: options.kind === "claude" || options.kind === "opencode" || options.kind === "pi"
                 ? initialSharedSessionId
                 : undefined,
             resumeConversationId: shouldRestoreInitialSession && options.kind === "claude"
@@ -66,11 +101,22 @@ export class LocalCompanionProxyAdapter {
             });
             this.server = server;
             server.on("error", (error) => {
+                // Roll back the half-initialized server: start() early-returns while
+                // this.server is set, so a leftover handle would make every retry
+                // silently "succeed" without ever listening.
+                if (this.server === server) {
+                    this.server = null;
+                }
+                server.close();
                 reject(error);
             });
             server.listen(0, CODEX_APP_SERVER_HOST, () => {
                 const address = server.address();
                 if (!address || typeof address === "string") {
+                    if (this.server === server) {
+                        this.server = null;
+                    }
+                    server.close();
                     reject(new Error(`Failed to allocate a local ${this.options.kind} companion port.`));
                     return;
                 }
@@ -141,8 +187,17 @@ export class LocalCompanionProxyAdapter {
         const ok = await this.resolveApproval(action);
         return ok ? 1 : 0;
     }
-    async submitUserInput(_answers) {
-        return false;
+    async submitUserInput(answers) {
+        try {
+            const result = await this.sendRequest({
+                command: "submit_user_input",
+                answers,
+            });
+            return result === true;
+        }
+        catch {
+            return false;
+        }
     }
     async dispose() {
         this.shuttingDown = true;
@@ -277,6 +332,9 @@ export class LocalCompanionProxyAdapter {
                 this.state.activeTurnOrigin = undefined;
                 this.state.pendingApprovalOrigin = undefined;
                 Object.assign(this.state, message.state);
+                if (this.state.pid) {
+                    this.settleReadyWaiters();
+                }
                 this.eventSink({
                     type: "status",
                     status: this.state.status,
@@ -299,6 +357,10 @@ export class LocalCompanionProxyAdapter {
         }
     }
     detachPanelSocket() {
+        this.settleReadyWaiters(new Error(formatCompanionNotConnectedMessage({
+            kind: this.options.kind,
+            launchMode: this.options.companionLaunchMode,
+        })));
         this.rejectPendingRequests("Companion socket disconnected unexpectedly.");
         this.detachMessageListener?.();
         this.detachMessageListener = null;
@@ -387,8 +449,44 @@ export class LocalCompanionProxyAdapter {
         }
         this.pendingRequests.clear();
     }
+    /**
+     * Wait for the companion's first state frame (which reports the worker
+     * pid). The companion sends it only after its adapter finished starting —
+     * for opencode that spans spawning `opencode serve`, connecting, and the
+     * initial session scan — so a WeChat message arriving inside that window
+     * must wait instead of failing with "connected but not ready yet".
+     */
+    waitForCompanionReady() {
+        if (this.state.pid) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            const entry = {
+                timer: setTimeout(() => {
+                    this.readyWaiters.delete(entry);
+                    reject(new Error(`${this.options.kind} companion is connected but not ready yet. Wait for it to finish starting.`));
+                }, 30_000),
+                settle: (error) => {
+                    clearTimeout(entry.timer);
+                    this.readyWaiters.delete(entry);
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                },
+            };
+            this.readyWaiters.add(entry);
+        });
+    }
+    settleReadyWaiters(error) {
+        for (const entry of [...this.readyWaiters]) {
+            entry.settle(error);
+        }
+    }
     async sendRequest(payload) {
-        const socket = this.socket;
+        let socket = this.socket;
         if (!socket) {
             throw new Error(formatCompanionNotConnectedMessage({
                 kind: this.options.kind,
@@ -396,7 +494,14 @@ export class LocalCompanionProxyAdapter {
             }));
         }
         if (!this.state.pid && payload.command !== "dispose") {
-            throw new Error(`${this.options.kind} companion is connected but not ready yet. Wait for it to finish starting.`);
+            await this.waitForCompanionReady();
+            socket = this.socket;
+            if (!socket) {
+                throw new Error(formatCompanionNotConnectedMessage({
+                    kind: this.options.kind,
+                    launchMode: this.options.companionLaunchMode,
+                }));
+            }
         }
         const id = `${++this.requestCounter}`;
         const response = new Promise((resolve, reject) => {
@@ -513,7 +618,8 @@ export class AbstractPtyAdapter {
         this.setStatus("starting", `Starting ${this.options.kind} adapter...`);
         let spawnTarget = null;
         try {
-            spawnTarget = resolveSpawnTarget(this.options.command, this.options.kind);
+            const rawTarget = resolveSpawnTarget(this.options.command, this.options.kind);
+            spawnTarget = unwrapCmdExeForPty(rawTarget);
             const env = this.buildEnv();
             const spawnArgs = [...spawnTarget.args, ...this.buildSpawnArgs()];
             let ptyProcess;

package/dist/bridge/bridge-adapters.js

@@ -2,7 +2,7 @@ import { ClaudeCompanionAdapter } from "./bridge-adapters.claude.js";
 import { LocalCompanionProxyAdapter } from "./bridge-adapters.core.js";
 import { CodexPtyAdapter } from "./bridge-adapters.codex.js";
 import { OpenCodeServerAdapter } from "./bridge-adapters.opencode.js";
-import { ShellAdapter } from "./bridge-adapters.shell.js";
+import { PiTuiAdapter } from "./bridge-adapters.pi.js";
 export * from "./bridge-adapters.shared.js";
 export function createBridgeAdapter(options) {
     switch (options.kind) {
@@ -18,8 +18,10 @@ export function createBridgeAdapter(options) {
             return options.renderMode === "companion"
                 ? new OpenCodeServerAdapter(options)
                 : new LocalCompanionProxyAdapter(options);
-        case "shell":
-            return new ShellAdapter(options);
+        case "pi":
+            return options.renderMode === "companion"
+                ? new PiTuiAdapter(options)
+                : new LocalCompanionProxyAdapter(options);
         default:
             throw new Error(`Unsupported adapter: ${options.kind}`);
     }