cli-wechat-bridge 1.0.9 → 1.1.0

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

@@ -3,9 +3,10 @@ import net from "node:net";
 import os from "node:os";
 import path from "node:path";
 import { buildLocalCompanionToken } from "../companion/local-companion-link.js";
+import { t } from "../i18n/index.js";
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { buildClaudeFailureMessage, buildClaudeHookScript, buildClaudeHookSettings, buildClaudePermissionDecisionHookOutput, buildClaudePermissionApprovalRequest, extractClaudeAssistantMessageText, extractClaudeResumeConversationId, extractClaudeTranscriptFinalReply, findInjectedClaudePromptIndex, getClaudePermissionAutoResponse, getClaudeWechatOutboundAttachmentDenyMessage, normalizeClaudeAssistantMessage, parseClaudeHookPayload, } from "./claude-hooks.js";
-import { detectCliApproval, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
+import { detectCliApproval, isThinkingForwardEnabled, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
 import * as shared from "./bridge-adapters.shared.js";
 const { CLAUDE_HOOK_LISTEN_HOST, CLAUDE_WECHAT_WORKING_NOTICE_DELAY_MS, DEFAULT_COLS, DEFAULT_ROWS, MODULE_DIR, buildClaudeCliArgs, delay, isClaudeInvalidResumeError, quotePosixCommandArg, quoteWindowsCommandArg, shouldIncludeClaudeNoAltScreen, } = shared;
@@ -90,6 +91,9 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     localTerminalInputListener = null;
     resizeListener = null;
     settingsFilePath = null;
+    hookErrorLogPath = null;
+    hookReceivedCount = 0;
+    hookHealthCheckTimer = null;
     pendingHookApprovals = new Map();
     recoveringInvalidResume = false;
     workingNoticeTimer = null;
@@ -98,6 +102,10 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     lastCompactCompletionAtMs = 0;
     startupOutputBuffer = "";
     hasAutoConfirmedWorkspaceTrustPrompt = false;
+    lastAutoApprovedPayload = null;
+    transcriptPollTimer = null;
+    transcriptTailOffset = 0;
+    polledTranscriptSessionId = null;
     constructor(options) {
         super(options);
         const shouldRestoreInitialSession = options.sessionStartMode !== "new";
@@ -163,7 +171,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             throw new Error("claude is still working. Wait for the current reply or use /stop.");
         }
         if (this.pendingApproval) {
-            throw new Error("A Claude approval request is pending. Reply with /confirm <code> or /deny.");
+            throw new Error("A Claude approval request is pending. Reply with /confirm or /deny.");
         }
         const normalizedText = normalizeOutput(text).trim();
         this.pendingInjectedInputs.push({
@@ -178,6 +186,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.pendingCliApprovalHints = null;
         this.clearWechatWorkingNotice(true);
         this.setStatus("busy");
+        this.startTranscriptThinkingWatch();
         this.writeToPty(this.buildRemoteInputPayload(text));
         await delay(CLAUDE_REMOTE_ENTER_DELAY_MS);
         this.writeToPty("\r");
@@ -248,11 +257,34 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.writeToPty(input);
         return true;
     }
+    async resolveAllApprovals(action) {
+        let count = 0;
+        for (const requestId of Array.from(this.pendingHookApprovals.keys())) {
+            const pending = this.pendingHookApprovals.get(requestId);
+            if (pending) {
+                this.pendingHookApprovals.delete(requestId);
+                this.respondToClaudeHook(pending.socket, requestId, buildClaudePermissionDecisionHookOutput(action));
+                count++;
+            }
+        }
+        if (count > 0) {
+            this.clearWechatWorkingNotice();
+            this.pendingCliApprovalHints = null;
+            this.pendingApproval = null;
+            this.state.pendingApproval = null;
+            this.state.pendingApprovalOrigin = undefined;
+            this.setStatus("busy");
+            return count;
+        }
+        const ok = await this.resolveApproval(action);
+        return ok ? 1 : 0;
+    }
     async dispose() {
         this.detachLocalTerminal();
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
         this.flushPendingClaudeHookApprovals();
+        this.stopTranscriptThinkingWatch();
         await super.dispose();
         await this.stopHookServer();
     }
@@ -271,6 +303,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     afterStart() {
         this.attachLocalTerminal();
         this.resizePtyToTerminal();
+        this.startHookHealthCheck();
     }
     handleData(rawText) {
         this.renderLocalOutput(rawText);
@@ -447,12 +480,15 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         const hookEntryPath = fs.existsSync(sourceHookEntryPath)
             ? sourceHookEntryPath
             : path.join(MODULE_DIR, "claude-hook.js");
+        const hookErrorLogPath = path.join(runtimeDir, "hook-error.log");
+        this.hookErrorLogPath = hookErrorLogPath;
         fs.writeFileSync(hookScriptPath, buildClaudeHookScript({
             platform: process.platform,
             runtimeExecPath: process.execPath,
             hookEntryPath,
             hookPort: this.hookPort,
             hookToken: this.hookToken,
+            hookErrorLogPath,
         }), "utf8");
         if (process.platform !== "win32") {
             fs.chmodSync(hookScriptPath, 0o755);
@@ -501,7 +537,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             return;
         }
         try {
-            this.pty.resize(process.stdout.columns || DEFAULT_COLS, process.stdout.rows || DEFAULT_ROWS);
+            this.pty.resize?.(process.stdout.columns || DEFAULT_COLS, process.stdout.rows || DEFAULT_ROWS);
         }
         catch {
             // Best effort resize sync.
@@ -547,6 +583,34 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             this.workingNoticeSent = false;
         }
     }
+    startHookHealthCheck() {
+        this.hookReceivedCount = 0;
+        this.clearHookHealthCheck();
+        this.hookHealthCheckTimer = setTimeout(() => {
+            this.hookHealthCheckTimer = null;
+            if (this.hookReceivedCount === 0 && !this.shuttingDown) {
+                const logHint = this.hookErrorLogPath
+                    ? t("hook.healthCheck.logHint", { logPath: this.hookErrorLogPath })
+                    : "";
+                this.emit({
+                    type: "stdout",
+                    text: [
+                        t("hook.healthCheck.warning"),
+                        logHint,
+                        t("hook.healthCheck.fixes"),
+                    ].filter(Boolean).join("\n"),
+                    timestamp: nowIso(),
+                });
+            }
+        }, 15_000);
+        this.hookHealthCheckTimer.unref?.();
+    }
+    clearHookHealthCheck() {
+        if (this.hookHealthCheckTimer) {
+            clearTimeout(this.hookHealthCheckTimer);
+            this.hookHealthCheckTimer = null;
+        }
+    }
     emitClaudeNotice(text, level = "info") {
         const normalized = normalizeOutput(text).trim();
         if (!normalized) {
@@ -668,6 +732,8 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.currentPreview = "(idle)";
     }
     handleClaudeHookEnvelope(params) {
+        this.hookReceivedCount++;
+        this.clearHookHealthCheck();
         const payload = parseClaudeHookPayload(params.rawPayload);
         if (!payload?.hook_event_name) {
             this.respondToClaudeHook(params.socket, params.requestId);
@@ -686,8 +752,32 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
                 this.handleClaudePermissionRequest(params.requestId, payload, params.socket);
                 return;
             case "Notification":
-                if (payload.notification_type === "permission_prompt" && this.pendingApproval) {
-                    this.setStatus("awaiting_approval", "Claude approval is required.");
+                if (payload.notification_type === "permission_prompt") {
+                    if (this.pendingApproval) {
+                        this.setStatus("awaiting_approval", "Claude approval is required.");
+                    }
+                    else if (this.lastAutoApprovedPayload) {
+                        // Auto-approval response failed to reach Claude Code (socket closed before delivery).
+                        // Fall back to forwarding the approval request to WeChat.
+                        const fallbackPayload = this.lastAutoApprovedPayload;
+                        this.lastAutoApprovedPayload = null;
+                        const request = buildClaudePermissionApprovalRequest(fallbackPayload);
+                        this.pendingApproval = {
+                            ...request,
+                            requestId: undefined,
+                            confirmInput: this.pendingCliApprovalHints?.confirmInput,
+                            denyInput: this.pendingCliApprovalHints?.denyInput,
+                        };
+                        this.pendingCliApprovalHints = null;
+                        this.state.pendingApproval = this.pendingApproval;
+                        this.state.pendingApprovalOrigin = this.state.activeTurnOrigin;
+                        this.setStatus("awaiting_approval", "Claude auto-approval failed, forwarding to WeChat.");
+                        this.emit({
+                            type: "approval_required",
+                            request: this.pendingApproval,
+                            timestamp: nowIso(),
+                        });
+                    }
                 }
                 this.respondToClaudeHook(params.socket, params.requestId);
                 return;
@@ -740,6 +830,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.state.resumeConversationId = nextResumeConversationId ?? undefined;
         this.transcriptPath = nextTranscriptPath;
         this.state.transcriptPath = nextTranscriptPath ?? undefined;
+        this.startTranscriptThinkingWatch();
         if (previousRuntimeSessionId === payload.session_id) {
             return;
         }
@@ -778,6 +869,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.pendingCliApprovalHints = null;
         this.clearWechatWorkingNotice(true);
         this.setStatus("busy");
+        this.startTranscriptThinkingWatch();
         this.emit({
             type: "mirrored_user_input",
             text: prompt,
@@ -817,6 +909,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     }
     handleClaudePermissionRequest(requestId, payload, socket) {
         this.clearWechatWorkingNotice();
+        this.lastAutoApprovedPayload = null;
         const denyMessage = getClaudeWechatOutboundAttachmentDenyMessage(payload);
         if (denyMessage) {
             this.pendingApproval = null;
@@ -833,6 +926,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             if (!this.pendingApproval && !this.state.pendingApproval) {
                 this.setStatus("busy", `Claude approval auto-approved: ${truncatePreview(autoResponse.reason, 180)}`);
             }
+            this.lastAutoApprovedPayload = payload;
             this.respondToClaudeHook(socket, requestId, buildClaudePermissionDecisionHookOutput(autoResponse.action));
             return;
         }
@@ -898,6 +992,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     handleClaudeStop(payload) {
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
+        this.lastAutoApprovedPayload = null;
         this.flushPendingClaudeHookApprovals();
         this.pendingApproval = null;
         this.state.pendingApproval = null;
@@ -915,11 +1010,97 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             summary: this.currentPreview,
             timestamp: nowIso(),
         });
+        this.stopTranscriptThinkingWatch();
         this.currentPreview = "(idle)";
     }
     handleClaudeStopFailure(payload) {
+        this.lastAutoApprovedPayload = null;
+        this.stopTranscriptThinkingWatch();
         this.failClaudeTurn(buildClaudeFailureMessage(payload));
     }
+    startTranscriptThinkingWatch() {
+        this.stopTranscriptThinkingWatch();
+        if (!this.transcriptPath) {
+            return;
+        }
+        if (!isThinkingForwardEnabled()) {
+            return;
+        }
+        this.transcriptTailOffset = 0;
+        try {
+            const stat = fs.statSync(this.transcriptPath);
+            this.transcriptTailOffset = stat.size;
+        }
+        catch {
+            return;
+        }
+        const watchPath = this.transcriptPath;
+        const sessionId = this.runtimeSessionId;
+        this.polledTranscriptSessionId = sessionId;
+        this.transcriptPollTimer = setInterval(() => {
+            if (this.shuttingDown) {
+                this.stopTranscriptThinkingWatch();
+                return;
+            }
+            if (this.polledTranscriptSessionId !== this.runtimeSessionId) {
+                this.stopTranscriptThinkingWatch();
+                return;
+            }
+            try {
+                const stat = fs.statSync(watchPath);
+                if (stat.size <= this.transcriptTailOffset) {
+                    return;
+                }
+                const fd = fs.openSync(watchPath, "r");
+                const buf = Buffer.alloc(stat.size - this.transcriptTailOffset);
+                fs.readSync(fd, buf, 0, buf.length, this.transcriptTailOffset);
+                fs.closeSync(fd);
+                this.transcriptTailOffset = stat.size;
+                const newText = buf.toString("utf8");
+                const lines = newText.split(/\r?\n/).filter(Boolean);
+                for (const line of lines) {
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!parsed ||
+                        parsed.type !== "assistant" ||
+                        !Array.isArray(parsed.message?.content)) {
+                        continue;
+                    }
+                    for (const block of parsed.message.content) {
+                        if (block.type === "thinking" &&
+                            typeof block.thinking === "string" &&
+                            block.thinking.trim()) {
+                            const thinking = normalizeOutput(block.thinking).trim();
+                            if (thinking) {
+                                this.emit({
+                                    type: "thinking",
+                                    text: thinking,
+                                    timestamp: nowIso(),
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // File may be temporarily locked or deleted; silently retry next poll.
+            }
+        }, 800);
+        this.transcriptPollTimer.unref?.();
+    }
+    stopTranscriptThinkingWatch() {
+        if (this.transcriptPollTimer) {
+            clearInterval(this.transcriptPollTimer);
+            this.transcriptPollTimer = null;
+        }
+        this.transcriptTailOffset = 0;
+        this.polledTranscriptSessionId = null;
+    }
     respondToClaudeHook(socket, requestId, stdout) {
         try {
             socket.end(`${JSON.stringify({ requestId, stdout })}\n`);

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

@@ -4,6 +4,7 @@ import crypto from "node:crypto";
 import { spawn as spawnChild } from "node:child_process";
 import { detectCliApproval, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
+import { killProcessTreeSync } from "./bridge-process-reaper.js";
 import * as shared from "./bridge-adapters.shared.js";
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV, LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
@@ -35,7 +36,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     pendingTurnThreadId = null;
     interruptPendingTurnStart = false;
     pendingThreadFollowId = null;
-    pendingApprovalRequest = null;
+    pendingApprovalRequests = [];
     pendingUserInputRequest = null;
     queuedTurnNotifications = [];
     queuedTurnServerRequests = [];
@@ -137,7 +138,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             throw new Error("codex is still working. Wait for the current reply or use /stop.");
         }
         if (this.pendingApproval) {
-            throw new Error("A Codex approval request is pending. Reply with /confirm <code> or /deny.");
+            throw new Error("A Codex approval request is pending. Reply with /confirm or /deny.");
         }
         if (this.startupBlocker) {
             throw new Error("Codex is waiting for local terminal input before the session can continue.");
@@ -185,18 +186,35 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         return true;
     }
     async resolveApproval(action) {
-        if (!this.pendingApproval) {
+        if (!this.pendingApproval && this.pendingApprovalRequests.length === 0) {
             return false;
         }
-        if (this.pendingApprovalRequest && this.rpcSocket) {
-            const request = this.pendingApprovalRequest;
-            await this.respondToApprovalRequest(request, action);
+        if (this.pendingApprovalRequests.length > 0 && this.rpcSocket) {
+            for (const request of this.pendingApprovalRequests) {
+                await this.respondToApprovalRequest(request, action);
+            }
             this.clearPendingApprovalState();
             this.setStatus("busy");
             return true;
         }
         return await super.resolveApproval(action);
     }
+    async resolveAllApprovals(action) {
+        if (this.pendingApprovalRequests.length === 0 && !this.pendingApproval) {
+            return 0;
+        }
+        if (this.pendingApprovalRequests.length > 0 && this.rpcSocket) {
+            const count = this.pendingApprovalRequests.length;
+            for (const request of this.pendingApprovalRequests) {
+                await this.respondToApprovalRequest(request, action);
+            }
+            this.clearPendingApprovalState();
+            this.setStatus("busy");
+            return count;
+        }
+        const ok = await super.resolveApproval(action);
+        return ok ? 1 : 0;
+    }
     async submitUserInput(answers) {
         if (!this.pendingUserInputRequest) {
             return false;
@@ -450,7 +468,12 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             };
             child.once("exit", () => finish());
             try {
-                child.kill();
+                if (child.pid) {
+                    killProcessTreeSync(child.pid);
+                }
+                else {
+                    child.kill();
+                }
             }
             catch {
                 finish();
@@ -783,7 +806,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.recoverStaleBusyStateIfNeeded();
         this.recoverStaleActiveTurnStateIfNeeded();
         if (this.pendingApproval) {
-            throw new Error("A Codex approval request is pending. Reply with /confirm <code> or /deny.");
+            throw new Error("A Codex approval request is pending. Reply with /confirm or /deny.");
         }
         if (this.pendingUserInputRequest || this.state.pendingUserInput) {
             throw new Error("Codex is waiting for user input. Reply with /answer and your response, or use /stop.");
@@ -1247,7 +1270,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             throw new Error("A thread id is required to resume a Codex thread.");
         }
         if (this.pendingApproval) {
-            throw new Error("A Codex approval request is pending. Reply with /confirm <code> or /deny.");
+            throw new Error("A Codex approval request is pending. Reply with /confirm or /deny.");
         }
         if (!options.startup &&
             (this.pendingTurnStart ||
@@ -1348,7 +1371,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             status: this.state.status,
             pendingTurnStart: this.pendingTurnStart,
             hasActiveTurn: Boolean(this.activeTurn),
-            hasPendingApproval: Boolean(this.pendingApproval || this.pendingApprovalRequest),
+            hasPendingApproval: Boolean(this.pendingApproval || this.pendingApprovalRequests.length),
             hasPendingUserInput: Boolean(this.pendingUserInputRequest || this.state.pendingUserInput),
             activeTurnId: this.state.activeTurnId,
         })) {
@@ -1366,7 +1389,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!this.activeTurn ||
             this.pendingTurnStart ||
             this.pendingApproval ||
-            this.pendingApprovalRequest ||
+            this.pendingApprovalRequests.length ||
             this.state.status === "busy" ||
             this.state.status === "awaiting_approval" ||
             this.state.activeTurnId) {
@@ -1586,7 +1609,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         return true;
     }
     clearPendingApprovalState() {
-        this.pendingApprovalRequest = null;
+        this.pendingApprovalRequests = [];
         this.pendingApproval = null;
         this.state.pendingApproval = null;
         this.state.pendingApprovalOrigin = undefined;
@@ -1850,10 +1873,11 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             case "serverRequest/resolved": {
                 const requestId = getCodexRpcRequestId(params.requestId);
                 if (requestId !== null &&
-                    this.pendingApprovalRequest &&
-                    requestId === this.pendingApprovalRequest.requestId &&
-                    trackedTurn.turnId === this.pendingApprovalRequest.turnId) {
-                    this.clearPendingApprovalState();
+                    this.pendingApprovalRequests.some((r) => r.requestId === requestId && r.turnId === trackedTurn.turnId)) {
+                    this.pendingApprovalRequests = this.pendingApprovalRequests.filter((r) => r.requestId !== requestId);
+                    if (this.pendingApprovalRequests.length === 0) {
+                        this.clearPendingApprovalState();
+                    }
                     if (this.state.status === "awaiting_approval") {
                         this.setStatus("busy", "Codex approval resolved.");
                     }
@@ -1975,14 +1999,14 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
             return;
         }
-        this.pendingApprovalRequest = {
+        this.pendingApprovalRequests.push({
             requestId,
             method,
             threadId: trackedTurn.threadId,
             turnId: trackedTurn.turnId,
             origin: trackedTurn.origin,
             params,
-        };
+        });
         this.pendingApproval = request;
         this.state.pendingApproval = request;
         this.state.pendingApprovalOrigin = trackedTurn.origin;
@@ -2146,8 +2170,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             : completedTrackedTurn.origin === "local"
                 ? "Local terminal turn completed."
                 : this.currentPreview;
-        if (this.pendingApprovalRequest &&
-            this.pendingApprovalRequest.turnId === trackedTurn.turnId) {
+        if (this.pendingApprovalRequests.length > 0 &&
+            this.pendingApprovalRequests.some((r) => r.turnId === trackedTurn.turnId)) {
             this.clearPendingApprovalState();
         }
         if (this.pendingUserInputRequest &&
@@ -2241,7 +2265,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             this.activeTurn.origin !== "wechat" ||
             this.pendingTurnStart ||
             this.pendingApproval ||
-            this.pendingApprovalRequest ||
+            this.pendingApprovalRequests.length ||
             this.pendingUserInputRequest ||
             this.state.pendingUserInput ||
             !this.collectTurnOutput(turnId)) {
@@ -2259,7 +2283,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         const activeTurn = this.activeTurn;
         const finalText = this.collectTurnOutput(turnId);
         const lastActivityAtMs = this.turnLastActivityAtMs.get(turnId) ?? null;
-        const pendingApproval = Boolean(this.pendingApproval || this.pendingApprovalRequest);
+        const pendingApproval = Boolean(this.pendingApproval || this.pendingApprovalRequests.length);
         const pendingUserInput = Boolean(this.pendingUserInputRequest || this.state.pendingUserInput);
         const nowMs = Date.now();
         if (!shouldAutoCompleteCodexWechatTurnAfterFinalReply({
@@ -2339,7 +2363,12 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             };
             child.once("exit", () => finish());
             try {
-                child.kill();
+                if (child.pid) {
+                    killProcessTreeSync(child.pid);
+                }
+                else {
+                    child.kill();
+                }
             }
             catch {
                 finish();
@@ -2370,7 +2399,12 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         if (this.nativeProcess) {
             try {
-                this.nativeProcess.kill();
+                if (this.nativeProcess.pid) {
+                    killProcessTreeSync(this.nativeProcess.pid);
+                }
+                else {
+                    this.nativeProcess.kill();
+                }
             }
             catch {
                 // Best effort cleanup after panel client failure.

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

@@ -1,10 +1,11 @@
 import net from "node:net";
 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";
 import { detectCliApproval, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
 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, getLocalCompanionCommandName, getSharedSessionIdFromAdapterState, LOCAL_COMPANION_RECONNECT_GRACE_MS, resolveSpawnTarget, } = shared;
+const { CODEX_APP_SERVER_HOST, INTERRUPT_SETTLE_DELAY_MS, buildCliEnvironment, buildPtySpawnOptions, buildSpawnDiagnostic, getLocalCompanionCommandName, getSharedSessionIdFromAdapterState, LOCAL_COMPANION_RECONNECT_GRACE_MS, resolveSpawnTarget, spawnFallbackProcess, } = shared;
 export class LocalCompanionProxyAdapter {
     options;
     state;
@@ -136,6 +137,10 @@ export class LocalCompanionProxyAdapter {
         });
         return Boolean(result);
     }
+    async resolveAllApprovals(action) {
+        const ok = await this.resolveApproval(action);
+        return ok ? 1 : 0;
+    }
     async submitUserInput(_answers) {
         return false;
     }
@@ -299,6 +304,7 @@ export class LocalCompanionProxyAdapter {
         this.detachMessageListener = null;
         if (this.socket) {
             this.socket.removeAllListeners();
+            this.socket.on("error", () => { });
             this.socket.destroy();
             this.socket = null;
         }
@@ -509,10 +515,27 @@ export class AbstractPtyAdapter {
         try {
             spawnTarget = resolveSpawnTarget(this.options.command, this.options.kind);
             const env = this.buildEnv();
-            const ptyProcess = spawnPty(spawnTarget.file, [...spawnTarget.args, ...this.buildSpawnArgs()], buildPtySpawnOptions({
-                cwd: this.options.cwd,
-                env,
-            }));
+            const spawnArgs = [...spawnTarget.args, ...this.buildSpawnArgs()];
+            let ptyProcess;
+            let usedFallback = false;
+            try {
+                ptyProcess = spawnPty(spawnTarget.file, spawnArgs, buildPtySpawnOptions({
+                    cwd: this.options.cwd,
+                    env,
+                }));
+            }
+            catch (ptyErr) {
+                usedFallback = true;
+                try {
+                    ptyProcess = spawnFallbackProcess(spawnTarget.file, spawnArgs, {
+                        cwd: this.options.cwd,
+                        env,
+                    });
+                }
+                catch (fallbackErr) {
+                    throw new Error(buildSpawnDiagnostic(ptyErr, spawnTarget), { cause: fallbackErr });
+                }
+            }
             this.pty = ptyProcess;
             this.shuttingDown = false;
             this.hasAcceptedInput = false;
@@ -523,6 +546,13 @@ export class AbstractPtyAdapter {
             ptyProcess.onData((data) => this.handleData(data));
             ptyProcess.onExit(({ exitCode }) => this.handleExit(exitCode));
             this.afterStart();
+            if (usedFallback) {
+                this.emit({
+                    type: "stdout",
+                    text: t("pty.fallback.warning"),
+                    timestamp: nowIso(),
+                });
+            }
             this.setStatus("idle", `${this.options.kind} adapter is ready.`);
         }
         catch (err) {
@@ -584,6 +614,10 @@ export class AbstractPtyAdapter {
         this.state.pendingApproval = null;
         return true;
     }
+    async resolveAllApprovals(action) {
+        const ok = await this.resolveApproval(action);
+        return ok ? 1 : 0;
+    }
     async submitUserInput(_answers) {
         return false;
     }

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

@@ -110,7 +110,7 @@ export class OpenCodeServerAdapter {
             throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
         }
         if (this.pendingPermission) {
-            throw new Error("An OpenCode approval request is pending. Reply with /confirm <code> or /deny.");
+            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
         }
         const normalized = normalizeOutput(text).trim();
         if (!normalized) {
@@ -163,7 +163,7 @@ export class OpenCodeServerAdapter {
             throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
         }
         if (this.pendingPermission) {
-            throw new Error("An OpenCode approval request is pending. Reply with /confirm <code> or /deny.");
+            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
         }
         this.outputBatcher.clear();
         this.clearStreamedPartState();
@@ -254,6 +254,10 @@ export class OpenCodeServerAdapter {
         this.setStatus("busy");
         return true;
     }
+    async resolveAllApprovals(action) {
+        const ok = await this.resolveApproval(action);
+        return ok ? 1 : 0;
+    }
     async submitUserInput(_answers) {
         return false;
     }