cli-wechat-bridge 1.0.5 → 1.0.7

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

@@ -1,16 +1,83 @@
 import fs from "node:fs";
 import net from "node:net";
+import os from "node:os";
 import path from "node:path";
 import { buildLocalCompanionToken } from "../companion/local-companion-link.js";
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
-import { buildClaudeFailureMessage, buildClaudeHookScript, buildClaudeHookSettings, buildClaudePermissionDecisionHookOutput, buildClaudePermissionApprovalRequest, extractClaudeAssistantMessageText, extractClaudeResumeConversationId, extractClaudeTranscriptFinalReply, findInjectedClaudePromptIndex, normalizeClaudeAssistantMessage, parseClaudeHookPayload, } from "./claude-hooks.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 { 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, isClaudeInvalidResumeError, quotePosixCommandArg, quoteWindowsCommandArg, shouldIncludeClaudeNoAltScreen, } = shared;
+const { CLAUDE_HOOK_LISTEN_HOST, CLAUDE_WECHAT_WORKING_NOTICE_DELAY_MS, DEFAULT_COLS, DEFAULT_ROWS, MODULE_DIR, buildClaudeCliArgs, delay, isClaudeInvalidResumeError, quotePosixCommandArg, quoteWindowsCommandArg, shouldIncludeClaudeNoAltScreen, } = shared;
 const CLAUDE_COMPACT_OUTPUT_LINE_RE = /^Compacted(?:\s*\(.*full summary.*\))?$/i;
 const CLAUDE_COMPACT_FAILURE_RE = /Error:\s*Error during compaction:|(?:^|\b)API Error:|\b(?:compact|compaction)\s+failed\b|^Error:/i;
 const CLAUDE_COMPACT_DEDUP_MS = 2_000;
+const CLAUDE_BRACKETED_PASTE_START = "\u001b[200~";
+const CLAUDE_BRACKETED_PASTE_END = "\u001b[201~";
+const CLAUDE_REMOTE_ENTER_DELAY_MS = 40;
+const CLAUDE_STARTUP_OUTPUT_BUFFER_LIMIT = 4_000;
+function isClaudeWorkspaceTrustPrompt(text) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    return (/Accessing workspace:/i.test(compact) &&
+        /Quick safety check:/i.test(compact) &&
+        /project you created or one you trust/i.test(compact) &&
+        /I trust this folder/i.test(compact));
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function normalizeClaudeProjectConfigKey(cwd) {
+    return path.resolve(cwd).replace(/\\/g, "/");
+}
+export function ensureClaudeWorkspaceTrustAccepted(cwd, homeDir = process.env.USERPROFILE || process.env.HOME || os.homedir()) {
+    const configPath = path.join(homeDir, ".claude.json");
+    let config = {};
+    try {
+        if (fs.existsSync(configPath)) {
+            const raw = fs.readFileSync(configPath, "utf8");
+            config = raw.trim() ? JSON.parse(raw) : {};
+        }
+    }
+    catch {
+        return false;
+    }
+    if (!isRecord(config)) {
+        return false;
+    }
+    const projectKey = normalizeClaudeProjectConfigKey(cwd);
+    const projects = isRecord(config.projects) ? config.projects : {};
+    const currentProject = isRecord(projects[projectKey])
+        ? projects[projectKey]
+        : {};
+    if (currentProject.hasTrustDialogAccepted === true) {
+        return false;
+    }
+    const nextConfig = {
+        ...config,
+        projects: {
+            ...projects,
+            [projectKey]: {
+                ...currentProject,
+                hasTrustDialogAccepted: true,
+            },
+        },
+    };
+    const tempPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
+    try {
+        fs.writeFileSync(tempPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf8");
+        fs.renameSync(tempPath, configPath);
+        return true;
+    }
+    catch {
+        try {
+            fs.rmSync(tempPath, { force: true });
+        }
+        catch {
+            // Best effort cleanup.
+        }
+        return false;
+    }
+}
 export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     hookServer = null;
     hookPort = null;
@@ -29,11 +96,20 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     workingNoticeSent = false;
     workingNoticeDelayMs = CLAUDE_WECHAT_WORKING_NOTICE_DELAY_MS;
     lastCompactCompletionAtMs = 0;
+    startupOutputBuffer = "";
+    hasAutoConfirmedWorkspaceTrustPrompt = false;
     constructor(options) {
         super(options);
-        this.runtimeSessionId = options.initialSharedSessionId ?? options.initialSharedThreadId ?? null;
-        this.resumeConversationId = options.initialResumeConversationId ?? null;
-        this.transcriptPath = options.initialTranscriptPath ?? null;
+        const shouldRestoreInitialSession = options.sessionStartMode !== "new";
+        this.runtimeSessionId = shouldRestoreInitialSession
+            ? options.initialSharedSessionId ?? options.initialSharedThreadId ?? null
+            : null;
+        this.resumeConversationId = shouldRestoreInitialSession
+            ? options.initialResumeConversationId ?? null
+            : null;
+        this.transcriptPath = shouldRestoreInitialSession
+            ? options.initialTranscriptPath ?? null
+            : null;
         if (this.runtimeSessionId) {
             this.state.sharedSessionId = this.runtimeSessionId;
             this.state.activeRuntimeSessionId = this.runtimeSessionId;
@@ -49,6 +125,9 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         if (this.pty) {
             return;
         }
+        this.startupOutputBuffer = "";
+        this.hasAutoConfirmedWorkspaceTrustPrompt = false;
+        ensureClaudeWorkspaceTrustAccepted(this.options.cwd);
         // Validate transcript file exists before launching Claude CLI.
         // After a compact, the old transcript is deleted and the persisted
         // resumeConversationId becomes invalid, causing --resume to crash.
@@ -99,7 +178,8 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.pendingCliApprovalHints = null;
         this.clearWechatWorkingNotice(true);
         this.setStatus("busy");
-        this.writeToPty(text.replace(/\r?\n/g, "\r"));
+        this.writeToPty(this.buildRemoteInputPayload(text));
+        await delay(CLAUDE_REMOTE_ENTER_DELAY_MS);
         this.writeToPty("\r");
         this.armWechatWorkingNotice();
     }
@@ -205,6 +285,9 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             return;
         }
         this.state.lastOutputAt = nowIso();
+        if (this.maybeAutoConfirmWorkspaceTrustPrompt(text)) {
+            return;
+        }
         if (this.shouldTreatClaudeOutputAsCompactCompletion(text)) {
             this.completeClaudeCompact();
             return;
@@ -237,6 +320,18 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             return;
         }
     }
+    maybeAutoConfirmWorkspaceTrustPrompt(text) {
+        if (this.hasAcceptedInput || this.hasAutoConfirmedWorkspaceTrustPrompt) {
+            return false;
+        }
+        this.startupOutputBuffer = `${this.startupOutputBuffer}${text}`.slice(-CLAUDE_STARTUP_OUTPUT_BUFFER_LIMIT);
+        if (!isClaudeWorkspaceTrustPrompt(this.startupOutputBuffer)) {
+            return false;
+        }
+        this.hasAutoConfirmedWorkspaceTrustPrompt = true;
+        this.writeToPty("\r");
+        return true;
+    }
     handleExit(exitCode) {
         this.detachLocalTerminal();
         this.clearWechatWorkingNotice(true);
@@ -464,6 +559,13 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             timestamp: nowIso(),
         });
     }
+    buildRemoteInputPayload(text) {
+        const normalizedText = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        if (!normalizedText.includes("\n")) {
+            return normalizedText;
+        }
+        return `${CLAUDE_BRACKETED_PASTE_START}${normalizedText}${CLAUDE_BRACKETED_PASTE_END}`;
+    }
     shouldTreatClaudeOutputAsCompactCompletion(text) {
         if (this.state.status !== "busy" &&
             this.state.status !== "awaiting_approval" &&
@@ -707,6 +809,25 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     }
     handleClaudePermissionRequest(requestId, payload, socket) {
         this.clearWechatWorkingNotice();
+        const denyMessage = getClaudeWechatOutboundAttachmentDenyMessage(payload);
+        if (denyMessage) {
+            this.pendingApproval = null;
+            this.state.pendingApproval = null;
+            this.state.pendingApprovalOrigin = undefined;
+            if (this.state.status === "awaiting_approval") {
+                this.setStatus("busy");
+            }
+            this.respondToClaudeHook(socket, requestId, buildClaudePermissionDecisionHookOutput("deny", denyMessage));
+            return;
+        }
+        const autoResponse = getClaudePermissionAutoResponse(payload);
+        if (autoResponse) {
+            if (!this.pendingApproval && !this.state.pendingApproval) {
+                this.setStatus("busy", `Claude approval auto-approved: ${truncatePreview(autoResponse.reason, 180)}`);
+            }
+            this.respondToClaudeHook(socket, requestId, buildClaudePermissionDecisionHookOutput(autoResponse.action));
+            return;
+        }
         this.flushPendingClaudeHookApprovals();
         this.pendingHookApprovals.set(requestId, {
             requestId,

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

@@ -7,7 +7,7 @@ import { AbstractPtyAdapter } from "./bridge-adapters.core.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";
-const { CODEX_APP_SERVER_HOST, CODEX_APP_SERVER_LOG_LIMIT, 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, buildCliEnvironment, buildCodexApprovalRequest, buildCodexCliArgs, buildCodexUserInputRequest, coerceWebSocketMessageData, delay, describeUnknownError, extractCodexFinalTextFromItem, extractCodexThreadFollowIdFromStatusChanged, extractCodexThreadStartedThreadId, extractCodexUserMessageText, findCodexSessionFile, findRecentCodexSessionFileForCwd, getCodexRpcRequestId, getNotificationThreadId, getNotificationTurnId, isRecord, isRecentIsoTimestamp, listCodexResumeSessions, normalizeComparablePath, normalizeCodexRpcError, reserveLocalPort, resolveSpawnTarget, shouldAutoCompleteCodexWechatTurnAfterFinalReply, shouldIgnoreCodexSessionReplayEntry, shouldRecoverCodexStaleBusyState, waitForTcpPort, } = shared;
+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;
 export class CodexPtyAdapter extends AbstractPtyAdapter {
     runtimeKind = "codex_runtime_host";
@@ -24,6 +24,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     cleanPanelExitInProgress = false;
     rpcRequestCounter = 0;
     pendingRpcRequests = new Map();
+    subscribedThreadIds = new Set();
     sharedThreadId = null;
     announcedThreadId = null;
     pendingThreadAnnouncement = null;
@@ -63,7 +64,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     localClientInstanceId = `${process.pid}-${Date.now().toString(36)}`;
     constructor(options) {
         super(options);
-        this.resumeThreadId = options.initialSharedSessionId ?? options.initialSharedThreadId ?? null;
+        this.resumeThreadId = options.sessionStartMode === "new"
+            ? null
+            : options.initialSharedSessionId ?? options.initialSharedThreadId ?? null;
         if (this.resumeThreadId && options.renderMode !== "panel") {
             this.state.sharedSessionId = this.resumeThreadId;
             this.state.sharedThreadId = this.resumeThreadId;
@@ -194,6 +197,27 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         return await super.resolveApproval(action);
     }
+    async submitUserInput(answers) {
+        if (!this.pendingUserInputRequest) {
+            return false;
+        }
+        const request = this.pendingUserInputRequest;
+        const responseAnswers = {};
+        for (const [questionId, values] of Object.entries(answers)) {
+            responseAnswers[questionId] = {
+                answers: values,
+            };
+        }
+        this.sendRpcMessage({
+            id: request.requestId,
+            result: {
+                answers: responseAnswers,
+            },
+        });
+        this.clearPendingUserInputState();
+        this.setStatus("busy", "Codex user input submitted.");
+        return true;
+    }
     async dispose() {
         this.resetTurnTracking({ preserveThread: false });
         if (this.isEmbeddedCliMode()) {
@@ -752,6 +776,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.pendingApproval) {
             throw new Error("A Codex approval request is pending. Reply with /confirm <code> 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.");
+        }
         if (this.pendingTurnStart || this.activeTurn || this.state.status === "busy") {
             const origin = this.state.activeTurnOrigin;
             if (origin === "local") {
@@ -766,6 +793,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.rememberInjectedInput(text);
         this.clearPendingApprovalState();
         const threadId = await this.ensureThreadStarted();
+        const subscribedBeforeTurnStart = await this.tryEnsureSharedThreadSubscribed(threadId);
         this.pendingTurnStart = true;
         this.pendingTurnThreadId = threadId;
         this.interruptPendingTurnStart = false;
@@ -793,6 +821,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 turnId,
                 origin: "wechat",
             });
+            if (!subscribedBeforeTurnStart) {
+                await this.tryEnsureSharedThreadSubscribed(threadId);
+            }
             if (this.interruptPendingTurnStart) {
                 await this.requestActiveTurnInterrupt();
                 this.armInterruptFallback();
@@ -813,11 +844,15 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.isNativePanelMode() && !this.nativeProcess) {
             return false;
         }
-        const turnPending = this.pendingTurnStart || this.state.status === "busy" || this.state.status === "awaiting_approval";
+        const turnPending = this.pendingTurnStart ||
+            this.state.status === "busy" ||
+            this.state.status === "awaiting_approval" ||
+            this.state.status === "awaiting_input";
         if (!turnPending) {
             return false;
         }
         this.clearPendingApprovalState();
+        this.clearPendingUserInputState();
         if (this.pendingTurnStart && !this.activeTurn) {
             this.interruptPendingTurnStart = true;
             this.armInterruptFallback();
@@ -980,6 +1015,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     attachRpcSocket(socket) {
         this.rpcSocket = socket;
         this.rpcShuttingDown = false;
+        this.subscribedThreadIds.clear();
         socket.addEventListener("message", (event) => {
             this.handleRpcMessageData(event.data);
         });
@@ -991,6 +1027,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         const socket = this.rpcSocket;
         this.rpcSocket = null;
         this.rpcShuttingDown = true;
+        this.subscribedThreadIds.clear();
         this.rejectPendingRpcRequests("Codex websocket connection closed.");
         if (!socket) {
             this.rpcShuttingDown = false;
@@ -1028,6 +1065,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             cleanPanelExitInProgress: this.cleanPanelExitInProgress,
         });
         this.rpcSocket = null;
+        this.subscribedThreadIds.clear();
         this.rejectPendingRpcRequests("Codex websocket connection closed.");
         this.rpcShuttingDown = false;
         if (expectedShutdown) {
@@ -1156,9 +1194,44 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             throw new Error("Codex did not return a thread id for the bridge session.");
         }
         this.rememberBridgeOwnedThreadSignal(threadId);
+        this.subscribedThreadIds.add(threadId);
         this.updateSharedThread(threadId);
         return threadId;
     }
+    async tryEnsureSharedThreadSubscribed(threadId) {
+        if (this.subscribedThreadIds.has(threadId)) {
+            return true;
+        }
+        try {
+            await this.ensureSharedThreadSubscribed(threadId);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async ensureSharedThreadSubscribed(threadId) {
+        if (this.subscribedThreadIds.has(threadId)) {
+            return;
+        }
+        const response = await this.sendRpcRequest("thread/resume", {
+            threadId,
+            cwd: this.options.cwd,
+            approvalPolicy: "on-request",
+            approvalsReviewer: "user",
+            sandbox: "workspace-write",
+            excludeTurns: true,
+        });
+        const resumedThreadId = this.extractThreadIdFromResponse(response);
+        if (!resumedThreadId) {
+            throw new Error("Codex did not return a thread id while subscribing the bridge client.");
+        }
+        this.rememberBridgeOwnedThreadSignal(resumedThreadId);
+        this.subscribedThreadIds.add(resumedThreadId);
+        if (resumedThreadId !== this.sharedThreadId) {
+            this.updateSharedThread(resumedThreadId);
+        }
+    }
     async resumeSharedThread(threadId, options = {}) {
         const trimmedThreadId = threadId.trim();
         if (!trimmedThreadId) {
@@ -1180,12 +1253,14 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             approvalPolicy: "on-request",
             approvalsReviewer: "user",
             sandbox: "workspace-write",
+            excludeTurns: true,
         });
         const resumedThreadId = this.extractThreadIdFromResponse(response);
         if (!resumedThreadId) {
             throw new Error("Codex did not return a thread id while resuming the saved thread.");
         }
         this.rememberBridgeOwnedThreadSignal(resumedThreadId);
+        this.subscribedThreadIds.add(resumedThreadId);
         this.sessionFilePath = null;
         this.sessionReadOffset = 0;
         this.sessionPartialLine = "";
@@ -1238,7 +1313,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.clearInterruptTimer();
         this.interruptTimer = setTimeout(() => {
             this.interruptTimer = null;
-            if (this.state.status !== "busy" && this.state.status !== "awaiting_approval") {
+            if (this.state.status !== "busy" &&
+                this.state.status !== "awaiting_approval" &&
+                this.state.status !== "awaiting_input") {
                 return;
             }
             this.resetTurnTracking({ preserveThread: true });
@@ -1263,6 +1340,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             pendingTurnStart: this.pendingTurnStart,
             hasActiveTurn: Boolean(this.activeTurn),
             hasPendingApproval: Boolean(this.pendingApproval || this.pendingApprovalRequest),
+            hasPendingUserInput: Boolean(this.pendingUserInputRequest || this.state.pendingUserInput),
             activeTurnId: this.state.activeTurnId,
         })) {
             return;
@@ -1301,6 +1379,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.interruptPendingTurnStart = false;
         this.pendingThreadFollowId = null;
         this.clearPendingApprovalState();
+        this.clearPendingUserInputState();
         this.queuedTurnNotifications = [];
         this.queuedTurnServerRequests = [];
         this.turnFinalMessages.clear();
@@ -1503,6 +1582,11 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.state.pendingApproval = null;
         this.state.pendingApprovalOrigin = undefined;
     }
+    clearPendingUserInputState() {
+        this.pendingUserInputRequest = null;
+        this.state.pendingUserInput = null;
+        this.state.pendingUserInputOrigin = undefined;
+    }
     cleanupTurnArtifacts(turnId) {
         this.clearFinalReplyCompletionTimerForTurn(turnId);
         this.turnFinalMessages.delete(turnId);
@@ -1570,6 +1654,13 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         socket.send(JSON.stringify(payload));
     }
     async respondToApprovalRequest(request, action) {
+        if (request.method === "item/permissions/requestApproval") {
+            this.sendRpcMessage({
+                id: request.requestId,
+                result: buildCodexPermissionsRequestApprovalResponse(request.params, action),
+            });
+            return;
+        }
         const decision = action === "confirm" ? "accept" : "decline";
         this.sendRpcMessage({
             id: request.requestId,
@@ -1754,6 +1845,15 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                         this.setStatus("busy", "Codex approval resolved.");
                     }
                 }
+                if (requestId !== null &&
+                    this.pendingUserInputRequest &&
+                    requestId === this.pendingUserInputRequest.requestId &&
+                    trackedTurn.turnId === this.pendingUserInputRequest.turnId) {
+                    this.clearPendingUserInputState();
+                    if (this.state.status === "awaiting_input") {
+                        this.setStatus("busy", "Codex user input resolved.");
+                    }
+                }
                 return;
             }
             case "turn/completed": {
@@ -1764,8 +1864,24 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
     }
     handleRpcServerRequest(requestId, method, params) {
+        if (method === "mcpServer/elicitation/request") {
+            this.sendRpcMessage({
+                id: requestId,
+                result: buildCodexMcpServerElicitationDeclineResponse(),
+            });
+            return;
+        }
+        if (method === "item/tool/call") {
+            this.sendRpcMessage({
+                id: requestId,
+                result: buildCodexDynamicToolCallFailureResponse(),
+            });
+            return;
+        }
         if (method !== "item/commandExecution/requestApproval" &&
-            method !== "item/fileChange/requestApproval") {
+            method !== "item/fileChange/requestApproval" &&
+            method !== "item/permissions/requestApproval" &&
+            method !== "item/tool/requestUserInput") {
             this.sendRpcMessage({
                 id: requestId,
                 error: {
@@ -1793,16 +1909,57 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
             return;
         }
-        const trackedTurn = this.identifyTrackedTurn("server/request", params);
+        const trackedTurn = this.identifyTrackedTurn("server/request", params) ??
+            this.fallbackTrackedTurnForServerRequest(params);
         if (!trackedTurn) {
+            this.sendRpcMessage({
+                id: requestId,
+                error: {
+                    code: -32602,
+                    message: "Invalid Codex server request payload: missing threadId or turnId.",
+                },
+            });
             return;
         }
         this.handleTrackedTurnStarted(trackedTurn);
         this.handleTrackedTurnServerRequest(requestId, method, params, trackedTurn);
     }
     handleTrackedTurnServerRequest(requestId, method, params, trackedTurn) {
+        if (method === "item/tool/requestUserInput") {
+            this.handleTrackedTurnUserInputRequest(requestId, params, trackedTurn);
+            return;
+        }
+        const denyMessage = getCodexWechatOutboundAttachmentDenyMessage(method, params);
+        if (denyMessage) {
+            this.sendRpcMessage({
+                id: requestId,
+                result: method === "item/permissions/requestApproval"
+                    ? buildCodexPermissionsRequestApprovalResponse(params, "deny")
+                    : { decision: "decline" },
+            });
+            this.state.lastOutputAt = nowIso();
+            this.setStatus("busy", `Codex approval auto-denied: ${truncatePreview(denyMessage, 180)}`);
+            return;
+        }
+        const autoResponse = getCodexApprovalAutoResponse(method, params);
+        if (autoResponse) {
+            this.sendRpcMessage({
+                id: requestId,
+                result: autoResponse.result,
+            });
+            this.state.lastOutputAt = nowIso();
+            this.setStatus("busy", `Codex approval auto-approved: ${truncatePreview(autoResponse.reason, 180)}`);
+            return;
+        }
         const request = buildCodexApprovalRequest(method, params);
         if (!request) {
+            this.sendRpcMessage({
+                id: requestId,
+                error: {
+                    code: -32602,
+                    message: "Invalid Codex approval request payload.",
+                },
+            });
             return;
         }
         this.pendingApprovalRequest = {
@@ -1811,18 +1968,63 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             threadId: trackedTurn.threadId,
             turnId: trackedTurn.turnId,
             origin: trackedTurn.origin,
+            params,
         };
         this.pendingApproval = request;
         this.state.pendingApproval = request;
         this.state.pendingApprovalOrigin = trackedTurn.origin;
         this.state.lastOutputAt = nowIso();
-        this.setStatus("awaiting_approval", "Codex approval is required.");
+        this.setStatus("awaiting_approval", `Codex approval is required: ${truncatePreview(request.commandPreview, 180)}`);
         this.emit({
             type: "approval_required",
             request,
             timestamp: nowIso(),
         });
     }
+    fallbackTrackedTurnForServerRequest(params) {
+        if (this.activeTurn) {
+            return null;
+        }
+        const threadId = getNotificationThreadId(params);
+        const turnId = getNotificationTurnId(params);
+        if (!threadId || !turnId) {
+            return null;
+        }
+        return {
+            threadId,
+            turnId,
+            origin: this.bridgeOwnedTurnIds.has(turnId) ? "wechat" : "local",
+        };
+    }
+    handleTrackedTurnUserInputRequest(requestId, params, trackedTurn) {
+        const request = buildCodexUserInputRequest(params);
+        if (!request) {
+            this.sendRpcMessage({
+                id: requestId,
+                error: {
+                    code: -32602,
+                    message: "Invalid Codex user input request payload.",
+                },
+            });
+            return;
+        }
+        this.pendingUserInputRequest = {
+            requestId,
+            method: "item/tool/requestUserInput",
+            threadId: trackedTurn.threadId,
+            turnId: trackedTurn.turnId,
+            origin: trackedTurn.origin,
+        };
+        this.state.pendingUserInput = request;
+        this.state.pendingUserInputOrigin = trackedTurn.origin;
+        this.state.lastOutputAt = nowIso();
+        this.setStatus("awaiting_input", "Codex is waiting for user input.");
+        this.emit({
+            type: "user_input_required",
+            request,
+            timestamp: nowIso(),
+        });
+    }
     handleThreadStatusChanged(params) {
         const threadId = extractCodexThreadFollowIdFromStatusChanged(params);
         if (!threadId) {
@@ -1935,6 +2137,10 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             this.pendingApprovalRequest.turnId === trackedTurn.turnId) {
             this.clearPendingApprovalState();
         }
+        if (this.pendingUserInputRequest &&
+            this.pendingUserInputRequest.turnId === trackedTurn.turnId) {
+            this.clearPendingUserInputState();
+        }
         if (this.activeTurn?.turnId === trackedTurn.turnId) {
             this.setActiveTurn(null);
         }
@@ -2023,6 +2229,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             this.pendingTurnStart ||
             this.pendingApproval ||
             this.pendingApprovalRequest ||
+            this.pendingUserInputRequest ||
+            this.state.pendingUserInput ||
             !this.collectTurnOutput(turnId)) {
             return;
         }
@@ -2039,6 +2247,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         const finalText = this.collectTurnOutput(turnId);
         const lastActivityAtMs = this.turnLastActivityAtMs.get(turnId) ?? null;
         const pendingApproval = Boolean(this.pendingApproval || this.pendingApprovalRequest);
+        const pendingUserInput = Boolean(this.pendingUserInputRequest || this.state.pendingUserInput);
         const nowMs = Date.now();
         if (!shouldAutoCompleteCodexWechatTurnAfterFinalReply({
             candidateTurnId: turnId,
@@ -2046,6 +2255,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             activeTurnOrigin: activeTurn?.origin,
             pendingTurnStart: this.pendingTurnStart,
             hasPendingApproval: pendingApproval,
+            hasPendingUserInput: pendingUserInput,
             hasFinalOutput: Boolean(finalText),
             hasCompletedTurn: this.hasCompletedTurn(turnId),
             lastActivityAtMs,
@@ -2056,6 +2266,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 activeTurn.origin === "wechat" &&
                 !this.pendingTurnStart &&
                 !pendingApproval &&
+                !pendingUserInput &&
                 finalText &&
                 typeof lastActivityAtMs === "number") {
                 const remainingMs = CODEX_FINAL_REPLY_SETTLE_DELAY_MS - (nowMs - lastActivityAtMs);
@@ -2073,6 +2284,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             return;
         }
         this.clearPendingApprovalState();
+        this.clearPendingUserInputState();
         this.setActiveTurn(null);
         this.cleanupTurnArtifacts(turnId);
         this.state.lastOutputAt = nowIso();

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

@@ -20,21 +20,29 @@ export class LocalCompanionProxyAdapter {
     reconnectShutdownTimer = null;
     constructor(options) {
         this.options = options;
+        const shouldRestoreInitialSession = options.sessionStartMode !== "new";
+        const initialSharedSessionId = shouldRestoreInitialSession
+            ? options.initialSharedSessionId ?? options.initialSharedThreadId
+            : undefined;
         this.state = {
             kind: options.kind,
             status: "stopped",
             cwd: options.cwd,
             command: options.command,
             profile: options.profile,
-            sharedSessionId: options.initialSharedSessionId ?? options.initialSharedThreadId,
+            sharedSessionId: initialSharedSessionId,
             sharedThreadId: options.kind === "codex" || options.kind === "opencode"
-                ? options.initialSharedSessionId ?? options.initialSharedThreadId
+                ? initialSharedSessionId
                 : undefined,
             activeRuntimeSessionId: options.kind === "claude" || options.kind === "opencode"
-                ? options.initialSharedSessionId ?? options.initialSharedThreadId
+                ? initialSharedSessionId
+                : undefined,
+            resumeConversationId: shouldRestoreInitialSession && options.kind === "claude"
+                ? options.initialResumeConversationId
+                : undefined,
+            transcriptPath: shouldRestoreInitialSession && options.kind === "claude"
+                ? options.initialTranscriptPath
                 : undefined,
-            resumeConversationId: options.kind === "claude" ? options.initialResumeConversationId : undefined,
-            transcriptPath: options.kind === "claude" ? options.initialTranscriptPath : undefined,
         };
     }
     setEventSink(sink) {