cli-link 0.0.1

package/dist/server/cli-manager.js

@@ -0,0 +1,1532 @@
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+const DEFAULT_CLAUDE_CLI_ARGS = ['--dangerously-skip-permissions'];
+const DEFAULT_CODEX_CLI_ARGS = [
+    '--dangerously-bypass-approvals-and-sandbox',
+    '-m',
+    'gpt-5.5',
+    '-c',
+    'model_reasoning_effort="xhigh"',
+];
+const CONFIRM_PATTERNS = [
+    /\?\s*\[[yY]\/[nN]\]/,
+    /\(yes\/no\)/i,
+    /\(y\/n\)/i,
+    /allow.*\?/i,
+    /proceed.*\?/i,
+    /confirm.*\?/i,
+    /approve.*\?/i,
+    /\[Y\/n\]/,
+];
+const ANSI_REGEX = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?(?:\x07|\x1b\\)|\r/g;
+function stripAnsi(text) {
+    return text.replace(ANSI_REGEX, '');
+}
+const FILE_TOOLS = ['Write', 'Edit', 'MultiEdit', 'writeFile', 'editFile', 'readFile', 'Read'];
+const COMMAND_TOOLS = ['Bash', 'bash', 'Shell', 'shell', 'Exec', 'exec'];
+const ASK_USER_QUESTION_TOOL = 'AskUserQuestion';
+function inferCLIType(cliCommand) {
+    const command = cliCommand || '';
+    if (!command.trim())
+        return 'codex';
+    const name = command.split(/[\\/]/).pop()?.toLowerCase() || command.toLowerCase();
+    return name.includes('codex') ? 'codex' : 'claude';
+}
+function getDefaultCLIArgs(cliType) {
+    if (cliType === 'codex') {
+        return [...DEFAULT_CODEX_CLI_ARGS];
+    }
+    return [...DEFAULT_CLAUDE_CLI_ARGS];
+}
+function hasArg(args, shortName, longName) {
+    return args.some((arg) => arg === shortName || arg === longName || arg.startsWith(`${longName}=`));
+}
+function getToolCategory(toolName) {
+    if (FILE_TOOLS.includes(toolName))
+        return 'file';
+    if (COMMAND_TOOLS.includes(toolName))
+        return 'command';
+    return 'other';
+}
+export class CLIManager {
+    process = null;
+    printProcess = null;
+    _status = 'disconnected';
+    config = {
+        cliType: 'codex',
+        cliCommand: 'codex',
+        workDir: process.cwd(),
+        confirmMode: 'key',
+        cliArgs: getDefaultCLIArgs('codex'),
+        runMode: 'print',
+    };
+    onEvent = null;
+    stdoutBuffer = '';
+    stderrBuffer = '';
+    pendingOutput = '';
+    hasStreamedText = false;
+    sessionId = null;
+    allowedTools = new Set();
+    pendingDenials = [];
+    lastInput = '';
+    isRetrying = false;
+    pendingQuestionToolUseId = null;
+    pendingQuestionNeedsPermissionApproval = false;
+    answeredQuestionToolUseIds = new Set();
+    get status() {
+        return this._status;
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    restoreConfig(config) {
+        const nextType = config.cliType || inferCLIType(config.cliCommand);
+        const cliCommand = typeof config.cliCommand === 'string' && config.cliCommand.trim()
+            ? config.cliCommand
+            : nextType === 'codex'
+                ? 'codex'
+                : 'claude';
+        this.config = {
+            ...this.config,
+            cliType: nextType,
+            cliCommand,
+            workDir: typeof config.workDir === 'string' && config.workDir.trim() ? config.workDir : this.config.workDir,
+            cliArgs: Array.isArray(config.cliArgs) ? config.cliArgs : getDefaultCLIArgs(nextType),
+            confirmMode: config.confirmMode === 'auto' ? 'auto' : 'key',
+            runMode: config.runMode === 'interactive' ? 'interactive' : 'print',
+        };
+    }
+    setEventHandler(cb) {
+        this.onEvent = cb;
+    }
+    emit(event) {
+        this.onEvent?.(event);
+    }
+    now() {
+        return new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    }
+    getCLIType() {
+        return this.config.cliType || inferCLIType(this.config.cliCommand);
+    }
+    getCLILabel() {
+        return this.getCLIType() === 'codex' ? 'Codex CLI' : 'Claude CLI';
+    }
+    start(config, onEvent) {
+        this.onEvent = onEvent;
+        const filtered = Object.fromEntries(Object.entries(config).filter(([_, v]) => v !== undefined));
+        const nextConfig = { ...this.config, ...filtered };
+        const nextType = filtered.cliType || inferCLIType(nextConfig.cliCommand);
+        const typeChanged = nextType !== this.config.cliType;
+        this.config = {
+            ...nextConfig,
+            cliType: nextType,
+            cliArgs: Array.isArray(filtered.cliArgs)
+                ? filtered.cliArgs
+                : typeChanged
+                    ? getDefaultCLIArgs(nextType)
+                    : nextConfig.cliArgs,
+        };
+        console.log(`[CLI] start called, clearing sessionId (was: ${this.sessionId?.slice(0, 8) || 'null'})`);
+        this.sessionId = null;
+        this.pendingQuestionToolUseId = null;
+        this.pendingQuestionNeedsPermissionApproval = false;
+        this.answeredQuestionToolUseIds.clear();
+        if (this.config.runMode === 'interactive') {
+            this.spawnInteractive();
+        }
+        else {
+            this._status = 'idle';
+            this.emit({ type: 'status', status: 'idle' });
+            this.emit({ type: 'system', content: `${this.getCLILabel()} 就绪 (print 模式)`, time: this.now() });
+        }
+    }
+    spawnInteractive() {
+        this.killProcess();
+        this.stdoutBuffer = '';
+        this.stderrBuffer = '';
+        this.pendingOutput = '';
+        const args = [...(this.config.cliArgs || [])];
+        if (this.getCLIType() === 'codex') {
+            if (!hasArg(args, '-C', '--cd')) {
+                args.push('-C', this.config.workDir);
+            }
+            args.push('--no-alt-screen');
+        }
+        try {
+            this.process = spawn(this.config.cliCommand, args, {
+                cwd: this.config.workDir,
+                env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1', TERM: 'dumb' },
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch (err) {
+            this.emit({ type: 'error', content: `CLI 启动失败: ${err.message}`, time: this.now() });
+            this._status = 'disconnected';
+            this.emit({ type: 'status', status: 'disconnected' });
+            return;
+        }
+        this._status = 'idle';
+        this.emit({ type: 'status', status: 'idle' });
+        this.emit({ type: 'system', content: 'CLI 进程已启动 (交互模式)', time: this.now() });
+        this.process.stdout.on('data', (data) => {
+            this.handleStdout(data.toString());
+        });
+        this.process.stderr.on('data', (data) => {
+            const text = stripAnsi(data.toString());
+            this.stderrBuffer += text;
+            const lines = this.stderrBuffer.split('\n');
+            this.stderrBuffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    this.emit({ type: 'error', content: trimmed, time: this.now() });
+                }
+            }
+        });
+        this.process.on('close', (code) => {
+            this.flushPendingOutput();
+            this._status = 'disconnected';
+            this.emit({ type: 'status', status: 'disconnected' });
+            this.emit({ type: 'system', content: `CLI 进程已退出 (code: ${code})`, time: this.now() });
+            this.process = null;
+        });
+        this.process.on('error', (err) => {
+            this.emit({ type: 'error', content: `CLI 错误: ${err.message}`, time: this.now() });
+            this._status = 'disconnected';
+            this.emit({ type: 'status', status: 'disconnected' });
+            this.process = null;
+        });
+    }
+    buildPrintArgs(input) {
+        if (this.getCLIType() === 'codex') {
+            return this.buildCodexPrintArgs(input);
+        }
+        return this.buildClaudePrintArgs(input);
+    }
+    buildClaudePrintArgs(input) {
+        const args = [];
+        const cliArgs = this.config.cliArgs || [];
+        args.push(...cliArgs);
+        if (this.sessionId) {
+            args.push('--resume', this.sessionId);
+        }
+        args.push('-p', input, '--output-format', 'stream-json', '--verbose');
+        const allowedTools = new Set(this.allowedTools);
+        allowedTools.add(ASK_USER_QUESTION_TOOL);
+        if (allowedTools.size > 0) {
+            args.push('--allowedTools', Array.from(allowedTools).join(','));
+        }
+        return args;
+    }
+    buildCodexPrintArgs(_input) {
+        const args = [...(this.config.cliArgs || [])];
+        if (!hasArg(args, '-C', '--cd')) {
+            args.push('-C', this.config.workDir);
+        }
+        args.push('exec');
+        if (this.sessionId) {
+            args.push('resume', '--json', this.sessionId, '-');
+        }
+        else {
+            args.push('--json', '-');
+        }
+        return args;
+    }
+    buildIsolatedPrintArgs(input) {
+        if (this.getCLIType() === 'codex') {
+            const args = [...(this.config.cliArgs || [])];
+            if (!hasArg(args, '-C', '--cd')) {
+                args.push('-C', this.config.workDir);
+            }
+            args.push('exec', '--json', '-');
+            return { args, stdin: input };
+        }
+        const args = [...(this.config.cliArgs || [])];
+        args.push('-p', input, '--output-format', 'stream-json', '--verbose');
+        return { args };
+    }
+    extractOneShotText(msg) {
+        const type = msg?.type;
+        if (type === 'item.completed') {
+            const item = msg.item || {};
+            const itemType = item.type || '';
+            const isAgentMessage = itemType === 'agent_message' ||
+                itemType === 'assistant_message' ||
+                (itemType === 'message' && item.role === 'assistant');
+            return isAgentMessage ? this.extractText(item.text || item.content || item.message || item) : '';
+        }
+        if (type === 'assistant') {
+            return this.extractText(msg.message || msg.content || msg);
+        }
+        if (type === 'text') {
+            return this.extractText(msg.text || msg.content || msg.message);
+        }
+        if (type === 'content_block_delta') {
+            return this.extractText(msg.delta);
+        }
+        if (type === 'result' || type === 'done' || type === 'complete') {
+            return this.extractText(msg.content || msg.message || msg.result);
+        }
+        return '';
+    }
+    extractOneShotError(msg) {
+        if (!msg || typeof msg !== 'object')
+            return '';
+        if (msg.type !== 'error' && msg.type !== 'turn.failed')
+            return '';
+        return this.extractText(msg.error || msg.message || msg.content) || `${this.getCLILabel()} 执行失败`;
+    }
+    runOneShot(input, timeoutMs = 120000) {
+        const { args, stdin } = this.buildIsolatedPrintArgs(input);
+        const cliType = this.getCLIType();
+        const cliLabel = this.getCLILabel();
+        return new Promise((resolve, reject) => {
+            let proc;
+            try {
+                proc = spawn(this.config.cliCommand, args, {
+                    cwd: this.config.workDir,
+                    env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+            catch (err) {
+                reject(new Error(`${cliLabel} 启动失败: ${err.message}`));
+                return;
+            }
+            const texts = [];
+            const errors = [];
+            let stdoutBuf = '';
+            let stderrBuf = '';
+            let settled = false;
+            const finish = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                fn();
+            };
+            const consumeLine = (line) => {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    return;
+                try {
+                    const json = JSON.parse(trimmed);
+                    const errorText = this.extractOneShotError(json);
+                    if (errorText)
+                        errors.push(errorText);
+                    const text = this.extractOneShotText(json);
+                    if (text)
+                        texts.push(text);
+                }
+                catch {
+                    if (cliType !== 'codex')
+                        texts.push(trimmed);
+                }
+            };
+            const flushStdout = () => {
+                if (!stdoutBuf.trim())
+                    return;
+                const remaining = stdoutBuf;
+                stdoutBuf = '';
+                consumeLine(remaining);
+            };
+            const timer = setTimeout(() => {
+                try {
+                    proc.kill('SIGTERM');
+                }
+                catch { }
+                finish(() => reject(new Error(`${cliLabel} 生成超时`)));
+            }, timeoutMs);
+            proc.stdout?.on('data', (data) => {
+                stdoutBuf += data.toString();
+                const lines = stdoutBuf.split('\n');
+                stdoutBuf = lines.pop() || '';
+                for (const line of lines) {
+                    consumeLine(line);
+                }
+            });
+            proc.stderr?.on('data', (data) => {
+                stderrBuf += stripAnsi(data.toString());
+            });
+            proc.on('close', (code) => {
+                flushStdout();
+                const text = texts.filter(Boolean).slice(-1)[0]?.trim() || texts.filter(Boolean).join('\n').trim();
+                if (code !== 0 && !text) {
+                    const detail = errors[0] || stderrBuf.trim() || `${cliLabel} 退出码 ${code}`;
+                    finish(() => reject(new Error(detail)));
+                    return;
+                }
+                if (!text) {
+                    const detail = errors[0] || stderrBuf.trim() || `${cliLabel} 未返回内容`;
+                    finish(() => reject(new Error(detail)));
+                    return;
+                }
+                finish(() => resolve(text));
+            });
+            proc.on('error', (err) => {
+                finish(() => reject(new Error(`${cliLabel} 执行错误: ${err.message}`)));
+            });
+            if (stdin != null) {
+                proc.stdin?.end(stdin);
+            }
+            else {
+                proc.stdin?.end();
+            }
+        });
+    }
+    getPrintStdio() {
+        return ['pipe', 'pipe', 'pipe'];
+    }
+    writePromptToStdin(proc, input) {
+        if (this.getCLIType() !== 'codex')
+            return;
+        proc.stdin?.end(input);
+    }
+    runPrintCommand(input, isRetry = false) {
+        this._status = 'running';
+        this.pendingDenials = [];
+        this.hasStreamedText = false;
+        this.isRetrying = isRetry;
+        if (!isRetry) {
+            this.lastInput = input;
+        }
+        this.emit({ type: 'status', status: 'running' });
+        const args = this.buildPrintArgs(input);
+        console.log(`[CLI] runPrintCommand: sessionId=${this.sessionId?.slice(0, 8) || 'null'}, resume=${!!this.sessionId}, args=${args.join(' ')}`);
+        let localBuf = '';
+        let stderrBuf = '';
+        let hasStructuredError = false;
+        try {
+            const proc = spawn(this.config.cliCommand, args, {
+                cwd: this.config.workDir,
+                env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },
+                stdio: this.getPrintStdio(),
+            });
+            this.printProcess = proc;
+            this.writePromptToStdin(proc, input);
+            proc.stdout.on('data', (data) => {
+                localBuf += data.toString();
+                const lines = localBuf.split('\n');
+                localBuf = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    try {
+                        const json = JSON.parse(trimmed);
+                        if (json?.type === 'error' || json?.type === 'turn.failed') {
+                            hasStructuredError = true;
+                        }
+                        this.handleJSONMessage(json);
+                        if (this._status === 'question')
+                            return;
+                    }
+                    catch { }
+                }
+            });
+            proc.stderr.on('data', (data) => {
+                stderrBuf += stripAnsi(data.toString());
+            });
+            proc.on('close', (code) => {
+                this.printProcess = null;
+                if (this._status !== 'question' && localBuf.trim()) {
+                    try {
+                        const json = JSON.parse(localBuf.trim());
+                        if (json?.type === 'error' || json?.type === 'turn.failed') {
+                            hasStructuredError = true;
+                        }
+                        this.handleJSONMessage(json);
+                    }
+                    catch { }
+                }
+                if (this._status !== 'question' && code !== 0 && stderrBuf.trim() && !hasStructuredError) {
+                    const errLines = stderrBuf.trim().split('\n').filter(l => l.trim());
+                    for (const line of errLines) {
+                        this.emit({ type: 'error', content: line.trim(), time: this.now() });
+                    }
+                }
+                if (this._status !== 'confirm' && this._status !== 'question') {
+                    this._status = 'idle';
+                    this.emit({ type: 'status', status: 'idle' });
+                }
+                this.isRetrying = false;
+            });
+            proc.on('error', (err) => {
+                this.printProcess = null;
+                this.emit({ type: 'error', content: `CLI 执行错误: ${err.message}`, time: this.now() });
+                this._status = 'idle';
+                this.emit({ type: 'status', status: 'idle' });
+                this.isRetrying = false;
+            });
+        }
+        catch (err) {
+            this.emit({ type: 'error', content: `CLI 启动失败: ${err.message}`, time: this.now() });
+            this._status = 'idle';
+            this.emit({ type: 'status', status: 'idle' });
+            this.isRetrying = false;
+        }
+    }
+    retryWithPermission() {
+        if (!this.sessionId) {
+            this.emit({ type: 'error', content: '无法重试: 没有活跃的会话', time: this.now() });
+            this._status = 'idle';
+            this.emit({ type: 'status', status: 'idle' });
+            return;
+        }
+        this._status = 'running';
+        this.pendingDenials = [];
+        this.hasStreamedText = false;
+        this.isRetrying = true;
+        this.emit({ type: 'status', status: 'running' });
+        this.emit({ type: 'system', content: `正在恢复会话并重试 (已授权: ${Array.from(this.allowedTools).join(', ')})...`, time: this.now() });
+        const retryInput = '请继续之前的操作，现在已经有权限了，请重新执行之前被拒绝的步骤。';
+        const args = this.buildPrintArgs(retryInput);
+        let localBuf = '';
+        let stderrBuf = '';
+        let hasStructuredError = false;
+        try {
+            const proc = spawn(this.config.cliCommand, args, {
+                cwd: this.config.workDir,
+                env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },
+                stdio: this.getPrintStdio(),
+            });
+            this.printProcess = proc;
+            this.writePromptToStdin(proc, retryInput);
+            proc.stdout.on('data', (data) => {
+                localBuf += data.toString();
+                const lines = localBuf.split('\n');
+                localBuf = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    try {
+                        const json = JSON.parse(trimmed);
+                        if (json?.type === 'error' || json?.type === 'turn.failed') {
+                            hasStructuredError = true;
+                        }
+                        this.handleJSONMessage(json);
+                        if (this._status === 'question')
+                            return;
+                    }
+                    catch { }
+                }
+            });
+            proc.stderr.on('data', (data) => {
+                stderrBuf += stripAnsi(data.toString());
+            });
+            proc.on('close', (code) => {
+                this.printProcess = null;
+                if (this._status !== 'question' && localBuf.trim()) {
+                    try {
+                        const json = JSON.parse(localBuf.trim());
+                        if (json?.type === 'error' || json?.type === 'turn.failed') {
+                            hasStructuredError = true;
+                        }
+                        this.handleJSONMessage(json);
+                    }
+                    catch { }
+                }
+                if (this._status !== 'question' && code !== 0 && stderrBuf.trim() && !hasStructuredError) {
+                    const errLines = stderrBuf.trim().split('\n').filter(l => l.trim());
+                    for (const line of errLines) {
+                        this.emit({ type: 'error', content: line.trim(), time: this.now() });
+                    }
+                }
+                if (this._status !== 'confirm' && this._status !== 'question') {
+                    this._status = 'idle';
+                    this.emit({ type: 'status', status: 'idle' });
+                }
+                this.isRetrying = false;
+            });
+            proc.on('error', (err) => {
+                this.printProcess = null;
+                this.emit({ type: 'error', content: `CLI 执行错误: ${err.message}`, time: this.now() });
+                this._status = 'idle';
+                this.emit({ type: 'status', status: 'idle' });
+                this.isRetrying = false;
+            });
+        }
+        catch (err) {
+            this.emit({ type: 'error', content: `CLI 启动失败: ${err.message}`, time: this.now() });
+            this._status = 'idle';
+            this.emit({ type: 'status', status: 'idle' });
+            this.isRetrying = false;
+        }
+    }
+    handleStdout(data) {
+        const clean = stripAnsi(data);
+        this.stdoutBuffer += clean;
+        const lines = this.stdoutBuffer.split('\n');
+        this.stdoutBuffer = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            this.processLine(trimmed);
+        }
+    }
+    processLine(line) {
+        try {
+            const json = JSON.parse(line);
+            this.handleJSONMessage(json);
+            return;
+        }
+        catch { }
+        if (this.isPromptLine(line)) {
+            this.flushPendingOutput();
+            this._status = 'idle';
+            this.emit({ type: 'status', status: 'idle' });
+            return;
+        }
+        if (CONFIRM_PATTERNS.some((p) => p.test(line))) {
+            this.flushPendingOutput();
+            this.handleConfirmation({ promptText: line });
+            return;
+        }
+        this.pendingOutput += (this.pendingOutput ? '\n' : '') + line;
+    }
+    isPromptLine(line) {
+        return /^\s*>\s*$/.test(line) ||
+            /^\s*›\s*$/.test(line) ||
+            /^\s*\$\s*$/.test(line);
+    }
+    flushPendingOutput() {
+        if (!this.pendingOutput.trim())
+            return;
+        const text = this.pendingOutput.trim();
+        this.pendingOutput = '';
+        if (this._status === 'idle' || this._status === 'running') {
+            this._status = 'running';
+            this.emit({ type: 'status', status: 'running' });
+            this.emit({ type: 'ai_message', content: text, time: this.now() });
+        }
+    }
+    tryParseJSON(val) {
+        if (typeof val !== 'string')
+            return null;
+        try {
+            const parsed = JSON.parse(val);
+            if (typeof parsed === 'object' && parsed !== null)
+                return parsed;
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    extractText(val) {
+        if (typeof val === 'string')
+            return val;
+        if (val == null)
+            return '';
+        if (Array.isArray(val)) {
+            return val
+                .map((block) => {
+                if (typeof block === 'string')
+                    return block;
+                if (block?.type === 'text' && typeof block.text === 'string')
+                    return block.text;
+                if (typeof block?.text === 'string')
+                    return block.text;
+                if (typeof block?.content === 'string')
+                    return block.content;
+                return '';
+            })
+                .filter(Boolean)
+                .join('\n');
+        }
+        if (typeof val === 'object') {
+            if (Array.isArray(val.content)) {
+                return this.extractText(val.content);
+            }
+            if (typeof val.text === 'string')
+                return val.text;
+            if (typeof val.message === 'string')
+                return val.message;
+            if (typeof val.content === 'string')
+                return val.content;
+            return '';
+        }
+        return String(val);
+    }
+    normalizeQuestionOptions(options) {
+        if (!Array.isArray(options))
+            return [];
+        return options
+            .map((opt) => {
+            if (typeof opt === 'string')
+                return { label: opt };
+            if (!opt || typeof opt !== 'object')
+                return null;
+            const label = typeof opt.label === 'string' ? opt.label : '';
+            if (!label)
+                return null;
+            return {
+                label,
+                description: typeof opt.description === 'string' ? opt.description : undefined,
+                markdown: typeof opt.markdown === 'string' ? opt.markdown : undefined,
+            };
+        })
+            .filter(Boolean);
+    }
+    normalizeAskUserQuestions(input) {
+        if (!input || typeof input !== 'object')
+            return [];
+        if (Array.isArray(input.questions)) {
+            return input.questions
+                .map((q) => {
+                if (typeof q === 'string') {
+                    return { question: q, options: [] };
+                }
+                if (!q || typeof q !== 'object')
+                    return null;
+                const question = typeof q.question === 'string' ? q.question : '';
+                if (!question)
+                    return null;
+                return {
+                    question,
+                    header: typeof q.header === 'string' ? q.header : undefined,
+                    options: this.normalizeQuestionOptions(q.options),
+                    multiSelect: !!q.multiSelect,
+                };
+            })
+                .filter(Boolean);
+        }
+        if (typeof input.question === 'string' && input.question) {
+            return [{
+                    question: input.question,
+                    header: typeof input.header === 'string' ? input.header : undefined,
+                    options: this.normalizeQuestionOptions(input.options),
+                    multiSelect: !!input.multiSelect,
+                }];
+        }
+        return [];
+    }
+    isAskUserQuestionTool(toolName) {
+        return typeof toolName === 'string' && toolName === ASK_USER_QUESTION_TOOL;
+    }
+    isPermissionDenial(details) {
+        return /requested permissions/i.test(details);
+    }
+    shouldIgnoreAskUserQuestionDenial(toolName, toolUseId) {
+        return this.isAskUserQuestionTool(toolName) ||
+            (!!toolUseId && !!this.pendingQuestionToolUseId && toolUseId === this.pendingQuestionToolUseId);
+    }
+    buildQuestionAnswerPrompt(answer) {
+        return [
+            '用户刚刚回答了你通过 AskUserQuestion 提出的问题。',
+            '请将下面内容作为该问题的用户答案，并继续之前的任务。',
+            '',
+            `用户回答：${answer}`,
+        ].join('\n');
+    }
+    pausePrintProcessForQuestion() {
+        if (this.config.runMode !== 'print' || !this.printProcess)
+            return;
+        const proc = this.printProcess;
+        this.printProcess = null;
+        try {
+            proc.kill('SIGINT');
+        }
+        catch { }
+    }
+    emitCodexUsage(usage) {
+        if (!usage || typeof usage !== 'object')
+            return;
+        const resultDetails = { subtype: 'result' };
+        if (usage.input_tokens != null)
+            resultDetails.inputTokens = usage.input_tokens;
+        if (usage.output_tokens != null)
+            resultDetails.outputTokens = usage.output_tokens;
+        if (usage.cached_input_tokens != null)
+            resultDetails.cacheReadTokens = usage.cached_input_tokens;
+        if (usage.reasoning_output_tokens != null)
+            resultDetails.reasoningOutputTokens = usage.reasoning_output_tokens;
+        if (this.sessionId)
+            resultDetails.session_id = this.sessionId;
+        if (Object.keys(resultDetails).length > 1) {
+            this.emit({ type: 'system', content: '执行完成', time: this.now(), details: resultDetails });
+        }
+    }
+    handleCodexJSONMessage(msg) {
+        const type = msg.type;
+        if (type === 'thread.started') {
+            const threadId = msg.thread_id || msg.threadId;
+            if (threadId && typeof threadId === 'string') {
+                this.sessionId = threadId;
+                console.log(`[CLI] Codex threadId set: ${threadId.slice(0, 8)}...`);
+                this.emit({
+                    type: 'system',
+                    content: `Codex CLI 已初始化 (thread: ${threadId.slice(0, 8)}...)`,
+                    time: this.now(),
+                    details: { subtype: 'init', session_id: threadId },
+                });
+            }
+            return true;
+        }
+        if (type === 'turn.started') {
+            this._status = 'running';
+            this.emit({ type: 'status', status: 'running' });
+            return true;
+        }
+        if (type === 'turn.completed') {
+            this.emitCodexUsage(msg.usage);
+            if (this._status !== 'confirm' && this._status !== 'question') {
+                this._status = 'idle';
+                this.emit({ type: 'status', status: 'idle' });
+            }
+            this.hasStreamedText = false;
+            return true;
+        }
+        if (type === 'turn.failed' || type === 'error') {
+            const errorText = this.extractText(msg.error || msg.message || msg.content) || 'Codex CLI 执行失败';
+            this.emit({ type: 'error', content: errorText, time: this.now() });
+            if (this._status !== 'confirm' && this._status !== 'question') {
+                this._status = 'idle';
+                this.emit({ type: 'status', status: 'idle' });
+            }
+            return true;
+        }
+        if (type === 'item.started' || type === 'item.completed') {
+            const item = msg.item || {};
+            const itemType = item.type || 'item';
+            const itemId = item.id || undefined;
+            const isCompleted = type === 'item.completed';
+            if (itemType === 'command_execution') {
+                const command = item.command || 'command';
+                const output = item.aggregated_output || '';
+                const exitCode = item.exit_code;
+                const status = isCompleted
+                    ? exitCode === 0 ? 'success' : 'failed'
+                    : 'running';
+                const details = isCompleted
+                    ? output || (exitCode != null ? `exit code: ${exitCode}` : undefined)
+                    : command;
+                this.emit({
+                    type: 'tool_call',
+                    content: command,
+                    toolName: 'Shell',
+                    status,
+                    details,
+                    toolUseId: itemId,
+                    time: this.now(),
+                });
+                return true;
+            }
+            const isAgentMessage = itemType === 'agent_message' ||
+                itemType === 'assistant_message' ||
+                (itemType === 'message' && item.role === 'assistant');
+            if (isCompleted && isAgentMessage) {
+                const text = this.extractText(item.text || item.content || item.message || item);
+                if (text) {
+                    this.hasStreamedText = true;
+                    this.emit({ type: 'ai_message', content: text, time: this.now() });
+                }
+                return true;
+            }
+            if (isCompleted && (itemType === 'reasoning' || itemType === 'thinking')) {
+                const text = this.extractText(item.text || item.content || item.message);
+                if (text) {
+                    this.emit({ type: 'thinking_message', content: text, time: this.now() });
+                }
+                return true;
+            }
+            return true;
+        }
+        return typeof type === 'string' && type.includes('.');
+    }
+    handleJSONMessage(msg) {
+        if (this.getCLIType() === 'codex' && this.handleCodexJSONMessage(msg)) {
+            return;
+        }
+        const type = msg.type;
+        if (type === 'system') {
+            const inner = this.tryParseJSON(msg.content) || msg;
+            const sid = msg.session_id || inner.session_id || msg.id || inner.id;
+            if (sid && typeof sid === 'string' && sid.length > 8) {
+                this.sessionId = sid;
+                console.log(`[CLI] sessionId set from system message: ${this.sessionId.slice(0, 8)}...`);
+            }
+            if (inner.subtype === 'init') {
+                const model = inner.model || msg.model || '';
+                const toolsCount = Array.isArray(inner.tools) ? inner.tools.length : 0;
+                const initDetails = { subtype: 'init' };
+                if (model)
+                    initDetails.model = model;
+                if (inner.session_id)
+                    initDetails.session_id = inner.session_id;
+                if (toolsCount)
+                    initDetails.toolsCount = toolsCount;
+                if (this.isRetrying) {
+                    this.emit({ type: 'system', content: `会话已恢复 (session: ${inner.session_id?.slice(0, 8)}...)`, time: this.now(), details: initDetails });
+                }
+                else {
+                    this.emit({ type: 'system', content: `CLI 已初始化 (session: ${inner.session_id?.slice(0, 8)}...)`, time: this.now(), details: initDetails });
+                }
+            }
+            else {
+                const text = this.extractText(msg.message || inner.message || inner.content) || '';
+                const sysDetails = {};
+                const sysUsage = inner.usage || {};
+                if (inner.subtype)
+                    sysDetails.subtype = inner.subtype;
+                if (inner.model)
+                    sysDetails.model = inner.model;
+                if (inner.session_id)
+                    sysDetails.session_id = inner.session_id;
+                if (Array.isArray(inner.tools))
+                    sysDetails.toolsCount = inner.tools.length;
+                if (inner.total_cost_usd != null)
+                    sysDetails.costUsd = inner.total_cost_usd;
+                else if (inner.cost_usd != null)
+                    sysDetails.costUsd = inner.cost_usd;
+                if (inner.duration_ms != null)
+                    sysDetails.durationMs = inner.duration_ms;
+                if (inner.num_turns != null)
+                    sysDetails.numTurns = inner.num_turns;
+                if (sysUsage.input_tokens != null)
+                    sysDetails.inputTokens = sysUsage.input_tokens;
+                else if (inner.input_tokens != null)
+                    sysDetails.inputTokens = inner.input_tokens;
+                if (sysUsage.output_tokens != null)
+                    sysDetails.outputTokens = sysUsage.output_tokens;
+                else if (inner.output_tokens != null)
+                    sysDetails.outputTokens = inner.output_tokens;
+                if (sysUsage.cache_read_input_tokens != null)
+                    sysDetails.cacheReadTokens = sysUsage.cache_read_input_tokens;
+                if (sysUsage.cache_creation_input_tokens != null)
+                    sysDetails.cacheCreationTokens = sysUsage.cache_creation_input_tokens;
+                // Generate meaningful content when extractText returns empty
+                let content = text;
+                if (!content) {
+                    const subtype = inner.subtype;
+                    if (subtype === 'result') {
+                        content = '执行完成';
+                    }
+                    else if (subtype === 'init') {
+                        content = `CLI 已初始化 (session: ${inner.session_id?.slice(0, 8)}...)`;
+                    }
+                    else if (subtype) {
+                        const subtypeLabels = {
+                            'status': '状态更新',
+                            'error': '系统错误',
+                            'warning': '系统警告',
+                            'info': '系统通知',
+                        };
+                        content = subtypeLabels[subtype] || `系统事件: ${subtype}`;
+                    }
+                    else {
+                        // No subtype, no text — try to describe from details
+                        const parts = [];
+                        if (inner.model)
+                            parts.push(`模型 ${inner.model}`);
+                        if (sysDetails.toolsCount)
+                            parts.push(`${sysDetails.toolsCount} 个工具`);
+                        if (inner.session_id)
+                            parts.push(`session ${String(inner.session_id).slice(0, 8)}...`);
+                        content = parts.length > 0 ? parts.join(' · ') : '系统消息';
+                    }
+                }
+                this.emit({ type: 'system', content, time: this.now(), details: Object.keys(sysDetails).length > 0 ? sysDetails : undefined });
+            }
+        }
+        else if (type === 'assistant' || type === 'text' || type === 'content_block_delta') {
+            this._status = 'running';
+            this.emit({ type: 'status', status: 'running' });
+            if (type === 'content_block_delta' && msg.delta) {
+                if (msg.delta.type === 'thinking_delta' && msg.delta.thinking) {
+                    this.emit({ type: 'thinking_message', content: msg.delta.thinking, time: this.now() });
+                }
+                else {
+                    const text = this.extractText(msg.delta);
+                    if (text) {
+                        this.hasStreamedText = true;
+                        this.emit({ type: 'ai_message', content: text, time: this.now() });
+                    }
+                }
+            }
+            else {
+                const message = msg.message || msg;
+                const contentArr = Array.isArray(message.content) ? message.content : null;
+                if (contentArr) {
+                    for (const block of contentArr) {
+                        if (block.type === 'tool_use') {
+                            this.emit({
+                                type: 'tool_call',
+                                content: block.name || 'tool',
+                                toolName: block.name || 'unknown',
+                                status: 'running',
+                                details: block.input ? JSON.stringify(block.input, null, 2) : undefined,
+                                toolUseId: block.id || undefined,
+                                time: this.now(),
+                            });
+                            // Detect AskUserQuestion tool and present to user
+                            if (block.name === 'AskUserQuestion' && block.input) {
+                                this.handleAskUserQuestion(block.name, block.input, block.id);
+                                return;
+                            }
+                        }
+                        else if (block.type === 'text') {
+                            if (block.text) {
+                                this.hasStreamedText = true;
+                                this.emit({ type: 'ai_message', content: block.text, time: this.now() });
+                            }
+                        }
+                        else if (block.type === 'thinking') {
+                            if (block.thinking) {
+                                this.emit({ type: 'thinking_message', content: block.thinking, time: this.now() });
+                            }
+                        }
+                    }
+                }
+                else {
+                    const text = this.extractText(msg.content || msg.message || msg.text);
+                    if (text) {
+                        this.hasStreamedText = true;
+                        this.emit({ type: 'ai_message', content: text, time: this.now() });
+                    }
+                }
+            }
+        }
+        else if (type === 'content_block_start') {
+            if (msg.content_block?.type === 'tool_use') {
+                this._status = 'running';
+                this.emit({ type: 'status', status: 'running' });
+                this.emit({
+                    type: 'tool_call',
+                    content: msg.content_block.name || 'tool',
+                    toolName: msg.content_block.name || 'unknown',
+                    status: 'running',
+                    details: msg.content_block.input ? JSON.stringify(msg.content_block.input, null, 2) : undefined,
+                    toolUseId: msg.content_block.id || undefined,
+                    time: this.now(),
+                });
+                // Detect AskUserQuestion tool and present to user
+                if (msg.content_block.name === 'AskUserQuestion' && msg.content_block.input) {
+                    this.handleAskUserQuestion(msg.content_block.name, msg.content_block.input, msg.content_block.id);
+                    return;
+                }
+            }
+        }
+        else if (type === 'content_block_stop') {
+            // block ended
+        }
+        else if (type === 'tool_use' || type === 'tool') {
+            this._status = 'running';
+            this.emit({ type: 'status', status: 'running' });
+            this.emit({
+                type: 'tool_call',
+                content: msg.name || 'tool',
+                toolName: msg.name || 'unknown',
+                status: 'running',
+                details: msg.input ? JSON.stringify(msg.input, null, 2) : undefined,
+                toolUseId: msg.id || undefined,
+                time: this.now(),
+            });
+            // Detect AskUserQuestion tool and present to user
+            if (msg.name === 'AskUserQuestion' && msg.input) {
+                this.handleAskUserQuestion(msg.name, msg.input, msg.id);
+                return;
+            }
+        }
+        else if (type === 'user') {
+            const message = msg.message || msg;
+            const contentArr = Array.isArray(message.content) ? message.content : null;
+            if (contentArr) {
+                for (const block of contentArr) {
+                    if (block.type === 'tool_result') {
+                        if (block.tool_use_id && this.answeredQuestionToolUseIds.has(block.tool_use_id)) {
+                            continue;
+                        }
+                        const isError = block.is_error || false;
+                        const details = typeof block.content === 'string' ? block.content : this.extractText(block.content);
+                        if (isError && details && this.isPermissionDenial(details)) {
+                            const toolName = this.extractToolNameFromDenial(details);
+                            if (this.shouldIgnoreAskUserQuestionDenial(toolName, block.tool_use_id)) {
+                                continue;
+                            }
+                            const category = getToolCategory(toolName);
+                            this.pendingDenials.push({
+                                toolName,
+                                category,
+                                toolUseId: block.tool_use_id,
+                                input: msg.tool_input || {},
+                                description: details,
+                            });
+                            this.emit({
+                                type: 'tool_call',
+                                content: `权限被拒绝: ${toolName}`,
+                                toolName,
+                                status: 'failed',
+                                details,
+                                toolUseId: block.tool_use_id || undefined,
+                                time: this.now(),
+                            });
+                        }
+                        else {
+                            this.emit({
+                                type: 'tool_call',
+                                content: isError ? '工具执行失败' : '工具执行完成',
+                                toolName: block.tool_use_id || 'result',
+                                status: isError ? 'failed' : 'success',
+                                details: details || undefined,
+                                toolUseId: block.tool_use_id || undefined,
+                                time: this.now(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        else if (type === 'tool_result') {
+            if (msg.tool_use_id && this.answeredQuestionToolUseIds.has(msg.tool_use_id)) {
+                return;
+            }
+            const isError = msg.is_error || false;
+            const details = this.extractText(msg.content);
+            if (isError && details && this.isPermissionDenial(details)) {
+                const toolName = msg.tool_name || this.extractToolNameFromDenial(details);
+                if (this.shouldIgnoreAskUserQuestionDenial(toolName, msg.tool_use_id)) {
+                    return;
+                }
+                const category = getToolCategory(toolName);
+                this.pendingDenials.push({
+                    toolName,
+                    category,
+                    toolUseId: msg.tool_use_id,
+                    input: msg.tool_input || {},
+                    description: details,
+                });
+                this.emit({
+                    type: 'tool_call',
+                    content: `权限被拒绝: ${toolName}`,
+                    toolName,
+                    status: 'failed',
+                    details,
+                    toolUseId: msg.tool_use_id || undefined,
+                    time: this.now(),
+                });
+            }
+            else {
+                this.emit({
+                    type: 'tool_call',
+                    content: isError ? '工具执行失败' : '工具执行完成',
+                    toolName: msg.tool_use_id || 'result',
+                    status: isError ? 'failed' : 'success',
+                    details: details || undefined,
+                    toolUseId: msg.tool_use_id || undefined,
+                    time: this.now(),
+                });
+            }
+        }
+        else if (type === 'permission_request') {
+            this.handlePermissionRequest(msg);
+        }
+        else if (type === 'confirm' || type === 'approval_request') {
+            this.handleConfirmation({
+                promptText: this.extractText(msg.message || msg.content || msg.prompt) || 'CLI 请求确认',
+            });
+        }
+        else if (type === 'result' || type === 'done' || type === 'complete') {
+            const sid = msg.session_id || msg.id;
+            if (sid && typeof sid === 'string' && sid.length > 8) {
+                this.sessionId = sid;
+                console.log(`[CLI] sessionId set from result message: ${this.sessionId.slice(0, 8)}...`);
+            }
+            const denials = (msg.permission_denials || this.pendingDenials).filter((denial) => {
+                const toolName = denial.tool_name || denial.toolName || this.extractToolNameFromDenial(denial.description || '');
+                return !this.shouldIgnoreAskUserQuestionDenial(toolName, denial.tool_use_id || denial.toolUseId);
+            });
+            if (denials && denials.length > 0 && this.config.confirmMode !== 'auto') {
+                this._status = 'confirm';
+                this.emit({ type: 'status', status: 'confirm' });
+                const denial = denials[0];
+                const toolName = denial.tool_name || denial.toolName || 'unknown';
+                const category = getToolCategory(toolName);
+                const input = denial.tool_input || denial.input || {};
+                let filePath = '';
+                let command = '';
+                let diffContent = '';
+                if (category === 'file') {
+                    filePath = input.file_path || input.path || '';
+                    if (input.content) {
+                        diffContent = typeof input.content === 'string' ? input.content : JSON.stringify(input.content, null, 2);
+                    }
+                    if (input.old_string || input.new_string) {
+                        diffContent = '';
+                        if (input.old_string)
+                            diffContent += `--- 原内容\n${input.old_string}\n`;
+                        if (input.new_string)
+                            diffContent += `+++ 新内容\n${input.new_string}\n`;
+                    }
+                }
+                else if (category === 'command') {
+                    command = input.command || input.cmd || '';
+                }
+                this.emit({
+                    type: 'confirm_request',
+                    content: `${toolName} 请求权限: ${denial.description || denial.tool_use_id || ''}`,
+                    time: this.now(),
+                    permission: {
+                        toolName,
+                        category,
+                        filePath,
+                        command,
+                        diffContent,
+                        input: Object.keys(input).length > 0 ? input : undefined,
+                        description: denial.description || '',
+                    },
+                });
+            }
+            else if (this._status !== 'question') {
+                this._status = 'idle';
+                this.emit({ type: 'status', status: 'idle' });
+            }
+            const text = this.extractText(msg.content || msg.message || msg.result);
+            if (text && !this.hasStreamedText) {
+                this.emit({ type: 'ai_message', content: text, time: this.now() });
+            }
+            this.hasStreamedText = false;
+            // Emit result statistics as a system message
+            const resultDetails = {};
+            const usage = msg.usage || {};
+            if (msg.total_cost_usd != null)
+                resultDetails.costUsd = msg.total_cost_usd;
+            else if (msg.cost_usd != null)
+                resultDetails.costUsd = msg.cost_usd;
+            if (msg.duration_ms != null)
+                resultDetails.durationMs = msg.duration_ms;
+            if (msg.duration_api_ms != null)
+                resultDetails.durationApiMs = msg.duration_api_ms;
+            if (msg.num_turns != null)
+                resultDetails.numTurns = msg.num_turns;
+            if (msg.model)
+                resultDetails.model = msg.model;
+            else if (msg.modelUsage && typeof msg.modelUsage === 'object') {
+                const models = Object.keys(msg.modelUsage);
+                if (models.length > 0)
+                    resultDetails.model = models[0];
+            }
+            if (msg.session_id)
+                resultDetails.session_id = msg.session_id;
+            if (usage.input_tokens != null)
+                resultDetails.inputTokens = usage.input_tokens;
+            else if (msg.input_tokens != null)
+                resultDetails.inputTokens = msg.input_tokens;
+            if (usage.output_tokens != null)
+                resultDetails.outputTokens = usage.output_tokens;
+            else if (msg.output_tokens != null)
+                resultDetails.outputTokens = msg.output_tokens;
+            if (usage.cache_read_input_tokens != null)
+                resultDetails.cacheReadTokens = usage.cache_read_input_tokens;
+            if (usage.cache_creation_input_tokens != null)
+                resultDetails.cacheCreationTokens = usage.cache_creation_input_tokens;
+            if (Object.keys(resultDetails).length > 0) {
+                this.emit({ type: 'system', content: '执行完成', time: this.now(), details: { subtype: 'result', ...resultDetails } });
+            }
+        }
+        else {
+            const text = this.extractText(msg.content || msg.message || msg.text);
+            if (text) {
+                this._status = 'running';
+                this.emit({ type: 'status', status: 'running' });
+                this.emit({ type: 'ai_message', content: text, time: this.now() });
+            }
+        }
+    }
+    handleAskUserQuestion(toolName, input, toolUseId) {
+        const questions = this.normalizeAskUserQuestions(input);
+        if (questions.length === 0)
+            return false;
+        if (toolUseId && this.pendingQuestionToolUseId === toolUseId) {
+            if (this._status !== 'question') {
+                this._status = 'question';
+                this.emit({ type: 'status', status: 'question' });
+            }
+            return true;
+        }
+        this._status = 'question';
+        this.pendingQuestionToolUseId = toolUseId || null;
+        this.pendingQuestionNeedsPermissionApproval = false;
+        this.emit({ type: 'status', status: 'question' });
+        this.emit({
+            type: 'ask_question',
+            content: 'Agent 提出问题',
+            questions,
+            toolUseId: toolUseId || undefined,
+            time: this.now(),
+        });
+        this.pausePrintProcessForQuestion();
+        return true;
+    }
+    questionResponse(answer, toolUseId) {
+        if (this._status !== 'question')
+            return;
+        const pendingToolUseId = this.pendingQuestionToolUseId;
+        if (toolUseId && pendingToolUseId && toolUseId !== pendingToolUseId)
+            return;
+        if (this.pendingQuestionNeedsPermissionApproval) {
+            this.writeToActiveProcess('y');
+            this.pendingQuestionNeedsPermissionApproval = false;
+        }
+        const delivered = this.writeToActiveProcess(answer);
+        this._status = 'running';
+        this.pendingQuestionToolUseId = null;
+        this.emit({ type: 'status', status: 'running' });
+        this.emit({
+            type: 'ask_question_result',
+            approved: true,
+            answer,
+            toolUseId: pendingToolUseId || toolUseId,
+            time: this.now(),
+        });
+        if (pendingToolUseId) {
+            this.answeredQuestionToolUseIds.add(pendingToolUseId);
+            this.emit({
+                type: 'tool_call',
+                content: '用户已回答',
+                toolName: ASK_USER_QUESTION_TOOL,
+                status: 'success',
+                details: answer,
+                toolUseId: pendingToolUseId,
+                time: this.now(),
+            });
+        }
+        if (this.config.runMode === 'print' && !delivered) {
+            this.runPrintCommand(this.buildQuestionAnswerPrompt(answer), true);
+        }
+    }
+    extractToolNameFromDenial(text) {
+        const patterns = [
+            /permissions?\s+to\s+(?:use|call|run|execute)\s+([A-Za-z0-9_.:-]+)/i,
+            /permissions?\s+(?:to|for)\s+([A-Za-z0-9_.:-]+)/i,
+            /tool\s+([A-Za-z0-9_.:-]+)/i,
+        ];
+        for (const pattern of patterns) {
+            const match = text.match(pattern);
+            if (match)
+                return match[1];
+        }
+        return 'unknown';
+    }
+    handlePermissionRequest(msg) {
+        const toolName = msg.tool_name || msg.toolName || msg.name || 'unknown';
+        if (this.isAskUserQuestionTool(toolName)) {
+            this.allowedTools.add(ASK_USER_QUESTION_TOOL);
+            const input = msg.input || msg.tool_input || {};
+            const handled = this.handleAskUserQuestion(toolName, input, msg.tool_use_id || msg.toolUseId || msg.id);
+            this.pendingQuestionNeedsPermissionApproval = handled && this.config.runMode !== 'print';
+            return;
+        }
+        if (this.config.confirmMode === 'auto') {
+            this.writeToActiveProcess('y');
+            this.emit({ type: 'system', content: '已自动批准操作', time: this.now() });
+            return;
+        }
+        const category = getToolCategory(toolName);
+        const input = msg.input || msg.tool_input || {};
+        const description = this.extractText(msg.description || msg.message || msg.content) || '';
+        let filePath = '';
+        let command = '';
+        let diffContent = '';
+        if (category === 'file') {
+            filePath = input.file_path || input.path || input.filename || '';
+            if (input.content) {
+                diffContent = typeof input.content === 'string' ? input.content : JSON.stringify(input.content, null, 2);
+            }
+            if (input.old_string || input.new_string) {
+                diffContent = '';
+                if (input.old_string) {
+                    diffContent += `--- 原内容\n${input.old_string}\n`;
+                }
+                if (input.new_string) {
+                    diffContent += `+++ 新内容\n${input.new_string}\n`;
+                }
+            }
+        }
+        else if (category === 'command') {
+            command = input.command || input.cmd || '';
+        }
+        this._status = 'confirm';
+        this.emit({ type: 'status', status: 'confirm' });
+        this.emit({
+            type: 'confirm_request',
+            content: description || `${toolName} 请求权限`,
+            time: this.now(),
+            permission: {
+                toolName,
+                category,
+                filePath,
+                command,
+                diffContent,
+                input: Object.keys(input).length > 0 ? input : undefined,
+                description,
+            },
+        });
+    }
+    handleConfirmation(opts) {
+        if (this.config.confirmMode === 'auto') {
+            this.writeToActiveProcess('y');
+            this.emit({ type: 'system', content: '已自动批准操作', time: this.now() });
+            return;
+        }
+        this._status = 'confirm';
+        this.emit({ type: 'status', status: 'confirm' });
+        this.emit({
+            type: 'confirm_request',
+            content: opts.promptText,
+            time: this.now(),
+            permission: opts.permission,
+        });
+    }
+    writeToActiveProcess(text) {
+        const target = this.printProcess || this.process;
+        if (target?.stdin?.writable) {
+            try {
+                target.stdin.write(text + '\n');
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
+    sendInput(text) {
+        if (this._status === 'question') {
+            this.questionResponse(text);
+            return;
+        }
+        if (this.config.runMode === 'print' && this._status !== 'confirm') {
+            this.runPrintCommand(text);
+            return;
+        }
+        const target = this.printProcess || this.process;
+        if (!target?.stdin?.writable) {
+            this.emit({ type: 'error', content: 'CLI 未连接，无法发送', time: this.now() });
+            return;
+        }
+        target.stdin.write(text + '\n');
+        if (this._status === 'confirm') {
+            this._status = 'running';
+            this.emit({ type: 'status', status: 'running' });
+        }
+        else if (this._status === 'idle') {
+            this._status = 'running';
+            this.emit({ type: 'status', status: 'running' });
+        }
+    }
+    confirmResponse(approved) {
+        if (approved && this.pendingDenials.length > 0) {
+            for (const denial of this.pendingDenials) {
+                const toolName = denial.tool_name || denial.toolName;
+                if (toolName) {
+                    this.allowedTools.add(toolName);
+                }
+            }
+            this.pendingDenials = [];
+            this.emit({
+                type: 'confirm_result',
+                approved: true,
+                time: this.now(),
+            });
+            this.emit({ type: 'system', content: `已授权: ${Array.from(this.allowedTools).join(', ')}`, time: this.now() });
+            this.retryWithPermission();
+            return;
+        }
+        this.pendingDenials = [];
+        this._status = 'idle';
+        this.emit({ type: 'status', status: 'idle' });
+        this.emit({
+            type: 'confirm_result',
+            approved,
+            time: this.now(),
+        });
+    }
+    interrupt() {
+        if (this.printProcess) {
+            this.printProcess.kill('SIGINT');
+            this.printProcess = null;
+        }
+        if (this.process) {
+            this.process.kill('SIGINT');
+        }
+        this._status = 'idle';
+        this.pendingQuestionNeedsPermissionApproval = false;
+        this.emit({ type: 'status', status: 'idle' });
+        this.emit({ type: 'system', content: '任务已中断', time: this.now() });
+    }
+    restart() {
+        this.sessionId = null;
+        this.pendingQuestionToolUseId = null;
+        this.pendingQuestionNeedsPermissionApproval = false;
+        this.answeredQuestionToolUseIds.clear();
+        if (this.printProcess) {
+            this.printProcess.kill('SIGTERM');
+            this.printProcess = null;
+        }
+        if (this.config.runMode === 'interactive') {
+            this.spawnInteractive();
+        }
+        else {
+            this._status = 'idle';
+            this.emit({ type: 'status', status: 'idle' });
+            this.emit({ type: 'system', content: 'CLI 已重置', time: this.now() });
+        }
+    }
+    setConfirmMode(mode) {
+        this.config.confirmMode = mode;
+    }
+    restoreSessionId(sid) {
+        if (sid && typeof sid === 'string' && sid.length > 8) {
+            this.sessionId = sid;
+            console.log(`[CLI] Restored sessionId: ${sid.slice(0, 8)}...`);
+        }
+    }
+    clearSessionId() {
+        this.sessionId = null;
+        this.pendingQuestionToolUseId = null;
+        this.pendingQuestionNeedsPermissionApproval = false;
+        this.answeredQuestionToolUseIds.clear();
+    }
+    restoreWorkDir(workDir) {
+        if (workDir && typeof workDir === 'string') {
+            const resolved = workDir.startsWith('~') ? workDir.replace('~', os.homedir()) : workDir;
+            try {
+                const stat = fs.statSync(resolved);
+                if (stat.isDirectory()) {
+                    this.config.workDir = resolved;
+                    console.log(`[CLI] Restored workDir: ${resolved}`);
+                }
+                else {
+                    console.log(`[CLI] Saved workDir is not a directory, using default: ${this.config.workDir}`);
+                }
+            }
+            catch {
+                console.log(`[CLI] Saved workDir does not exist: ${resolved}, using default: ${this.config.workDir}`);
+            }
+        }
+    }
+    killProcess() {
+        if (this.process) {
+            try {
+                this.process.kill('SIGTERM');
+            }
+            catch { }
+            this.process = null;
+        }
+        if (this.printProcess) {
+            try {
+                this.printProcess.kill('SIGTERM');
+            }
+            catch { }
+            this.printProcess = null;
+        }
+    }
+    destroy() {
+        this.killProcess();
+        this.onEvent = null;
+    }
+}