@code4bug/jarvis-agent 1.0.2 → 1.0.3

package/dist/core/query.d.ts

@@ -1,4 +1,4 @@
-import { Message, LoopState, Tool, LLMService, TranscriptMessage } from '../types/index.js';
+import { Message, LoopState, Tool, LLMService, TranscriptMessage, ToolCallInfo } from '../types/index.js';
 /** 危险命令确认结果 */
 export type DangerConfirmResult = 'once' | 'always' | 'cancel';
 export interface QueryCallbacks {
@@ -22,3 +22,10 @@ export interface QueryCallbacks {
 export declare function executeQuery(userInput: string, transcript: TranscriptMessage[], _tools: Tool[], service: LLMService, callbacks: QueryCallbacks, abortSignal: {
     aborted: boolean;
 }): Promise<TranscriptMessage[]>;
+/**
+ * 直接执行工具（供 Worker 线程调用）
+ * 注意：此函数在 Worker 线程中运行，不能使用 callbacks
+ */
+export declare function runToolDirect(tc: ToolCallInfo, abortSignal: {
+    aborted: boolean;
+}): Promise<string>;

package/dist/core/query.js

@@ -1,7 +1,13 @@
 import { v4 as uuid } from 'uuid';
-import { findToolMerged as findTool } from '../tools/index.js';
-import { MAX_ITERATIONS } from '../config/constants.js';
-import { sanitizeOutput, validateCommand, authorizeCommand, authorizeRule } from './safeguard.js';
+import { Worker } from 'worker_threads';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { findToolMerged as findTool } from '../tools/index';
+import { MAX_ITERATIONS } from '../config/constants';
+import { sanitizeOutput, validateCommand, authorizeCommand, authorizeRule } from './safeguard';
+// 兼容 ESM __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 /**
  * 单轮 Agentic Loop：推理 → 工具调用 → 循环
  */
@@ -19,50 +25,59 @@ export async function executeQuery(userInput, transcript, _tools, service, callb
         loopState.iteration++;
         callbacks.onLoopStateChange({ ...loopState });
         const result = await runOneIteration(localTranscript, _tools, service, callbacks, abortSignal);
-        // 添加推理消息
-        if (result.text) {
-            const blocks = [{ type: 'text', text: result.text }];
-            if (result.toolCall) {
-                blocks.push({
-                    type: 'tool_use',
-                    id: result.toolCall.id,
-                    name: result.toolCall.name,
-                    input: result.toolCall.input,
-                });
-            }
-            localTranscript.push({ role: 'assistant', content: blocks });
+        // 构建 assistant transcript 块
+        const assistantBlocks = [];
+        if (result.text)
+            assistantBlocks.push({ type: 'text', text: result.text });
+        for (const tc of result.toolCalls) {
+            assistantBlocks.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.input });
         }
-        else if (result.toolCall) {
-            localTranscript.push({
-                role: 'assistant',
-                content: [{
-                        type: 'tool_use',
-                        id: result.toolCall.id,
-                        name: result.toolCall.name,
-                        input: result.toolCall.input,
-                    }],
-            });
+        if (assistantBlocks.length > 0) {
+            localTranscript.push({ role: 'assistant', content: assistantBlocks });
         }
         // 无工具调用 → 结束
-        if (!result.toolCall)
+        if (result.toolCalls.length === 0)
             break;
-        if (abortSignal.aborted)
+        // 中断发生在推理阶段
+        if (abortSignal.aborted) {
+            for (const tc of result.toolCalls) {
+                const skippedResult = `[用户中断] 工具 ${tc.name} 未执行（用户按下 ESC 中断）`;
+                localTranscript.push({ role: 'tool_result', toolUseId: tc.id, content: skippedResult });
+                const skipMsgId = uuid();
+                callbacks.onMessage({
+                    id: skipMsgId, type: 'tool_exec', status: 'aborted',
+                    content: `${tc.name} 已跳过（用户中断）`, timestamp: Date.now(),
+                    toolName: tc.name, toolArgs: tc.input, toolResult: skippedResult,
+                    abortHint: '命令已跳过（ESC）',
+                });
+            }
             break;
-        // 执行工具
-        const tc = result.toolCall;
-        const toolResult = await executeTool(tc, callbacks);
-        localTranscript.push({
-            role: 'tool_result',
-            toolUseId: tc.id,
-            content: toolResult.content,
-        });
-        if (toolResult.isError)
+        }
+        // 判断是否可并行执行
+        let toolResults;
+        if (result.toolCalls.length > 1 && canRunInParallel(result.toolCalls)) {
+            toolResults = await executeToolsInParallel(result.toolCalls, callbacks, abortSignal);
+        }
+        else {
+            toolResults = [];
+            for (const tc of result.toolCalls) {
+                const r = await executeTool(tc, callbacks, abortSignal);
+                toolResults.push({ tc, ...r });
+                if (r.isError)
+                    break;
+            }
+        }
+        // 将所有工具结果写入 transcript
+        for (const { tc, content } of toolResults) {
+            localTranscript.push({ role: 'tool_result', toolUseId: tc.id, content });
+        }
+        // 任意工具出错则终止循环
+        if (toolResults.some((r) => r.isError))
             break;
     }
     loopState.isRunning = false;
     loopState.aborted = abortSignal.aborted;
     callbacks.onLoopStateChange({ ...loopState });
-    // 如果被用户中断，在 transcript 中追加中断标记，让 LLM 知道上轮回复未完成
     if (abortSignal.aborted) {
         localTranscript.push({
             role: 'user',
@@ -76,7 +91,7 @@ async function runOneIteration(transcript, tools, service, callbacks, abortSigna
     const startTime = Date.now();
     let accumulatedText = '';
     let accumulatedThinking = '';
-    let toolCall = null;
+    let toolCalls = [];
     let tokenCount = 0;
     let firstTokenTime = null;
     const thinkingId = uuid();
@@ -88,23 +103,29 @@ async function runOneIteration(transcript, tools, service, callbacks, abortSigna
         timestamp: Date.now(),
     });
     await new Promise((resolve, reject) => {
+        let resolved = false;
+        const safeResolve = () => { if (!resolved) {
+            resolved = true;
+            resolve();
+        } };
         service
             .streamMessage(transcript, tools, {
             onThinking: (text) => {
-                if (abortSignal.aborted)
+                if (abortSignal.aborted) {
+                    safeResolve();
                     return;
+                }
                 accumulatedThinking += text;
-                // 实时更新 thinking 消息内容，让用户看到思考过程
+                tokenCount++;
                 callbacks.onUpdateMessage(thinkingId, { content: accumulatedThinking });
             },
             onText: (text) => {
                 if (abortSignal.aborted) {
-                    resolve();
+                    safeResolve();
                     return;
                 }
                 if (firstTokenTime === null) {
                     firstTokenTime = Date.now();
-                    // 收到首 token，将 thinking 消息标记为完成（保留 think 内容）
                     callbacks.onUpdateMessage(thinkingId, {
                         status: 'success',
                         content: accumulatedThinking ? '思考完成' : '',
@@ -117,13 +138,21 @@ async function runOneIteration(transcript, tools, service, callbacks, abortSigna
             },
             onToolUse: (id, name, input) => {
                 if (abortSignal.aborted) {
-                    resolve();
+                    safeResolve();
+                    return;
+                }
+                toolCalls = [{ id, name, input }];
+                safeResolve();
+            },
+            onMultiToolUse: (calls) => {
+                if (abortSignal.aborted) {
+                    safeResolve();
                     return;
                 }
-                toolCall = { id, name, input };
-                resolve();
+                toolCalls = calls;
+                safeResolve();
             },
-            onComplete: () => resolve(),
+            onComplete: () => safeResolve(),
             onError: (err) => reject(err),
         }, abortSignal)
             .catch(reject);
@@ -132,7 +161,6 @@ async function runOneIteration(transcript, tools, service, callbacks, abortSigna
     const firstTokenLatency = firstTokenTime !== null ? firstTokenTime - startTime : 0;
     const durationSec = duration / 1000;
     const tokensPerSecond = durationSec > 0 ? tokenCount / durationSec : 0;
-    // 最终更新 thinking 消息状态
     callbacks.onUpdateMessage(thinkingId, {
         status: 'success',
         content: accumulatedThinking ? '思考完成' : '',
@@ -141,7 +169,6 @@ async function runOneIteration(transcript, tools, service, callbacks, abortSigna
     });
     if (accumulatedText) {
         const isAborted = abortSignal.aborted;
-        // 先清空流式文本，再 push reasoning 消息，避免 streamText 被后续工具消息挤到底部
         callbacks.onClearStreamText?.();
         callbacks.onMessage({
             id: uuid(),
@@ -156,15 +183,199 @@ async function runOneIteration(transcript, tools, service, callbacks, abortSigna
             ...(isAborted ? { abortHint: '推理已中断（ESC）' } : {}),
         });
     }
-    return { text: accumulatedText, toolCall, duration, tokenCount, firstTokenLatency, tokensPerSecond };
+    else if (accumulatedThinking && toolCalls.length === 0) {
+        const isAborted = abortSignal.aborted;
+        callbacks.onClearStreamText?.();
+        callbacks.onStreamText(accumulatedThinking);
+        callbacks.onClearStreamText?.();
+        callbacks.onMessage({
+            id: uuid(),
+            type: 'reasoning',
+            status: isAborted ? 'aborted' : 'success',
+            content: accumulatedThinking,
+            timestamp: Date.now(),
+            duration,
+            tokenCount,
+            firstTokenLatency,
+            tokensPerSecond,
+            ...(isAborted ? { abortHint: '推理已中断（ESC）' } : {}),
+        });
+    }
+    const effectiveText = accumulatedText || (accumulatedThinking && toolCalls.length === 0 ? accumulatedThinking : '');
+    return { text: effectiveText, toolCalls, duration, tokenCount, firstTokenLatency, tokensPerSecond };
+}
+// ===== 并行执行判断 =====
+/** 判断一组工具调用是否可以并行执行（无写-写冲突、无读-写冲突） */
+function canRunInParallel(calls) {
+    // 写操作工具集合
+    const WRITE_TOOLS = new Set(['WriteFile', 'Bash']);
+    // 读操作工具集合
+    const READ_TOOLS = new Set(['ReadFile', 'ListDirectory', 'SearchFiles', 'SemanticSearch']);
+    const hasWrite = calls.some((c) => WRITE_TOOLS.has(c.name));
+    const hasRead = calls.some((c) => READ_TOOLS.has(c.name));
+    // 有写操作时：写-写 或 读-写 混合均不可并行（避免竞态）
+    if (hasWrite)
+        return false;
+    // 全部是读操作 → 可并行
+    if (hasRead && !hasWrite)
+        return true;
+    // Bash 命令：检查是否有文件路径重叠（简单启发式）
+    const bashCalls = calls.filter((c) => c.name === 'Bash');
+    if (bashCalls.length > 1) {
+        // 多个 Bash 命令默认不并行（无法静态分析副作用）
+        return false;
+    }
+    // 其余情况（如多个只读 skill）允许并行
+    return true;
+}
+// ===== 并行工具执行（多 Worker 线程） =====
+/** 在独立 Worker 线程中执行单个工具，返回结果字符串 */
+function runToolInWorker(tc, abortSignal) {
+    return new Promise((resolve, reject) => {
+        const isTsx = __filename.endsWith('.ts');
+        const workerScript = isTsx
+            ? `
+import { tsImport } from 'tsx/esm/api';
+import { workerData, parentPort } from 'worker_threads';
+import { pathToFileURL } from 'url';
+const mod = await tsImport(workerData.__file, pathToFileURL(workerData.__file).href);
+const result = await mod.runToolDirect(workerData.tc, workerData.abortSignal);
+parentPort.postMessage({ result });
+`
+            : `
+import { runToolDirect } from '${__filename.replace(/\.ts$/, '.js')}';
+import { workerData, parentPort } from 'worker_threads';
+const result = await runToolDirect(workerData.tc, workerData.abortSignal);
+parentPort.postMessage({ result });
+`;
+        const worker = new Worker(workerScript, {
+            eval: true,
+            workerData: {
+                __file: __filename,
+                tc,
+                abortSignal: { aborted: abortSignal.aborted },
+            },
+        });
+        worker.on('message', (msg) => {
+            worker.terminate();
+            resolve(msg.result);
+        });
+        worker.on('error', (err) => {
+            worker.terminate();
+            reject(err);
+        });
+        worker.on('exit', (code) => {
+            if (code !== 0)
+                reject(new Error(`工具 Worker 异常退出 code=${code}`));
+        });
+    });
+}
+/**
+ * 直接执行工具（供 Worker 线程调用）
+ * 注意：此函数在 Worker 线程中运行，不能使用 callbacks
+ */
+export async function runToolDirect(tc, abortSignal) {
+    // 动态导入避免循环依赖
+    const { findToolMerged } = await import('../tools/index.js');
+    const tool = findToolMerged(tc.name);
+    if (!tool)
+        return `错误: 未知工具 ${tc.name}`;
+    try {
+        const result = await tool.execute(tc.input, abortSignal);
+        const { sanitizeOutput } = await import('./safeguard.js');
+        return sanitizeOutput(result);
+    }
+    catch (err) {
+        return `错误: ${err.message || '工具执行失败'}`;
+    }
+}
+/** 并行执行多个工具，每个工具在独立 Worker 线程中运行，实时更新 UI */
+async function executeToolsInParallel(calls, callbacks, abortSignal) {
+    const groupId = uuid();
+    // 为每个工具预先创建 pending 消息节点（TUI 立即渲染占位）
+    const msgIds = calls.map((tc) => {
+        const msgId = uuid();
+        const isSkill = tc.name.startsWith('skill_');
+        const displayContent = tc.name === 'Bash' && tc.input.command
+            ? `Bash(${tc.input.command})`
+            : isSkill
+                ? `${tc.name.replace(/^skill_/, '')}(${Object.values(tc.input).join(', ')})`
+                : `调用工具: ${tc.name}`;
+        callbacks.onMessage({
+            id: msgId,
+            type: 'tool_exec',
+            status: 'pending',
+            content: displayContent,
+            timestamp: Date.now(),
+            toolName: tc.name,
+            toolArgs: tc.input,
+            parallelGroupId: groupId,
+        });
+        return msgId;
+    });
+    // 并行启动所有工具（各自在独立 Worker 线程）
+    const tasks = calls.map(async (tc, i) => {
+        const msgId = msgIds[i];
+        const start = Date.now();
+        // 安全围栏检查（Bash 命令）
+        if (tc.name === 'Bash' && tc.input.command) {
+            const { validateCommand } = await import('./safeguard.js');
+            const check = validateCommand(tc.input.command);
+            if (!check.allowed) {
+                if (!check.canOverride) {
+                    const errMsg = `${check.reason}\n🚫 该命令已被永久禁止。\n命令: ${tc.input.command}`;
+                    callbacks.onUpdateMessage(msgId, { status: 'error', content: errMsg, toolResult: errMsg });
+                    return { tc, content: `错误: ${errMsg}`, isError: true };
+                }
+                // 危险命令在并行模式下直接跳过（无法弹出交互式确认）
+                const skipMsg = `⚠️ 并行模式下跳过危险命令: ${tc.input.command}\n原因: ${check.reason}`;
+                callbacks.onUpdateMessage(msgId, { status: 'error', content: skipMsg, toolResult: skipMsg });
+                return { tc, content: skipMsg, isError: true };
+            }
+        }
+        try {
+            const content = await runToolInWorker(tc, abortSignal);
+            const wasAborted = abortSignal.aborted;
+            const isSkill = tc.name.startsWith('skill_');
+            const doneContent = wasAborted
+                ? `${tc.name} 已中断`
+                : tc.name === 'Bash' && tc.input.command
+                    ? `Bash(${tc.input.command}) 执行完成`
+                    : isSkill
+                        ? `${tc.name.replace(/^skill_/, '')}(${Object.values(tc.input).join(', ')}) 执行完成`
+                        : `工具 ${tc.name} 执行完成`;
+            callbacks.onUpdateMessage(msgId, {
+                status: wasAborted ? 'aborted' : 'success',
+                content: doneContent,
+                toolResult: content,
+                duration: Date.now() - start,
+                parallelGroupId: groupId,
+                ...(wasAborted ? { abortHint: '命令已中断（ESC）' } : {}),
+            });
+            return { tc, content, isError: false };
+        }
+        catch (err) {
+            const errMsg = err.message || '工具执行失败';
+            callbacks.onUpdateMessage(msgId, { status: 'error', content: errMsg, toolResult: errMsg });
+            return { tc, content: `错误: ${errMsg}`, isError: false };
+        }
+    });
+    return Promise.all(tasks);
 }
 /** 执行工具并返回结果 */
-async function executeTool(tc, callbacks) {
+async function executeTool(tc, callbacks, abortSignal) {
     const toolExecId = uuid();
-    // 对 Bash 工具使用更直观的显示格式
+    // 对 Bash / Skill 工具使用更直观的显示格式
+    const isSkill = tc.name.startsWith('skill_');
+    const skillName = isSkill ? tc.name.replace(/^skill_/, '') : '';
+    const skillArgsSummary = isSkill
+        ? Object.values(tc.input).map((v) => String(v)).filter(Boolean).join(', ')
+        : '';
     const displayContent = tc.name === 'Bash' && tc.input.command
         ? `Bash(${tc.input.command})`
-        : `调用工具: ${tc.name}`;
+        : isSkill
+            ? `${skillName}(${skillArgsSummary})`
+            : `调用工具: ${tc.name}`;
     callbacks.onMessage({
         id: toolExecId,
         type: 'tool_exec',
@@ -219,17 +430,28 @@ async function executeTool(tc, callbacks) {
     }
     try {
         const start = Date.now();
-        const result = await tool.execute(tc.input);
+        const result = await tool.execute(tc.input, abortSignal);
         // 对工具输出统一脱敏
         const safeResult = sanitizeOutput(result);
-        const doneContent = tc.name === 'Bash' && tc.input.command
-            ? `Bash(${tc.input.command}) 执行完成`
-            : `工具 ${tc.name} 执行完成`;
+        // 工具执行期间被中断
+        const wasAborted = abortSignal?.aborted;
+        const doneContent = wasAborted
+            ? (tc.name === 'Bash' && tc.input.command
+                ? `Bash(${tc.input.command}) 已中断`
+                : isSkill
+                    ? `${skillName}(${skillArgsSummary}) 已中断`
+                    : `工具 ${tc.name} 已中断`)
+            : (tc.name === 'Bash' && tc.input.command
+                ? `Bash(${tc.input.command}) 执行完成`
+                : isSkill
+                    ? `${skillName}(${skillArgsSummary}) 执行完成`
+                    : `工具 ${tc.name} 执行完成`);
         callbacks.onUpdateMessage(toolExecId, {
-            status: 'success',
+            status: wasAborted ? 'aborted' : 'success',
             content: doneContent,
             toolResult: safeResult,
             duration: Date.now() - start,
+            ...(wasAborted ? { abortHint: '命令已中断（ESC）' } : {}),
         });
         return { content: safeResult, isError: false };
     }

package/dist/core/queryWorker.d.ts

@@ -0,0 +1,44 @@
+import { DangerConfirmResult } from './query.js';
+import { TranscriptMessage, Message, LoopState, Session } from '../types/index.js';
+export type WorkerInbound = {
+    type: 'run';
+    userInput: string;
+    transcript: TranscriptMessage[];
+} | {
+    type: 'abort';
+} | {
+    type: 'danger_confirm_result';
+    requestId: string;
+    choice: DangerConfirmResult;
+};
+export type WorkerOutbound = {
+    type: 'message';
+    msg: Message;
+} | {
+    type: 'update_message';
+    id: string;
+    updates: Partial<Message>;
+} | {
+    type: 'stream_text';
+    text: string;
+} | {
+    type: 'clear_stream_text';
+} | {
+    type: 'loop_state';
+    state: LoopState;
+} | {
+    type: 'session_update';
+    session: Session;
+} | {
+    type: 'danger_confirm_request';
+    requestId: string;
+    command: string;
+    reason: string;
+    ruleName: string;
+} | {
+    type: 'done';
+    transcript: TranscriptMessage[];
+} | {
+    type: 'error';
+    message: string;
+};

package/dist/core/queryWorker.js

@@ -0,0 +1,66 @@
+/**
+ * Worker 线程入口 — 在独立线程中执行 executeQuery
+ * 通过 parentPort.postMessage 将回调事件传回主线程
+ */
+import { parentPort } from 'worker_threads';
+import { executeQuery } from './query.js';
+import { getAllTools } from '../tools/index.js';
+import { LLMServiceImpl } from '../services/api/llm.js';
+import { MockService } from '../services/api/mock.js';
+import { loadConfig, getActiveModel } from '../config/loader.js';
+if (!parentPort)
+    throw new Error('queryWorker must run inside worker_threads');
+// ===== 初始化 LLM 服务 =====
+const config = loadConfig();
+const activeModel = getActiveModel(config);
+let service;
+try {
+    service = activeModel ? new LLMServiceImpl() : new MockService();
+}
+catch {
+    service = new MockService();
+}
+// ===== 中断信号 =====
+const abortSignal = { aborted: false };
+// ===== 危险命令确认：挂起 Promise，等待主线程回复 =====
+const pendingConfirms = new Map();
+// ===== 监听主线程消息 =====
+parentPort.on('message', async (msg) => {
+    if (msg.type === 'abort') {
+        abortSignal.aborted = true;
+        return;
+    }
+    if (msg.type === 'danger_confirm_result') {
+        const resolve = pendingConfirms.get(msg.requestId);
+        if (resolve) {
+            pendingConfirms.delete(msg.requestId);
+            resolve(msg.choice);
+        }
+        return;
+    }
+    if (msg.type === 'run') {
+        abortSignal.aborted = false;
+        const send = (out) => parentPort.postMessage(out);
+        const callbacks = {
+            onMessage: (m) => send({ type: 'message', msg: m }),
+            onUpdateMessage: (id, updates) => send({ type: 'update_message', id, updates }),
+            onStreamText: (text) => send({ type: 'stream_text', text }),
+            onClearStreamText: () => send({ type: 'clear_stream_text' }),
+            onLoopStateChange: (state) => send({ type: 'loop_state', state }),
+            onConfirmDangerousCommand: (command, reason, ruleName) => {
+                return new Promise((resolve) => {
+                    const requestId = `${Date.now()}-${Math.random()}`;
+                    pendingConfirms.set(requestId, resolve);
+                    send({ type: 'danger_confirm_request', requestId, command, reason, ruleName });
+                });
+            },
+        };
+        try {
+            const newTranscript = await executeQuery(msg.userInput, msg.transcript, getAllTools(), service, callbacks, abortSignal);
+            send({ type: 'done', transcript: newTranscript });
+        }
+        catch (err) {
+            send({ type: 'error', message: err.message ?? '未知错误' });
+        }
+    }
+});

package/dist/core/safeguard.js

@@ -42,7 +42,7 @@ export const DANGER_RULES = [
 /** 敏感信息匹配规则 — 用于输出脱敏 */
 export const SENSITIVE_PATTERNS = [
     { name: 'AWS Access Key', pattern: /\b(AKIA[0-9A-Z]{16})\b/g, replacement: '[AWS_ACCESS_KEY]' },
-    { name: 'AWS Secret Key', pattern: /\b([A-Za-z0-9/+=]{40})\b/g, replacement: '[AWS_SECRET_KEY]' },
+    { name: 'AWS Secret Key', pattern: /(?<![A-Za-z0-9/])([A-Za-z0-9+=]{40})(?![A-Za-z0-9/])/g, replacement: '[AWS_SECRET_KEY]' },
     { name: 'Generic API Key', pattern: /\b(api[_-]?key|apikey)\s*[:=]\s*['"]?([^\s'"]+)/gi, replacement: '$1=[REDACTED]' },
     { name: 'Generic Secret', pattern: /\b(secret|token|password|passwd|pwd)\s*[:=]\s*['"]?([^\s'"]+)/gi, replacement: '$1=[REDACTED]' },
     { name: 'Bearer Token', pattern: /Bearer\s+[A-Za-z0-9\-._~+/]+=*/g, replacement: 'Bearer [REDACTED]' },

package/dist/hooks/useDoubleCtrlCExit.d.ts

@@ -0,0 +1,5 @@
+/** 双击 Ctrl+C 退出：第一次按下后显示倒计时，3 秒内再按一次退出，否则取消 */
+export declare function useDoubleCtrlCExit(exit: () => void): {
+    countdown: number | null;
+    handleCtrlC: () => void;
+};

package/dist/hooks/useDoubleCtrlCExit.js

@@ -0,0 +1,34 @@
+import { useState, useCallback, useRef, useEffect } from 'react';
+/** 双击 Ctrl+C 退出：第一次按下后显示倒计时，3 秒内再按一次退出，否则取消 */
+export function useDoubleCtrlCExit(exit) {
+    const [countdown, setCountdown] = useState(null);
+    const timerRef = useRef(null);
+    const clearTimer = useCallback(() => {
+        if (timerRef.current) {
+            clearInterval(timerRef.current);
+            timerRef.current = null;
+        }
+        setCountdown(null);
+    }, []);
+    const handleCtrlC = useCallback(() => {
+        if (countdown !== null) {
+            clearTimer();
+            exit();
+            return;
+        }
+        setCountdown(1);
+        timerRef.current = setInterval(() => {
+            setCountdown((prev) => {
+                if (prev === null || prev <= 1) {
+                    clearTimer();
+                    return null;
+                }
+                return prev - 1;
+            });
+        }, 1000);
+    }, [countdown, clearTimer, exit]);
+    // 组件卸载时清理
+    useEffect(() => () => { if (timerRef.current)
+        clearInterval(timerRef.current); }, []);
+    return { countdown, handleCtrlC };
+}

package/dist/hooks/useInputHistory.js

@@ -5,6 +5,28 @@ import os from 'os';
 const HISTORY_DIR = path.join(os.homedir(), '.jarvis');
 const HISTORY_FILE = path.join(HISTORY_DIR, '.input_history');
 const MAX_HISTORY = 20;
+// 历史记录使用 JSON 数组格式存储，天然支持多行内容，无需手动转义
+/** 还原旧 encodeLine 格式：将字面量 \n 还原为真实换行，\\\\ 还原为 \\ */
+function decodeLegacyLine(s) {
+    let result = '';
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === '\\' && i + 1 < s.length) {
+            const next = s[i + 1];
+            if (next === 'n') {
+                result += '\n';
+                i++;
+                continue;
+            }
+            if (next === '\\') {
+                result += '\\';
+                i++;
+                continue;
+            }
+        }
+        result += s[i];
+    }
+    return result;
+}
 /** 从文件加载历史记录 */
 function loadHistory() {
     try {
@@ -13,19 +35,29 @@ function loadHistory() {
         const content = fs.readFileSync(HISTORY_FILE, 'utf-8').trim();
         if (!content)
             return [];
-        return content.split('\n').slice(-MAX_HISTORY);
+        // 尝试 JSON 格式（新格式）
+        if (content.startsWith('[')) {
+            try {
+                const arr = JSON.parse(content);
+                if (Array.isArray(arr))
+                    return arr.filter((s) => typeof s === 'string').slice(-MAX_HISTORY);
+            }
+            catch { /* JSON 解析失败，回退纯文本 */ }
+        }
+        // 回退：旧的纯文本格式，对每行做 decode 还原可能的转义
+        return content.split('\n').filter(Boolean).slice(-MAX_HISTORY).map(decodeLegacyLine);
     }
     catch {
         return [];
     }
 }
-/** 保存历史记录到文件 */
+/** 保存历史记录到文件（JSON 数组格式） */
 function saveHistory(history) {
     try {
         if (!fs.existsSync(HISTORY_DIR)) {
             fs.mkdirSync(HISTORY_DIR, { recursive: true });
         }
-        fs.writeFileSync(HISTORY_FILE, history.slice(-MAX_HISTORY).join('\n') + '\n', 'utf-8');
+        fs.writeFileSync(HISTORY_FILE, JSON.stringify(history.slice(-MAX_HISTORY)), 'utf-8');
     }
     catch {
         // 静默失败