@code4bug/jarvis-agent 1.0.4 → 1.1.5

package/dist/core/QueryEngine.js

@@ -8,28 +8,27 @@ import { loadConfig, getActiveModel } from '../config/loader.js';
 import { SESSIONS_DIR } from '../config/constants.js';
 import { setActiveAgent } from '../config/agentState.js';
 import { clearAuthorizations } from './safeguard.js';
+import { agentUIBus } from './AgentRegistry.js';
+import { logError, logInfo, logWarn } from './logger.js';
+import { updateUserProfileFromInput } from '../services/userProfile.js';
 export class QueryEngine {
     service;
     session;
     transcript = [];
     workerBridge = new WorkerBridge();
     constructor() {
-        // 尝试从配置文件加载 LLM，失败则回退 MockService
-        const config = loadConfig();
-        const activeModel = getActiveModel(config);
-        if (activeModel) {
-            try {
-                this.service = new LLMServiceImpl();
-            }
-            catch {
-                this.service = new MockService();
-            }
-        }
-        else {
-            this.service = new MockService();
-        }
+        this.service = this.createService();
         this.session = this.createSession();
         this.ensureSessionDir();
+        logInfo('engine.created', {
+            sessionId: this.session.id,
+            service: this.service.constructor.name,
+        });
+    }
+    /** 注册持久 UI 回调，供后台 spawn_agent 子 Agent 推送消息 */
+    registerUIBus(onMessage, onUpdateMessage) {
+        agentUIBus.register(onMessage, onUpdateMessage);
+        logInfo('engine.ui_bus_registered', { sessionId: this.session.id });
     }
     createSession() {
         return {
@@ -46,8 +45,26 @@ export class QueryEngine {
             fs.mkdirSync(SESSIONS_DIR, { recursive: true });
         }
     }
+    createService() {
+        const config = loadConfig();
+        const activeModel = getActiveModel(config);
+        if (activeModel) {
+            try {
+                return new LLMServiceImpl();
+            }
+            catch {
+                return new MockService();
+            }
+        }
+        return new MockService();
+    }
     /** 处理用户输入（在独立 Worker 线程中执行） */
     async handleQuery(userInput, callbacks) {
+        logInfo('query.received', {
+            sessionId: this.session.id,
+            inputLength: userInput.length,
+            preview: userInput.slice(0, 200),
+        });
         const userMsg = {
             id: uuid(),
             type: 'user',
@@ -57,6 +74,12 @@ export class QueryEngine {
         };
         callbacks.onMessage(userMsg);
         this.session.messages.push(userMsg);
+        if (this.transcript.length === 0) {
+            const updated = await updateUserProfileFromInput(userInput);
+            if (updated) {
+                this.service = this.createService();
+            }
+        }
         // 将回调包装后传给 WorkerBridge，Worker 事件会映射回这里
         const bridgeCallbacks = {
             onMessage: (msg) => {
@@ -73,11 +96,23 @@ export class QueryEngine {
             onLoopStateChange: callbacks.onLoopStateChange,
             onSessionUpdate: callbacks.onSessionUpdate,
             onConfirmDangerousCommand: callbacks.onConfirmDangerousCommand,
+            onSubAgentMessage: (msg) => {
+                // SubAgent 消息也存入会话，方便持久化
+                this.session.messages.push(msg);
+                callbacks.onSubAgentMessage?.(msg);
+            },
+            onSubAgentUpdateMessage: callbacks.onSubAgentUpdateMessage,
         };
         try {
             this.transcript = await this.workerBridge.run(userInput, this.transcript, bridgeCallbacks);
+            logInfo('query.completed', {
+                sessionId: this.session.id,
+                transcriptLength: this.transcript.length,
+                totalTokens: this.session.totalTokens,
+            });
         }
         catch (err) {
+            logError('query.failed', err, { sessionId: this.session.id });
             const errMsg = {
                 id: uuid(),
                 type: 'error',
@@ -93,10 +128,12 @@ export class QueryEngine {
     }
     /** 终止当前任务（通知 Worker 中断） */
     abort() {
+        logWarn('query.abort_requested', { sessionId: this.session.id });
         this.workerBridge.abort();
     }
     /** 重置会话 */
     reset() {
+        logInfo('session.reset', { sessionId: this.session.id });
         this.saveSession();
         this.session = this.createSession();
         this.transcript = [];
@@ -106,25 +143,22 @@ export class QueryEngine {
      * 切换智能体：持久化选择 + 重建 LLM service + 重置会话
      */
     switchAgent(agentName) {
+        logInfo('agent.switch.start', {
+            fromSessionId: this.session.id,
+            agentName,
+        });
         setActiveAgent(agentName);
         // 重建 LLM service 以加载新 agent 的 system prompt
-        const config = loadConfig();
-        const activeModel = getActiveModel(config);
-        if (activeModel) {
-            try {
-                this.service = new LLMServiceImpl();
-            }
-            catch {
-                this.service = new MockService();
-            }
-        }
-        else {
-            this.service = new MockService();
-        }
+        this.service = this.createService();
         // 重置会话上下文
         this.saveSession();
         this.session = this.createSession();
         this.transcript = [];
+        logInfo('agent.switch.completed', {
+            sessionId: this.session.id,
+            agentName,
+            service: this.service.constructor.name,
+        });
     }
     /** 保存会话到文件 */
     saveSession() {
@@ -138,8 +172,15 @@ export class QueryEngine {
             }
             const filePath = path.join(SESSIONS_DIR, `${this.session.id}.json`);
             fs.writeFileSync(filePath, JSON.stringify(this.session, null, 2), 'utf-8');
+            logInfo('session.saved', {
+                sessionId: this.session.id,
+                filePath,
+                messageCount: this.session.messages.length,
+            });
+        }
+        catch (error) {
+            logError('session.save_failed', error, { sessionId: this.session.id });
         }
-        catch { /* 静默失败 */ }
     }
     /** 列出所有历史会话（按更新时间倒序），返回摘要信息 */
     static listSessions() {
@@ -210,9 +251,15 @@ export class QueryEngine {
                     });
                 }
             }
+            logInfo('session.loaded', {
+                sessionId,
+                messageCount: cleanedMessages.length,
+                transcriptLength: this.transcript.length,
+            });
             return { session: this.session, messages: cleanedMessages };
         }
-        catch {
+        catch (error) {
+            logError('session.load_failed', error, { sessionId });
             return null;
         }
     }
@@ -239,9 +286,14 @@ export class QueryEngine {
                 }
                 catch { /* 跳过删除失败的文件 */ }
             }
+            logInfo('session.clear_others', {
+                sessionId: this.session.id,
+                removedCount: count,
+            });
             return count;
         }
-        catch {
+        catch (error) {
+            logError('session.clear_others_failed', error, { sessionId: this.session.id });
             return 0;
         }
     }

package/dist/core/SubAgentBridge.d.ts

@@ -0,0 +1,20 @@
+import { Message, LoopState, SubAgentTask, SubAgentResult } from '../types/index.js';
+import { DangerConfirmResult } from './query.js';
+export interface SubAgentBridgeCallbacks {
+    onMessage: (taskId: string, msg: Message) => void;
+    onUpdateMessage: (taskId: string, id: string, updates: Partial<Message>) => void;
+    onStreamText: (taskId: string, text: string) => void;
+    onLoopStateChange: (taskId: string, state: LoopState) => void;
+    /** 危险命令确认，委托给主线程 UI */
+    onConfirmDangerousCommand?: (taskId: string, command: string, reason: string, ruleName: string) => Promise<DangerConfirmResult>;
+}
+export declare class SubAgentBridge {
+    private worker;
+    /**
+     * 在独立 Worker 线程中执行 SubAgent 任务
+     * @returns SubAgentResult（包含最终输出、消息列表、transcript）
+     */
+    run(task: SubAgentTask, callbacks: SubAgentBridgeCallbacks): Promise<SubAgentResult>;
+    /** 中断 SubAgent 执行 */
+    abort(): void;
+}

package/dist/core/SubAgentBridge.js

@@ -0,0 +1,208 @@
+/**
+ * SubAgentBridge — 单个 SubAgent 的 Worker 线程桥接
+ *
+ * 职责：
+ *   - 创建并管理 SubAgent Worker 线程
+ *   - 转发 Worker 事件到上层回调
+ *   - 处理危险命令确认的双向通信
+ *   - 代理 MessageBus publish/subscribe 请求（跨线程通讯）
+ *   - 支持中断
+ */
+import { Worker } from 'worker_threads';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { agentMessageBus } from './AgentMessageBus.js';
+import { logError, logInfo, logWarn } from './logger.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/** 创建 SubAgent Worker（兼容 tsx 开发模式与编译后 .js） */
+function createSubAgentWorker() {
+    const workerTsPath = path.join(__dirname, 'subAgentWorker.ts');
+    const isTsx = __filename.endsWith('.ts');
+    if (isTsx) {
+        const inlineScript = `
+import { tsImport } from 'tsx/esm/api';
+import { workerData } from 'worker_threads';
+import { pathToFileURL } from 'url';
+await tsImport(workerData.__workerFile, pathToFileURL(workerData.__workerFile).href);
+`;
+        return new Worker(inlineScript, {
+            eval: true,
+            workerData: { __workerFile: workerTsPath },
+        });
+    }
+    return new Worker(workerTsPath.replace(/\.ts$/, '.js'));
+}
+export class SubAgentBridge {
+    worker = null;
+    /**
+     * 在独立 Worker 线程中执行 SubAgent 任务
+     * @returns SubAgentResult（包含最终输出、消息列表、transcript）
+     */
+    run(task, callbacks) {
+        return new Promise((resolve, reject) => {
+            const worker = createSubAgentWorker();
+            this.worker = worker;
+            logInfo('subagent_bridge.run.start', {
+                taskId: task.taskId,
+                allowedTools: task.allowedTools,
+            });
+            // 收集 SubAgent 产生的所有消息，用于汇总结果
+            const collectedMessages = [];
+            let finalTranscript = [];
+            worker.on('message', async (msg) => {
+                switch (msg.type) {
+                    case 'message':
+                        collectedMessages.push(msg.msg);
+                        callbacks.onMessage(msg.taskId, msg.msg);
+                        break;
+                    case 'update_message':
+                        callbacks.onUpdateMessage(msg.taskId, msg.id, msg.updates);
+                        break;
+                    case 'stream_text':
+                        callbacks.onStreamText(msg.taskId, msg.text);
+                        break;
+                    case 'loop_state':
+                        callbacks.onLoopStateChange(msg.taskId, msg.state);
+                        break;
+                    case 'danger_confirm_request': {
+                        const choice = callbacks.onConfirmDangerousCommand
+                            ? await callbacks.onConfirmDangerousCommand(msg.taskId, msg.command, msg.reason, msg.ruleName)
+                            : 'cancel';
+                        const reply = {
+                            type: 'danger_confirm_result',
+                            requestId: msg.requestId,
+                            choice,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    // ===== MessageBus IPC 代理 =====
+                    case 'bus_publish': {
+                        agentMessageBus.publish(msg.from, msg.channel, msg.payload);
+                        const ack = { type: 'bus_publish_ack', requestId: msg.requestId };
+                        worker.postMessage(ack);
+                        break;
+                    }
+                    case 'bus_subscribe': {
+                        // 在主线程侧等待消息，结果回传 Worker
+                        agentMessageBus.subscribe(msg.channel, msg.timeoutMs, msg.fromOffset).then((busMsg) => {
+                            const reply = {
+                                type: 'bus_subscribe_result',
+                                requestId: msg.requestId,
+                                message: busMsg,
+                            };
+                            worker.postMessage(reply);
+                        });
+                        break;
+                    }
+                    case 'bus_read_history': {
+                        const history = agentMessageBus.getHistory(msg.channel, msg.limit);
+                        const reply = {
+                            type: 'bus_read_history_result',
+                            requestId: msg.requestId,
+                            messages: history,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    case 'bus_get_offset': {
+                        const offset = agentMessageBus.getOffset(msg.channel);
+                        const reply = {
+                            type: 'bus_get_offset_result',
+                            requestId: msg.requestId,
+                            offset,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    case 'bus_list_channels': {
+                        const channels = agentMessageBus.listChannels();
+                        const reply = {
+                            type: 'bus_list_channels_result',
+                            requestId: msg.requestId,
+                            channels,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    case 'done':
+                        finalTranscript = msg.transcript;
+                        this.worker = null;
+                        worker.terminate();
+                        logInfo('subagent_bridge.run.done', {
+                            taskId: msg.taskId,
+                            transcriptLength: msg.transcript.length,
+                            messageCount: collectedMessages.length,
+                        });
+                        // 从 transcript 中提取最终输出文本
+                        resolve({
+                            taskId: msg.taskId,
+                            status: 'done',
+                            output: extractFinalOutput(msg.transcript),
+                            messages: collectedMessages,
+                            transcript: finalTranscript,
+                        });
+                        break;
+                    case 'error':
+                        this.worker = null;
+                        worker.terminate();
+                        logError('subagent_bridge.run.failed', msg.message, {
+                            taskId: msg.taskId,
+                            messageCount: collectedMessages.length,
+                        });
+                        resolve({
+                            taskId: msg.taskId,
+                            status: 'error',
+                            output: '',
+                            messages: collectedMessages,
+                            transcript: finalTranscript,
+                            error: msg.message,
+                        });
+                        break;
+                }
+            });
+            worker.on('error', (err) => {
+                this.worker = null;
+                logError('subagent_bridge.worker_error', err, { taskId: task.taskId });
+                reject(err);
+            });
+            worker.on('exit', (code) => {
+                if (this.worker) {
+                    // Worker 退出但未发送 done/error，说明异常终止
+                    this.worker = null;
+                    logError('subagent_bridge.worker_exit_abnormal', undefined, { taskId: task.taskId, code });
+                    reject(new Error(`SubAgent Worker 意外退出，code=${code}`));
+                }
+            });
+            const runMsg = { type: 'run', task };
+            worker.postMessage(runMsg);
+        });
+    }
+    /** 中断 SubAgent 执行 */
+    abort() {
+        if (this.worker) {
+            logWarn('subagent_bridge.abort_forwarded');
+            const msg = { type: 'abort' };
+            this.worker.postMessage(msg);
+        }
+    }
+}
+/** 从 transcript 中提取最后一条 assistant 文本作为最终输出 */
+function extractFinalOutput(transcript) {
+    for (let i = transcript.length - 1; i >= 0; i--) {
+        const msg = transcript[i];
+        if (msg.role === 'assistant') {
+            if (typeof msg.content === 'string')
+                return msg.content;
+            // ContentBlock[] — 取最后一个 text block
+            const blocks = msg.content;
+            for (let j = blocks.length - 1; j >= 0; j--) {
+                if (blocks[j].type === 'text' && blocks[j].text) {
+                    return blocks[j].text;
+                }
+            }
+        }
+    }
+    return '';
+}

package/dist/core/WorkerBridge.js

@@ -5,6 +5,9 @@
 import { Worker } from 'worker_threads';
 import { fileURLToPath } from 'url';
 import path from 'path';
+import { agentMessageBus } from './AgentMessageBus.js';
+import { spawnSubAgentInMainThread } from '../tools/spawnAgent.js';
+import { logError, logInfo, logWarn } from './logger.js';
 // 兼容 ESM __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -39,6 +42,10 @@ export class WorkerBridge {
             const workerTsPath = path.join(__dirname, 'queryWorker.ts');
             const worker = createWorker(workerTsPath);
             this.worker = worker;
+            logInfo('worker_bridge.run.start', {
+                inputLength: userInput.length,
+                transcriptLength: transcript.length,
+            });
             worker.on('message', async (msg) => {
                 switch (msg.type) {
                     case 'message':
@@ -72,25 +79,97 @@ export class WorkerBridge {
                         worker.postMessage(reply);
                         break;
                     }
+                    case 'subagent_message':
+                        // SubAgent 消息：推送到 UI（已携带 subAgentId）
+                        callbacks.onSubAgentMessage?.(msg.msg);
+                        break;
+                    case 'subagent_update_message':
+                        callbacks.onSubAgentUpdateMessage?.(msg.id, msg.updates);
+                        break;
+                    // ===== MessageBus IPC 代理（queryWorker → 主线程） =====
+                    case 'bus_publish': {
+                        agentMessageBus.publish(msg.from, msg.channel, msg.payload);
+                        const ack = { type: 'bus_publish_ack', requestId: msg.requestId };
+                        worker.postMessage(ack);
+                        break;
+                    }
+                    case 'bus_subscribe': {
+                        agentMessageBus.subscribe(msg.channel, msg.timeoutMs, msg.fromOffset).then((busMsg) => {
+                            const reply = {
+                                type: 'bus_subscribe_result',
+                                requestId: msg.requestId,
+                                message: busMsg,
+                            };
+                            worker.postMessage(reply);
+                        });
+                        break;
+                    }
+                    case 'bus_read_history': {
+                        const history = agentMessageBus.getHistory(msg.channel, msg.limit);
+                        const reply = {
+                            type: 'bus_read_history_result',
+                            requestId: msg.requestId,
+                            messages: history,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    case 'bus_get_offset': {
+                        const offset = agentMessageBus.getOffset(msg.channel);
+                        const reply = {
+                            type: 'bus_get_offset_result',
+                            requestId: msg.requestId,
+                            offset,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    case 'bus_list_channels': {
+                        const channels = agentMessageBus.listChannels();
+                        const reply = {
+                            type: 'bus_list_channels_result',
+                            requestId: msg.requestId,
+                            channels,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    // ===== spawn_subagent IPC（在主线程创建 SubAgentBridge）=====
+                    case 'spawn_subagent': {
+                        const result = spawnSubAgentInMainThread(msg.taskId, msg.instruction, msg.agentLabel, msg.allowedTools);
+                        const reply = {
+                            type: 'spawn_subagent_result',
+                            requestId: msg.requestId,
+                            result,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
                     case 'done':
                         this.worker = null;
                         worker.terminate();
+                        logInfo('worker_bridge.run.done', {
+                            transcriptLength: msg.transcript.length,
+                        });
                         resolve(msg.transcript);
                         break;
                     case 'error':
                         this.worker = null;
                         worker.terminate();
+                        logError('worker_bridge.run.error', msg.message);
                         reject(new Error(msg.message));
                         break;
                 }
             });
             worker.on('error', (err) => {
                 this.worker = null;
+                logError('worker_bridge.worker_error', err);
                 reject(err);
             });
             worker.on('exit', (code) => {
                 if (code !== 0 && this.worker) {
                     this.worker = null;
+                    logError('worker_bridge.worker_exit_abnormal', undefined, { code });
                     reject(new Error(`Worker 异常退出，code=${code}`));
                 }
             });
@@ -102,6 +181,7 @@ export class WorkerBridge {
     /** 向 Worker 发送中断信号 */
     abort() {
         if (this.worker) {
+            logWarn('worker_bridge.abort_forwarded');
             const msg = { type: 'abort' };
             this.worker.postMessage(msg);
         }

package/dist/core/busAccess.d.ts

@@ -0,0 +1,9 @@
+import type { BusMessage } from './AgentMessageBus.js';
+export interface BusAccessor {
+    publish(from: string, channel: string, payload: string): Promise<void> | void;
+    subscribe(channel: string, timeoutMs?: number, fromOffset?: number): Promise<BusMessage | null>;
+    getHistory(channel: string, limit?: number): Promise<BusMessage[]> | BusMessage[];
+    getOffset(channel: string): Promise<number> | number;
+    listChannels(): Promise<string[]> | string[];
+}
+export declare function getBus(): Promise<BusAccessor>;

package/dist/core/busAccess.js

@@ -0,0 +1,32 @@
+/**
+ * busAccess — 统一的 MessageBus 访问入口
+ *
+ * 解决跨线程访问问题：
+ *   - 主线程：直接使用 agentMessageBus 单例
+ *   - SubAgent Worker 线程：使用 workerBusProxy（通过 IPC 代理到主线程）
+ *
+ * 工具层统一通过此模块访问，无需关心当前运行环境。
+ */
+import { isMainThread } from 'worker_threads';
+let _bus = null;
+export async function getBus() {
+    if (_bus)
+        return _bus;
+    if (isMainThread) {
+        // 主线程：直接使用单例
+        const { agentMessageBus } = await import('./AgentMessageBus.js');
+        _bus = {
+            publish: (from, channel, payload) => { agentMessageBus.publish(from, channel, payload); },
+            subscribe: (channel, timeoutMs, fromOffset) => agentMessageBus.subscribe(channel, timeoutMs, fromOffset),
+            getHistory: (channel, limit) => agentMessageBus.getHistory(channel, limit),
+            getOffset: (channel) => agentMessageBus.getOffset(channel),
+            listChannels: () => agentMessageBus.listChannels(),
+        };
+    }
+    else {
+        // Worker 线程：使用独立的 IPC 代理模块（避免循环依赖）
+        const { workerBusProxy } = await import('./workerBusProxy.js');
+        _bus = workerBusProxy;
+    }
+    return _bus;
+}

package/dist/core/logger.d.ts

@@ -0,0 +1,8 @@
+export type LogLevel = 'INFO' | 'WARN' | 'ERROR';
+export interface LogPayload {
+    [key: string]: unknown;
+}
+export declare function ensureLoggerReady(): string;
+export declare function logInfo(event: string, payload?: LogPayload): void;
+export declare function logWarn(event: string, payload?: LogPayload): void;
+export declare function logError(event: string, error?: unknown, payload?: LogPayload): void;

package/dist/core/logger.js

@@ -0,0 +1,63 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { isMainThread, threadId } from 'worker_threads';
+function resolveLogsDir() {
+    return path.join(os.homedir(), '.jarvis', 'logs');
+}
+function ensureLogsDir() {
+    const logsDir = resolveLogsDir();
+    if (!fs.existsSync(logsDir)) {
+        fs.mkdirSync(logsDir, { recursive: true });
+    }
+    return logsDir;
+}
+function getLogFilePath(date = new Date()) {
+    const logsDir = ensureLogsDir();
+    const day = date.toISOString().slice(0, 10);
+    return path.join(logsDir, `${day}.log`);
+}
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        };
+    }
+    return { message: String(error) };
+}
+function writeLog(level, event, payload = {}) {
+    try {
+        const now = new Date();
+        const line = JSON.stringify({
+            timestamp: now.toISOString(),
+            level,
+            event,
+            pid: process.pid,
+            threadId,
+            workerType: isMainThread ? 'main' : 'worker',
+            cwd: process.cwd(),
+            ...payload,
+        });
+        fs.appendFileSync(getLogFilePath(now), `${line}\n`, 'utf-8');
+    }
+    catch {
+        // 日志系统自身不能影响主流程
+    }
+}
+export function ensureLoggerReady() {
+    return ensureLogsDir();
+}
+export function logInfo(event, payload) {
+    writeLog('INFO', event, payload);
+}
+export function logWarn(event, payload) {
+    writeLog('WARN', event, payload);
+}
+export function logError(event, error, payload = {}) {
+    writeLog('ERROR', event, {
+        ...payload,
+        ...(error !== undefined ? { error: normalizeError(error) } : {}),
+    });
+}

package/dist/core/query.d.ts

@@ -15,6 +15,10 @@ export interface QueryCallbacks {
      * @param ruleName 匹配的规则名
      */
     onConfirmDangerousCommand?: (command: string, reason: string, ruleName: string) => Promise<DangerConfirmResult>;
+    /** SubAgent 产生消息时透传到主线程 UI（由 dispatch_subagent 工具触发） */
+    onSubAgentMessage?: (msg: Message) => void;
+    /** SubAgent 更新已有消息时透传 */
+    onSubAgentUpdateMessage?: (id: string, updates: Partial<Message>) => void;
 }
 /**
  * 单轮 Agentic Loop：推理 → 工具调用 → 循环