cli-wechat-bridge 1.0.5

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

@@ -0,0 +1,829 @@
+import fs from "node:fs";
+import net from "node:net";
+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 { 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_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;
+export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
+    hookServer = null;
+    hookPort = null;
+    hookToken = null;
+    runtimeSessionId;
+    resumeConversationId;
+    transcriptPath;
+    pendingCliApprovalHints = null;
+    pendingInjectedInputs = [];
+    localTerminalInputListener = null;
+    resizeListener = null;
+    settingsFilePath = null;
+    pendingHookApprovals = new Map();
+    recoveringInvalidResume = false;
+    workingNoticeTimer = null;
+    workingNoticeSent = false;
+    workingNoticeDelayMs = CLAUDE_WECHAT_WORKING_NOTICE_DELAY_MS;
+    lastCompactCompletionAtMs = 0;
+    constructor(options) {
+        super(options);
+        this.runtimeSessionId = options.initialSharedSessionId ?? options.initialSharedThreadId ?? null;
+        this.resumeConversationId = options.initialResumeConversationId ?? null;
+        this.transcriptPath = options.initialTranscriptPath ?? null;
+        if (this.runtimeSessionId) {
+            this.state.sharedSessionId = this.runtimeSessionId;
+            this.state.activeRuntimeSessionId = this.runtimeSessionId;
+        }
+        if (this.resumeConversationId) {
+            this.state.resumeConversationId = this.resumeConversationId;
+        }
+        if (this.transcriptPath) {
+            this.state.transcriptPath = this.transcriptPath;
+        }
+    }
+    async start() {
+        if (this.pty) {
+            return;
+        }
+        // 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.
+        if (this.transcriptPath) {
+            try {
+                fs.accessSync(this.transcriptPath);
+            }
+            catch {
+                this.emitClaudeNotice(`Conversation transcript "${this.transcriptPath}" no longer exists (likely after compact). Starting fresh session.`, "warning");
+                this.transcriptPath = null;
+                this.resumeConversationId = null;
+                this.runtimeSessionId = null;
+                this.state.transcriptPath = undefined;
+                this.state.resumeConversationId = undefined;
+                this.state.sharedSessionId = undefined;
+                this.state.activeRuntimeSessionId = undefined;
+            }
+        }
+        await this.startHookServer();
+        try {
+            await super.start();
+        }
+        catch (error) {
+            await this.stopHookServer();
+            throw error;
+        }
+    }
+    async sendInput(text) {
+        if (!this.pty) {
+            throw new Error("claude adapter is not running.");
+        }
+        if (this.state.status === "busy") {
+            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.");
+        }
+        const normalizedText = normalizeOutput(text).trim();
+        this.pendingInjectedInputs.push({
+            normalizedText,
+            createdAtMs: Date.now(),
+        });
+        this.pendingInjectedInputs = this.pendingInjectedInputs.slice(-8);
+        this.hasAcceptedInput = true;
+        this.currentPreview = truncatePreview(text);
+        this.state.lastInputAt = nowIso();
+        this.state.activeTurnOrigin = "wechat";
+        this.pendingCliApprovalHints = null;
+        this.clearWechatWorkingNotice(true);
+        this.setStatus("busy");
+        this.writeToPty(text.replace(/\r?\n/g, "\r"));
+        this.writeToPty("\r");
+        this.armWechatWorkingNotice();
+    }
+    async listResumeSessions(_limit = 10) {
+        throw new Error('WeChat /resume is disabled in claude mode. Use /resume directly inside "wechat-claude"; WeChat will follow the active local session.');
+    }
+    async resumeSession(_threadId) {
+        throw new Error('WeChat /resume is disabled in claude mode. Use /resume directly inside "wechat-claude"; WeChat will follow the active local session.');
+    }
+    async interrupt() {
+        if (!this.pty) {
+            return false;
+        }
+        if (this.state.status !== "busy" && this.state.status !== "awaiting_approval") {
+            return false;
+        }
+        this.clearWechatWorkingNotice(true);
+        this.pendingCliApprovalHints = null;
+        this.flushPendingClaudeHookApprovals();
+        this.writeToPty("\u0003");
+        return true;
+    }
+    async reset() {
+        this.clearWechatWorkingNotice(true);
+        this.pendingCliApprovalHints = null;
+        this.runtimeSessionId = null;
+        this.resumeConversationId = null;
+        this.transcriptPath = null;
+        this.state.sharedSessionId = undefined;
+        this.state.sharedThreadId = undefined;
+        this.state.activeRuntimeSessionId = undefined;
+        this.state.resumeConversationId = undefined;
+        this.state.transcriptPath = undefined;
+        this.state.lastSessionSwitchAt = undefined;
+        this.state.lastSessionSwitchSource = undefined;
+        this.state.lastSessionSwitchReason = undefined;
+        await super.reset();
+    }
+    async resolveApproval(action) {
+        if (!this.pendingApproval) {
+            return false;
+        }
+        if (this.pendingApproval.requestId) {
+            const handled = this.respondToClaudeHookApproval(this.pendingApproval.requestId, action);
+            if (handled) {
+                this.clearWechatWorkingNotice();
+                this.pendingCliApprovalHints = null;
+                this.pendingApproval = null;
+                this.state.pendingApproval = null;
+                this.state.pendingApprovalOrigin = undefined;
+                this.setStatus("busy");
+                return true;
+            }
+        }
+        const input = action === "confirm" ? this.pendingApproval.confirmInput : this.pendingApproval.denyInput;
+        if (!input) {
+            throw new Error("Remote approval is not safely available for this Claude prompt. Approve it in the local Claude terminal.");
+        }
+        this.clearWechatWorkingNotice();
+        this.pendingCliApprovalHints = null;
+        this.pendingApproval = null;
+        this.state.pendingApproval = null;
+        this.state.pendingApprovalOrigin = undefined;
+        this.setStatus("busy");
+        this.writeToPty(input);
+        return true;
+    }
+    async dispose() {
+        this.detachLocalTerminal();
+        this.clearWechatWorkingNotice(true);
+        this.pendingCliApprovalHints = null;
+        this.flushPendingClaudeHookApprovals();
+        await super.dispose();
+        await this.stopHookServer();
+    }
+    buildSpawnArgs() {
+        if (!this.settingsFilePath) {
+            throw new Error("Claude companion settings are not ready.");
+        }
+        return buildClaudeCliArgs({
+            settingsFilePath: this.settingsFilePath,
+            resumeConversationId: this.resumeConversationId,
+            profile: this.options.profile,
+            includeNoAltScreen: shouldIncludeClaudeNoAltScreen(this.options.command),
+            extraCliArgs: this.options.extraCliArgs,
+        });
+    }
+    afterStart() {
+        this.attachLocalTerminal();
+        this.resizePtyToTerminal();
+    }
+    handleData(rawText) {
+        this.renderLocalOutput(rawText);
+        const text = normalizeOutput(rawText);
+        if (!text) {
+            return;
+        }
+        if (this.resumeConversationId &&
+            !this.hasAcceptedInput &&
+            !this.recoveringInvalidResume &&
+            isClaudeInvalidResumeError(text)) {
+            void this.recoverFromInvalidResume(this.resumeConversationId);
+            return;
+        }
+        this.state.lastOutputAt = nowIso();
+        if (this.shouldTreatClaudeOutputAsCompactCompletion(text)) {
+            this.completeClaudeCompact();
+            return;
+        }
+        const compactFailure = this.extractClaudeCompactFailure(text);
+        if (compactFailure) {
+            this.failClaudeTurn(compactFailure);
+            return;
+        }
+        const approval = detectCliApproval(text);
+        if (approval) {
+            this.clearWechatWorkingNotice();
+            if (this.pendingApproval) {
+                this.pendingApproval = {
+                    ...this.pendingApproval,
+                    confirmInput: this.pendingApproval.confirmInput ?? approval.confirmInput,
+                    denyInput: this.pendingApproval.denyInput ?? approval.denyInput,
+                };
+                this.state.pendingApproval = this.pendingApproval;
+            }
+            else {
+                this.pendingCliApprovalHints = {
+                    confirmInput: approval.confirmInput,
+                    denyInput: approval.denyInput,
+                };
+            }
+            return;
+        }
+        if (!this.hasAcceptedInput) {
+            return;
+        }
+    }
+    handleExit(exitCode) {
+        this.detachLocalTerminal();
+        this.clearWechatWorkingNotice(true);
+        this.pendingCliApprovalHints = null;
+        void this.stopHookServer();
+        if (this.recoveringInvalidResume && !this.shuttingDown) {
+            this.clearCompletionTimer();
+            this.pty = null;
+            this.state.status = "stopped";
+            this.state.pid = undefined;
+            this.pendingApproval = null;
+            this.state.pendingApproval = null;
+            return;
+        }
+        super.handleExit(exitCode);
+    }
+    async startHookServer() {
+        if (this.hookServer) {
+            return;
+        }
+        this.hookToken = buildLocalCompanionToken();
+        await new Promise((resolve, reject) => {
+            const server = net.createServer((socket) => {
+                let buffer = "";
+                socket.setEncoding("utf8");
+                socket.on("data", (chunk) => {
+                    buffer += chunk;
+                    while (true) {
+                        const newlineIndex = buffer.indexOf("\n");
+                        if (newlineIndex < 0) {
+                            break;
+                        }
+                        const line = buffer.slice(0, newlineIndex).trim();
+                        buffer = buffer.slice(newlineIndex + 1);
+                        if (!line) {
+                            continue;
+                        }
+                        try {
+                            const envelope = JSON.parse(line);
+                            if (envelope.token === this.hookToken &&
+                                typeof envelope.requestId === "string" &&
+                                typeof envelope.payload === "string") {
+                                this.handleClaudeHookEnvelope({
+                                    requestId: envelope.requestId,
+                                    rawPayload: envelope.payload,
+                                    socket,
+                                });
+                            }
+                        }
+                        catch {
+                            // Ignore malformed hook payloads.
+                        }
+                    }
+                });
+                const cleanupPendingRequestsForSocket = () => {
+                    for (const [requestId, pending] of this.pendingHookApprovals.entries()) {
+                        if (pending.socket === socket) {
+                            this.pendingHookApprovals.delete(requestId);
+                            this.handleClosedClaudeHookApproval(requestId);
+                        }
+                    }
+                };
+                socket.once("close", cleanupPendingRequestsForSocket);
+                socket.once("error", cleanupPendingRequestsForSocket);
+            });
+            this.hookServer = server;
+            server.once("error", (error) => {
+                reject(error);
+            });
+            server.listen(0, CLAUDE_HOOK_LISTEN_HOST, () => {
+                const address = server.address();
+                if (!address || typeof address === "string") {
+                    reject(new Error("Failed to allocate a local Claude hook port."));
+                    return;
+                }
+                this.hookPort = address.port;
+                try {
+                    this.writeClaudeRuntimeFiles();
+                    resolve();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    async stopHookServer() {
+        this.flushPendingClaudeHookApprovals();
+        if (!this.hookServer) {
+            this.hookPort = null;
+            this.settingsFilePath = null;
+            return;
+        }
+        const server = this.hookServer;
+        this.hookServer = null;
+        this.hookPort = null;
+        this.settingsFilePath = null;
+        await new Promise((resolve) => {
+            server.close(() => resolve());
+        });
+    }
+    writeClaudeRuntimeFiles() {
+        if (!this.hookPort || !this.hookToken) {
+            throw new Error("Claude hook server is not ready.");
+        }
+        const { workspaceDir } = ensureWorkspaceChannelDir(this.options.cwd);
+        const runtimeDir = path.join(workspaceDir, "claude-runtime");
+        fs.mkdirSync(runtimeDir, { recursive: true });
+        const hookScriptPath = path.join(runtimeDir, process.platform === "win32" ? "hook.cmd" : "hook.sh");
+        const settingsFilePath = path.join(runtimeDir, "settings.json");
+        const sourceHookEntryPath = path.join(MODULE_DIR, "claude-hook.ts");
+        const hookEntryPath = fs.existsSync(sourceHookEntryPath)
+            ? sourceHookEntryPath
+            : path.join(MODULE_DIR, "claude-hook.js");
+        fs.writeFileSync(hookScriptPath, buildClaudeHookScript({
+            platform: process.platform,
+            runtimeExecPath: process.execPath,
+            hookEntryPath,
+            hookPort: this.hookPort,
+            hookToken: this.hookToken,
+        }), "utf8");
+        if (process.platform !== "win32") {
+            fs.chmodSync(hookScriptPath, 0o755);
+        }
+        const hookCommand = process.platform === "win32"
+            ? quoteWindowsCommandArg(hookScriptPath)
+            : quotePosixCommandArg(hookScriptPath);
+        fs.writeFileSync(settingsFilePath, JSON.stringify(buildClaudeHookSettings(hookCommand), null, 2), "utf8");
+        this.settingsFilePath = settingsFilePath;
+    }
+    attachLocalTerminal() {
+        if (this.localTerminalInputListener || !this.pty) {
+            return;
+        }
+        this.localTerminalInputListener = (chunk) => {
+            const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+            this.writeToPty(text);
+        };
+        process.stdin.on("data", this.localTerminalInputListener);
+        process.stdin.resume();
+        if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+            process.stdin.setRawMode(true);
+        }
+        this.resizeListener = () => {
+            this.resizePtyToTerminal();
+        };
+        if (process.stdout.isTTY) {
+            process.stdout.on("resize", this.resizeListener);
+        }
+    }
+    detachLocalTerminal() {
+        if (this.localTerminalInputListener) {
+            process.stdin.off("data", this.localTerminalInputListener);
+            this.localTerminalInputListener = null;
+        }
+        if (this.resizeListener) {
+            process.stdout.off("resize", this.resizeListener);
+            this.resizeListener = null;
+        }
+        if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+            process.stdin.setRawMode(false);
+        }
+    }
+    resizePtyToTerminal() {
+        if (!this.pty || !process.stdout.isTTY) {
+            return;
+        }
+        try {
+            this.pty.resize(process.stdout.columns || DEFAULT_COLS, process.stdout.rows || DEFAULT_ROWS);
+        }
+        catch {
+            // Best effort resize sync.
+        }
+    }
+    renderLocalOutput(rawText) {
+        try {
+            process.stdout.write(rawText);
+        }
+        catch {
+            // Best effort local mirroring for the visible Claude companion.
+        }
+    }
+    armWechatWorkingNotice() {
+        this.clearWechatWorkingNotice();
+        if (this.workingNoticeSent ||
+            !this.hasAcceptedInput ||
+            this.state.status !== "busy" ||
+            this.pendingApproval ||
+            this.state.activeTurnOrigin !== "wechat") {
+            return;
+        }
+        this.workingNoticeTimer = setTimeout(() => {
+            this.workingNoticeTimer = null;
+            if (this.workingNoticeSent ||
+                !this.hasAcceptedInput ||
+                this.state.status !== "busy" ||
+                this.pendingApproval ||
+                this.state.activeTurnOrigin !== "wechat") {
+                return;
+            }
+            this.workingNoticeSent = true;
+            this.emitClaudeNotice(`Claude is still working on:\n${this.currentPreview}`);
+        }, this.workingNoticeDelayMs);
+        this.workingNoticeTimer.unref?.();
+    }
+    clearWechatWorkingNotice(resetSent = false) {
+        if (this.workingNoticeTimer) {
+            clearTimeout(this.workingNoticeTimer);
+            this.workingNoticeTimer = null;
+        }
+        if (resetSent) {
+            this.workingNoticeSent = false;
+        }
+    }
+    emitClaudeNotice(text, level = "info") {
+        const normalized = normalizeOutput(text).trim();
+        if (!normalized) {
+            return;
+        }
+        this.state.lastOutputAt = nowIso();
+        this.emit({
+            type: "notice",
+            text: normalized,
+            level,
+            timestamp: nowIso(),
+        });
+    }
+    shouldTreatClaudeOutputAsCompactCompletion(text) {
+        if (this.state.status !== "busy" &&
+            this.state.status !== "awaiting_approval" &&
+            !this.hasAcceptedInput) {
+            return false;
+        }
+        return normalizeOutput(text)
+            .split("\n")
+            .some((line) => CLAUDE_COMPACT_OUTPUT_LINE_RE.test(line.trim()));
+    }
+    isCompactCommandActive() {
+        const preview = normalizeOutput(this.currentPreview).trim().toLowerCase();
+        return preview === "/compact" || preview.startsWith("/compact ");
+    }
+    extractClaudeCompactFailure(text) {
+        if (!this.isCompactCommandActive()) {
+            return null;
+        }
+        const matchedLine = normalizeOutput(text)
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .find((line) => CLAUDE_COMPACT_FAILURE_RE.test(line));
+        if (!matchedLine) {
+            return null;
+        }
+        const detail = matchedLine
+            .replace(/^Error:\s*Error during compaction:\s*/i, "")
+            .replace(/^Error:\s*/i, "")
+            .replace(/^(?:compact|compaction)\s+failed:\s*/i, "")
+            .trim();
+        return truncatePreview(`Compact failed: ${detail || "Claude reported an unknown compaction error."}`, 500);
+    }
+    failClaudeTurn(message) {
+        const hasActiveTurn = this.state.status === "busy" ||
+            this.state.status === "awaiting_approval" ||
+            this.hasAcceptedInput ||
+            this.pendingApproval !== null ||
+            this.state.activeTurnOrigin !== undefined ||
+            this.currentPreview !== "(idle)";
+        if (!hasActiveTurn) {
+            return;
+        }
+        this.clearCompletionTimer();
+        this.clearWechatWorkingNotice(true);
+        this.pendingCliApprovalHints = null;
+        this.flushPendingClaudeHookApprovals();
+        this.pendingApproval = null;
+        this.state.pendingApproval = null;
+        this.state.pendingApprovalOrigin = undefined;
+        this.state.activeTurnOrigin = undefined;
+        this.hasAcceptedInput = false;
+        this.setStatus("idle");
+        this.emit({
+            type: "task_failed",
+            message,
+            timestamp: nowIso(),
+        });
+        this.currentPreview = "(idle)";
+    }
+    completeClaudeCompact(params) {
+        const compactedAtMs = Date.now();
+        const shouldEmitNotice = compactedAtMs - this.lastCompactCompletionAtMs > CLAUDE_COMPACT_DEDUP_MS;
+        this.lastCompactCompletionAtMs = compactedAtMs;
+        if (shouldEmitNotice) {
+            const previousResumeConversationId = this.resumeConversationId;
+            const nextResumeConversationId = params?.nextResumeConversationId ?? previousResumeConversationId;
+            const detail = previousResumeConversationId &&
+                nextResumeConversationId &&
+                previousResumeConversationId !== nextResumeConversationId
+                ? ` Old ID: ${previousResumeConversationId} → New ID: ${nextResumeConversationId}.`
+                : "";
+            this.emitClaudeNotice(`Conversation was compacted.${detail} Bridge is ready for new WeChat messages.`, "info");
+        }
+        const shouldEmitTaskComplete = this.state.status === "busy" ||
+            this.state.status === "awaiting_approval" ||
+            this.hasAcceptedInput;
+        const completedPreview = this.currentPreview;
+        this.clearCompletionTimer();
+        this.clearWechatWorkingNotice(true);
+        this.pendingCliApprovalHints = null;
+        this.flushPendingClaudeHookApprovals();
+        this.pendingApproval = null;
+        this.state.pendingApproval = null;
+        this.state.pendingApprovalOrigin = undefined;
+        this.state.activeTurnOrigin = undefined;
+        this.hasAcceptedInput = false;
+        this.setStatus("idle");
+        if (shouldEmitTaskComplete) {
+            this.emit({
+                type: "task_complete",
+                summary: completedPreview,
+                timestamp: nowIso(),
+            });
+        }
+        this.currentPreview = "(idle)";
+    }
+    handleClaudeHookEnvelope(params) {
+        const payload = parseClaudeHookPayload(params.rawPayload);
+        if (!payload?.hook_event_name) {
+            this.respondToClaudeHook(params.socket, params.requestId);
+            return;
+        }
+        switch (payload.hook_event_name) {
+            case "SessionStart":
+                this.handleClaudeSessionStart(payload);
+                this.respondToClaudeHook(params.socket, params.requestId);
+                return;
+            case "UserPromptSubmit":
+                this.handleClaudeUserPromptSubmit(payload);
+                this.respondToClaudeHook(params.socket, params.requestId);
+                return;
+            case "PermissionRequest":
+                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.");
+                }
+                this.respondToClaudeHook(params.socket, params.requestId);
+                return;
+            case "Stop":
+                this.handleClaudeStop(payload);
+                this.respondToClaudeHook(params.socket, params.requestId);
+                return;
+            case "StopFailure":
+                this.handleClaudeStopFailure(payload);
+                this.respondToClaudeHook(params.socket, params.requestId);
+                return;
+            default:
+                this.respondToClaudeHook(params.socket, params.requestId);
+                return;
+        }
+    }
+    handleClaudeSessionStart(payload) {
+        if (!payload.session_id) {
+            return;
+        }
+        const previousRuntimeSessionId = this.runtimeSessionId;
+        const previousResumeConversationId = this.resumeConversationId;
+        const nextTranscriptPath = typeof payload.transcript_path === "string" && payload.transcript_path.trim()
+            ? payload.transcript_path.trim()
+            : null;
+        const nextResumeConversationId = extractClaudeResumeConversationId(nextTranscriptPath ?? undefined);
+        const compactedByTranscriptRotation = Boolean(this.transcriptPath) &&
+            Boolean(nextTranscriptPath) &&
+            this.transcriptPath !== nextTranscriptPath &&
+            (this.state.status === "busy" ||
+                this.state.status === "awaiting_approval" ||
+                this.hasAcceptedInput);
+        // Compact may keep the same runtime session id, so rely on the structured
+        // source when available and fall back to transcript rotation while a turn is active.
+        if (payload.source === "compact" ||
+            compactedByTranscriptRotation) {
+            this.completeClaudeCompact({
+                nextResumeConversationId,
+            });
+        }
+        this.runtimeSessionId = payload.session_id;
+        this.state.sharedSessionId = payload.session_id;
+        this.state.activeRuntimeSessionId = payload.session_id;
+        this.state.sharedThreadId = undefined;
+        this.resumeConversationId = nextResumeConversationId;
+        this.state.resumeConversationId = nextResumeConversationId ?? undefined;
+        this.transcriptPath = nextTranscriptPath;
+        this.state.transcriptPath = nextTranscriptPath ?? undefined;
+        if (previousRuntimeSessionId === payload.session_id) {
+            return;
+        }
+        const timestamp = nowIso();
+        const isRestore = !previousRuntimeSessionId &&
+            (payload.source === "resume" ||
+                (nextResumeConversationId !== null &&
+                    nextResumeConversationId === previousResumeConversationId));
+        const source = isRestore ? "restore" : "local";
+        const reason = isRestore ? "startup_restore" : "local_follow";
+        this.state.lastSessionSwitchAt = timestamp;
+        this.state.lastSessionSwitchSource = source;
+        this.state.lastSessionSwitchReason = reason;
+        this.emit({
+            type: "session_switched",
+            sessionId: payload.session_id,
+            source,
+            reason,
+            timestamp,
+        });
+    }
+    handleClaudeUserPromptSubmit(payload) {
+        const prompt = typeof payload.prompt === "string" ? normalizeOutput(payload.prompt).trim() : "";
+        if (!prompt) {
+            return;
+        }
+        const injectedIndex = findInjectedClaudePromptIndex(prompt, this.pendingInjectedInputs);
+        if (injectedIndex >= 0) {
+            this.pendingInjectedInputs.splice(injectedIndex, 1);
+            return;
+        }
+        this.hasAcceptedInput = true;
+        this.currentPreview = truncatePreview(prompt);
+        this.state.lastInputAt = nowIso();
+        this.state.activeTurnOrigin = "local";
+        this.pendingCliApprovalHints = null;
+        this.clearWechatWorkingNotice(true);
+        this.setStatus("busy");
+        this.emit({
+            type: "mirrored_user_input",
+            text: prompt,
+            origin: "local",
+            timestamp: nowIso(),
+        });
+    }
+    async recoverFromInvalidResume(failedResumeConversationId) {
+        if (this.recoveringInvalidResume) {
+            return;
+        }
+        this.recoveringInvalidResume = true;
+        this.clearWechatWorkingNotice(true);
+        this.pendingCliApprovalHints = null;
+        this.flushPendingClaudeHookApprovals();
+        this.pendingApproval = null;
+        this.state.pendingApproval = null;
+        this.state.pendingApprovalOrigin = undefined;
+        this.runtimeSessionId = null;
+        this.resumeConversationId = null;
+        this.transcriptPath = null;
+        this.state.sharedSessionId = undefined;
+        this.state.sharedThreadId = undefined;
+        this.state.activeRuntimeSessionId = undefined;
+        this.state.resumeConversationId = undefined;
+        this.state.transcriptPath = undefined;
+        this.state.lastSessionSwitchAt = undefined;
+        this.state.lastSessionSwitchSource = undefined;
+        this.state.lastSessionSwitchReason = undefined;
+        this.emitClaudeNotice(`Saved Claude conversation ${failedResumeConversationId} is no longer available. Starting a fresh Claude session.`, "warning");
+        try {
+            await super.reset();
+        }
+        finally {
+            this.recoveringInvalidResume = false;
+        }
+    }
+    handleClaudePermissionRequest(requestId, payload, socket) {
+        this.clearWechatWorkingNotice();
+        this.flushPendingClaudeHookApprovals();
+        this.pendingHookApprovals.set(requestId, {
+            requestId,
+            socket,
+        });
+        const request = buildClaudePermissionApprovalRequest(payload);
+        this.pendingApproval = {
+            ...request,
+            requestId,
+            confirmInput: this.pendingApproval?.confirmInput ?? this.pendingCliApprovalHints?.confirmInput,
+            denyInput: this.pendingApproval?.denyInput ?? this.pendingCliApprovalHints?.denyInput,
+        };
+        this.pendingCliApprovalHints = null;
+        this.state.pendingApproval = this.pendingApproval;
+        this.state.pendingApprovalOrigin = this.state.activeTurnOrigin;
+        this.setStatus("awaiting_approval", "Claude approval is required.");
+        this.emit({
+            type: "approval_required",
+            request: this.pendingApproval,
+            timestamp: nowIso(),
+        });
+    }
+    handleClosedClaudeHookApproval(requestId) {
+        if (this.pendingApproval?.requestId !== requestId) {
+            return;
+        }
+        if (this.pendingApproval.confirmInput || this.pendingApproval.denyInput) {
+            this.pendingApproval = {
+                ...this.pendingApproval,
+                requestId: undefined,
+            };
+            this.state.pendingApproval = this.pendingApproval;
+            return;
+        }
+        this.pendingApproval = null;
+        this.state.pendingApproval = null;
+        this.state.pendingApprovalOrigin = undefined;
+        if (this.state.status === "awaiting_approval") {
+            this.setStatus("awaiting_approval", "Claude approval must be resolved in the local terminal.");
+        }
+        this.emitClaudeNotice("Claude approval can no longer be resolved from WeChat. Approve it in the local Claude terminal.", "warning");
+    }
+    readClaudeTranscriptFinalReply() {
+        if (!this.transcriptPath) {
+            return null;
+        }
+        try {
+            const rawTranscript = fs.readFileSync(this.transcriptPath, "utf8");
+            return extractClaudeTranscriptFinalReply(rawTranscript);
+        }
+        catch {
+            return null;
+        }
+    }
+    resolveClaudeFinalReplyText(payload) {
+        return (extractClaudeAssistantMessageText(payload) ||
+            this.readClaudeTranscriptFinalReply() ||
+            normalizeClaudeAssistantMessage(payload));
+    }
+    handleClaudeStop(payload) {
+        this.clearWechatWorkingNotice(true);
+        this.pendingCliApprovalHints = null;
+        this.flushPendingClaudeHookApprovals();
+        this.pendingApproval = null;
+        this.state.pendingApproval = null;
+        this.state.pendingApprovalOrigin = undefined;
+        this.state.activeTurnOrigin = undefined;
+        this.hasAcceptedInput = false;
+        this.setStatus("idle");
+        this.emit({
+            type: "final_reply",
+            text: this.resolveClaudeFinalReplyText(payload),
+            timestamp: nowIso(),
+        });
+        this.emit({
+            type: "task_complete",
+            summary: this.currentPreview,
+            timestamp: nowIso(),
+        });
+        this.currentPreview = "(idle)";
+    }
+    handleClaudeStopFailure(payload) {
+        this.failClaudeTurn(buildClaudeFailureMessage(payload));
+    }
+    respondToClaudeHook(socket, requestId, stdout) {
+        try {
+            socket.end(`${JSON.stringify({ requestId, stdout })}\n`);
+        }
+        catch {
+            try {
+                socket.destroy();
+            }
+            catch {
+                // Best effort cleanup.
+            }
+        }
+    }
+    respondToClaudeHookApproval(requestId, action) {
+        const pending = this.pendingHookApprovals.get(requestId);
+        if (!pending) {
+            return false;
+        }
+        this.pendingHookApprovals.delete(requestId);
+        this.respondToClaudeHook(pending.socket, requestId, buildClaudePermissionDecisionHookOutput(action));
+        return true;
+    }
+    cancelPendingClaudeHookApproval(requestId) {
+        const pending = this.pendingHookApprovals.get(requestId);
+        if (!pending) {
+            return;
+        }
+        this.respondToClaudeHook(pending.socket, requestId);
+        this.pendingHookApprovals.delete(requestId);
+    }
+    flushPendingClaudeHookApprovals() {
+        for (const requestId of Array.from(this.pendingHookApprovals.keys())) {
+            this.cancelPendingClaudeHookApproval(requestId);
+        }
+    }
+}