@code4bug/jarvis-agent 1.2.1 → 1.3.2

package/dist/core/WorkerBridge.js

@@ -36,12 +36,61 @@ await tsImport(workerData.__workerFile, pathToFileURL(workerData.__workerFile).h
 }
 export class WorkerBridge {
     worker = null;
+    currentRun = null;
+    finalizeRun(worker, action, payload) {
+        const run = this.currentRun;
+        if (!run || run.worker !== worker || run.settled)
+            return;
+        run.settled = true;
+        if (run.abortTimer) {
+            clearTimeout(run.abortTimer);
+            run.abortTimer = null;
+        }
+        this.currentRun = null;
+        this.worker = null;
+        worker.terminate().catch(() => { });
+        if (action === 'resolve') {
+            run.resolve(payload);
+        }
+        else {
+            run.reject(payload);
+        }
+    }
+    buildAbortedTranscript(transcript, userInput) {
+        const abortNotice = '[系统提示] 用户中断了上一轮回复（按下 ESC）。上一条助手消息可能不完整，请在后续回复中注意这一点。';
+        const nextTranscript = [...transcript];
+        const lastMessage = nextTranscript[nextTranscript.length - 1];
+        if (userInput.trim()) {
+            const hasSameTrailingUserInput = lastMessage?.role === 'user' && lastMessage.content === userInput;
+            if (!hasSameTrailingUserInput) {
+                nextTranscript.push({ role: 'user', content: userInput });
+            }
+        }
+        nextTranscript.push({ role: 'user', content: abortNotice });
+        return nextTranscript;
+    }
     /** 在独立 Worker 线程中执行查询，返回更新后的 transcript */
     run(userInput, transcript, callbacks, options) {
         return new Promise((resolve, reject) => {
             const workerTsPath = path.join(__dirname, 'queryWorker.ts');
             const worker = createWorker(workerTsPath);
             this.worker = worker;
+            this.currentRun = {
+                worker,
+                resolve,
+                reject,
+                transcript,
+                userInput,
+                callbacks,
+                settled: false,
+                abortTimer: null,
+                lastLoopState: {
+                    iteration: 0,
+                    maxIterations: 0,
+                    isRunning: true,
+                    aborted: false,
+                },
+            };
             logInfo('worker_bridge.run.start', {
                 inputLength: userInput.length,
                 transcriptLength: transcript.length,
@@ -61,6 +110,9 @@ export class WorkerBridge {
                         callbacks.onClearStreamText?.();
                         break;
                     case 'loop_state':
+                        if (this.currentRun?.worker === worker) {
+                            this.currentRun.lastLoopState = msg.state;
+                        }
                         callbacks.onLoopStateChange(msg.state);
                         break;
                     case 'session_update':
@@ -146,31 +198,25 @@ export class WorkerBridge {
                         break;
                     }
                     case 'done':
-                        this.worker = null;
-                        worker.terminate();
                         logInfo('worker_bridge.run.done', {
                             transcriptLength: msg.transcript.length,
                         });
-                        resolve(msg.transcript);
+                        this.finalizeRun(worker, 'resolve', msg.transcript);
                         break;
                     case 'error':
-                        this.worker = null;
-                        worker.terminate();
                         logError('worker_bridge.run.error', msg.message);
-                        reject(new Error(msg.message));
+                        this.finalizeRun(worker, 'reject', new Error(msg.message));
                         break;
                 }
             });
             worker.on('error', (err) => {
-                this.worker = null;
                 logError('worker_bridge.worker_error', err);
-                reject(err);
+                this.finalizeRun(worker, 'reject', err);
             });
             worker.on('exit', (code) => {
-                if (code !== 0 && this.worker) {
-                    this.worker = null;
+                if (code !== 0 && this.currentRun?.worker === worker && !this.currentRun.settled) {
                     logError('worker_bridge.worker_exit_abnormal', undefined, { code });
-                    reject(new Error(`Worker 异常退出，code=${code}`));
+                    this.finalizeRun(worker, 'reject', new Error(`Worker 异常退出，code=${code}`));
                 }
             });
             // 启动执行
@@ -180,10 +226,23 @@ export class WorkerBridge {
     }
     /** 向 Worker 发送中断信号 */
     abort() {
-        if (this.worker) {
-            logWarn('worker_bridge.abort_forwarded');
-            const msg = { type: 'abort' };
-            this.worker.postMessage(msg);
-        }
+        const run = this.currentRun;
+        if (!run || run.settled)
+            return;
+        logWarn('worker_bridge.abort_forwarded');
+        const msg = { type: 'abort' };
+        run.worker.postMessage(msg);
+        run.callbacks.onClearStreamText?.();
+        run.callbacks.onLoopStateChange({
+            ...run.lastLoopState,
+            isRunning: false,
+            aborted: true,
+        });
+        run.abortTimer = setTimeout(() => {
+            if (!this.currentRun || this.currentRun.worker !== run.worker || this.currentRun.settled)
+                return;
+            logWarn('worker_bridge.abort_force_resolve');
+            this.finalizeRun(run.worker, 'resolve', this.buildAbortedTranscript(run.transcript, run.userInput));
+        }, 120);
     }
 }

package/dist/core/query.js

@@ -352,21 +352,59 @@ function canRunInParallelDirect(calls) {
 /** 在独立 Worker 线程中执行单个工具，返回结果字符串 */
 function runToolInWorker(tc, abortSignal) {
     return new Promise((resolve, reject) => {
+        let settled = false;
+        let abortForwarded = false;
+        let abortPollTimer = null;
+        let forceTerminateTimer = null;
+        const cleanup = () => {
+            if (abortPollTimer !== null) {
+                clearInterval(abortPollTimer);
+                abortPollTimer = null;
+            }
+            if (forceTerminateTimer !== null) {
+                clearTimeout(forceTerminateTimer);
+                forceTerminateTimer = null;
+            }
+        };
+        const safeResolve = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            worker.terminate().catch(() => { });
+            resolve(result);
+        };
+        const safeReject = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            worker.terminate().catch(() => { });
+            reject(err);
+        };
         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 abortSignal = { aborted: Boolean(workerData.abortSignal?.aborted) };
+parentPort.on('message', (msg) => {
+  if (msg?.type === 'abort') abortSignal.aborted = true;
+});
 const mod = await tsImport(workerData.__file, pathToFileURL(workerData.__file).href);
-const result = await mod.runToolDirect(workerData.tc, workerData.abortSignal);
-parentPort.postMessage({ result });
+const result = await mod.runToolDirect(workerData.tc, abortSignal);
+parentPort.postMessage({ type: 'result', 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 abortSignal = { aborted: Boolean(workerData.abortSignal?.aborted) };
+parentPort.on('message', (msg) => {
+  if (msg?.type === 'abort') abortSignal.aborted = true;
+});
+const result = await runToolDirect(workerData.tc, abortSignal);
+parentPort.postMessage({ type: 'result', result });
 `;
         const worker = new Worker(workerScript, {
             eval: true,
@@ -376,17 +414,37 @@ parentPort.postMessage({ result });
                 abortSignal: { aborted: abortSignal.aborted },
             },
         });
+        abortPollTimer = setInterval(() => {
+            if (!abortSignal.aborted || abortForwarded || settled)
+                return;
+            abortForwarded = true;
+            logWarn('tool.worker.abort_forwarded', { toolName: tc.name });
+            worker.postMessage({ type: 'abort' });
+            forceTerminateTimer = setTimeout(() => {
+                if (settled)
+                    return;
+                logWarn('tool.worker.force_terminated', { toolName: tc.name });
+                safeResolve('(工具执行被中断)');
+            }, 1500);
+        }, 50);
         worker.on('message', (msg) => {
-            worker.terminate();
-            resolve(msg.result);
+            if (msg.type === 'result') {
+                safeResolve(msg.result ?? '');
+            }
         });
         worker.on('error', (err) => {
-            worker.terminate();
-            reject(err);
+            safeReject(err);
         });
         worker.on('exit', (code) => {
-            if (code !== 0)
-                reject(new Error(`工具 Worker 异常退出 code=${code}`));
+            if (settled)
+                return;
+            if (abortSignal.aborted) {
+                safeResolve('(工具执行被中断)');
+                return;
+            }
+            if (code !== 0) {
+                safeReject(new Error(`工具 Worker 异常退出 code=${code}`));
+            }
         });
     });
 }

package/dist/hooks/useMultilineInputStream.d.ts

@@ -0,0 +1,17 @@
+interface UseMultilineInputStreamOptions {
+    stdin?: NodeJS.ReadStream;
+    isActive: boolean;
+    pasteDetectWindowMs: number;
+    imeComposeWindowMs: number;
+    isAsciiLowerAlpha: (text: string) => boolean;
+    hasNonAscii: (text: string) => boolean;
+    insertPaste: (text: string) => void;
+    handleNormalInput: (raw: string) => void;
+    commitImeBuffer: () => void;
+    flushImeBuffer: () => void;
+    appendImeBuffer: (text: string) => void;
+    getImeBuffer: () => string;
+    clearImeBufferWithInsertedLenRollback: () => void;
+}
+export declare function useMultilineInputStream({ stdin, isActive, pasteDetectWindowMs, imeComposeWindowMs, isAsciiLowerAlpha, hasNonAscii, insertPaste, handleNormalInput, commitImeBuffer, flushImeBuffer, appendImeBuffer, getImeBuffer, clearImeBufferWithInsertedLenRollback, }: UseMultilineInputStreamOptions): void;
+export {};

package/dist/hooks/useMultilineInputStream.js

@@ -0,0 +1,141 @@
+import { useEffect, useRef } from 'react';
+export function useMultilineInputStream({ stdin, isActive, pasteDetectWindowMs, imeComposeWindowMs, isAsciiLowerAlpha, hasNonAscii, insertPaste, handleNormalInput, commitImeBuffer, flushImeBuffer, appendImeBuffer, getImeBuffer, clearImeBufferWithInsertedLenRollback, }) {
+    const pasteBufferRef = useRef(null);
+    const batchBufferRef = useRef('');
+    const batchTimerRef = useRef(null);
+    const imeTimerRef = useRef(null);
+    const escTimerRef = useRef(null);
+    const ESC_WAIT_MS = 50;
+    useEffect(() => {
+        if (!stdin || !isActive)
+            return;
+        const flushBatchBuffer = () => {
+            const buf = batchBufferRef.current;
+            batchBufferRef.current = '';
+            batchTimerRef.current = null;
+            if (!buf)
+                return;
+            const cleaned = buf.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            if (cleaned.includes('\n') && cleaned.length > 1) {
+                insertPaste(cleaned);
+                return;
+            }
+            if (isAsciiLowerAlpha(buf)) {
+                appendImeBuffer(buf);
+                if (imeTimerRef.current !== null) {
+                    clearTimeout(imeTimerRef.current);
+                }
+                imeTimerRef.current = setTimeout(flushImeBuffer, imeComposeWindowMs);
+                return;
+            }
+            if (hasNonAscii(buf) && getImeBuffer().length > 0) {
+                if (imeTimerRef.current !== null) {
+                    clearTimeout(imeTimerRef.current);
+                    imeTimerRef.current = null;
+                }
+                clearImeBufferWithInsertedLenRollback();
+                handleNormalInput(buf);
+                return;
+            }
+            if (getImeBuffer().length > 0) {
+                commitImeBuffer();
+            }
+            handleNormalInput(buf);
+        };
+        const onData = (data) => {
+            const raw = data.toString('utf-8');
+            if (raw.includes('\x1B[200~')) {
+                const startIdx = raw.indexOf('\x1B[200~') + 6;
+                const endIdx = raw.indexOf('\x1B[201~');
+                if (endIdx !== -1) {
+                    insertPaste(raw.slice(startIdx, endIdx));
+                }
+                else {
+                    pasteBufferRef.current = raw.slice(startIdx);
+                }
+                return;
+            }
+            if (pasteBufferRef.current !== null) {
+                const endIdx = raw.indexOf('\x1B[201~');
+                if (endIdx !== -1) {
+                    pasteBufferRef.current += raw.slice(0, endIdx);
+                    insertPaste(pasteBufferRef.current);
+                    pasteBufferRef.current = null;
+                }
+                else {
+                    pasteBufferRef.current += raw;
+                }
+                return;
+            }
+            if (escTimerRef.current !== null) {
+                clearTimeout(escTimerRef.current);
+                escTimerRef.current = null;
+                if (raw === '\r' || raw === '\n') {
+                    handleNormalInput('\x1B\r');
+                    return;
+                }
+                handleNormalInput('\x1B');
+            }
+            const isSingleControl = raw === '\r' || raw === '\n' ||
+                raw === '\x7F' || raw === '\x08' ||
+                raw === '\t' || raw === '\x1B' ||
+                raw === '\x1B\r' || raw === '\x1B\n' ||
+                raw.startsWith('\x1B[') || raw.startsWith('\x1B]') || raw.startsWith('\x1BO');
+            if (raw === '\x03' || raw === '\x0F' || raw === '\x0C')
+                return;
+            if (raw === '\x1B') {
+                escTimerRef.current = setTimeout(() => {
+                    escTimerRef.current = null;
+                    handleNormalInput('\x1B');
+                }, ESC_WAIT_MS);
+                return;
+            }
+            if (isSingleControl && batchBufferRef.current === '') {
+                if (getImeBuffer().length > 0) {
+                    commitImeBuffer();
+                }
+                handleNormalInput(raw);
+                return;
+            }
+            if (isSingleControl && batchBufferRef.current !== '') {
+                batchBufferRef.current += raw;
+                return;
+            }
+            batchBufferRef.current += raw;
+            if (batchTimerRef.current !== null) {
+                clearTimeout(batchTimerRef.current);
+            }
+            batchTimerRef.current = setTimeout(flushBatchBuffer, pasteDetectWindowMs);
+        };
+        stdin.prependListener('data', onData);
+        return () => {
+            stdin.off('data', onData);
+            if (batchTimerRef.current !== null) {
+                clearTimeout(batchTimerRef.current);
+                batchTimerRef.current = null;
+            }
+            if (escTimerRef.current !== null) {
+                clearTimeout(escTimerRef.current);
+                escTimerRef.current = null;
+            }
+            if (imeTimerRef.current !== null) {
+                clearTimeout(imeTimerRef.current);
+                imeTimerRef.current = null;
+            }
+        };
+    }, [
+        stdin,
+        isActive,
+        pasteDetectWindowMs,
+        imeComposeWindowMs,
+        isAsciiLowerAlpha,
+        hasNonAscii,
+        insertPaste,
+        handleNormalInput,
+        commitImeBuffer,
+        flushImeBuffer,
+        appendImeBuffer,
+        getImeBuffer,
+        clearImeBufferWithInsertedLenRollback,
+    ]);
+}

package/dist/hooks/useTerminalCursorSync.d.ts

@@ -0,0 +1,11 @@
+interface UseTerminalCursorSyncOptions {
+    showCursor: boolean;
+    isActive: boolean;
+    rowsBelow: number;
+    cursorRow?: number;
+    rowsInInput?: number;
+    cursorColumn?: number;
+    delayMs?: number;
+}
+export declare function useTerminalCursorSync({ showCursor, isActive, rowsBelow, cursorRow, rowsInInput, cursorColumn, delayMs, }: UseTerminalCursorSyncOptions): void;
+export {};

package/dist/hooks/useTerminalCursorSync.js

@@ -0,0 +1,46 @@
+import { useEffect, useRef } from 'react';
+import { moveCursorToColumn, relocateCursorToInputLine } from '../terminal/cursor.js';
+export function useTerminalCursorSync({ showCursor, isActive, rowsBelow, cursorRow = 0, rowsInInput = 1, cursorColumn = 3, delayMs = 80, }) {
+    const cursorRelocTimerRef = useRef(null);
+    const lastCursorCommandRef = useRef('');
+    useEffect(() => {
+        return () => {
+            if (cursorRelocTimerRef.current !== null) {
+                clearTimeout(cursorRelocTimerRef.current);
+            }
+        };
+    }, []);
+    useEffect(() => {
+        if (cursorRelocTimerRef.current !== null) {
+            clearTimeout(cursorRelocTimerRef.current);
+        }
+        if (!showCursor || !isActive) {
+            cursorRelocTimerRef.current = setTimeout(() => {
+                cursorRelocTimerRef.current = null;
+                const commandKey = 'col:1';
+                if (lastCursorCommandRef.current === commandKey)
+                    return;
+                lastCursorCommandRef.current = commandKey;
+                moveCursorToColumn(1);
+            }, delayMs);
+        }
+        else {
+            cursorRelocTimerRef.current = setTimeout(() => {
+                cursorRelocTimerRef.current = null;
+                const extraRowsUp = Math.max(rowsInInput - 1 - cursorRow, 0);
+                const safeColumn = Math.max(cursorColumn, 1);
+                const commandKey = `input:${rowsBelow}:${extraRowsUp}:${safeColumn}`;
+                if (lastCursorCommandRef.current === commandKey)
+                    return;
+                lastCursorCommandRef.current = commandKey;
+                relocateCursorToInputLine(rowsBelow, safeColumn, extraRowsUp);
+            }, delayMs);
+        }
+        return () => {
+            if (cursorRelocTimerRef.current !== null) {
+                clearTimeout(cursorRelocTimerRef.current);
+                cursorRelocTimerRef.current = null;
+            }
+        };
+    }, [showCursor, isActive, rowsBelow, cursorRow, rowsInInput, cursorColumn, delayMs]);
+}

package/dist/hooks/useTerminalSize.d.ts

@@ -0,0 +1,7 @@
+interface TerminalSize {
+    width: number;
+    height: number;
+}
+/** 响应式终端尺寸 */
+export declare function useTerminalSize(): TerminalSize;
+export {};

package/dist/hooks/useTerminalSize.js

@@ -0,0 +1,21 @@
+import { useState, useEffect } from 'react';
+/** 响应式终端尺寸 */
+export function useTerminalSize() {
+    const [size, setSize] = useState(() => ({
+        width: process.stdout.columns || 80,
+        height: process.stdout.rows || 24,
+    }));
+    useEffect(() => {
+        const onResize = () => {
+            setSize({
+                width: process.stdout.columns || 80,
+                height: process.stdout.rows || 24,
+            });
+        };
+        process.stdout.on('resize', onResize);
+        return () => {
+            process.stdout.off('resize', onResize);
+        };
+    }, []);
+    return size;
+}