ai-helper-agent 1.9.3 → 1.9.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-helper-agent",
-  "version": "1.9.3",
+  "version": "1.9.5",
   "description": "AI Helper 代理服务 - 为 Chrome 扩展提供本地文件读写和系统命令执行能力",
   "type": "module",
   "main": "./src/server.js",

package/src/config.js

@@ -13,8 +13,8 @@ const MEMORY_DIR = join(AGENT_DIR, 'memory');
 const DEFAULTS = {
   port: 18910,
   host: '127.0.0.1',
-  workdir: process.cwd(),
-  allowedPaths: [],
+  workdir: WORKSPACE_DIR,
+  allowedPaths: [WORKSPACE_DIR],
   pairCodeTTL: 30,
   commandTimeout: 300000,
   fileMaxSize: 50 * 1024 * 1024
@@ -103,6 +103,11 @@ export function loadConfig() {
     configCache.allowedPaths.push(SKILLS_DIR);
   }
 
+  // 自动将 workspace 目录加入白名单，确保 AI 可以访问工作目录
+  if (!configCache.allowedPaths.includes(WORKSPACE_DIR)) {
+    configCache.allowedPaths.push(WORKSPACE_DIR);
+  }
+
   return configCache;
 }
 

package/src/executor.js

@@ -51,9 +51,14 @@ function getShellForExec() {
   return { shell: '/bin/bash', args: ['-c'] };
 }
 
-// 运行中的进程映射：execId → { process, wsClients: Set, timeoutId, forceKillId }
+// 运行中的进程映射：execId → { process, wsClients: Set, timeoutId, forceKillId, stdoutBuf, stderrBuf }
 const runningProcesses = new Map();
 
+// 已完成进程缓存（解决竞态条件：进程完成太快，WebSocket 客户端来不及连接）
+// execId → { stdoutBuf, stderrBuf, exitCode, killed, cleanupTimeout }
+const completedProcesses = new Map();
+const COMPLETED_CACHE_TTL = 30000; // 30秒后清理
+
 // 安全的子进程环境变量白名单（不泄露宿主敏感信息）
 const SAFE_ENV_KEYS = [
   'PATH', 'HOME', 'USER', 'SHELL', 'TERM', 'LANG', 'LC_ALL', 'LC_CTYPE',
@@ -127,7 +132,8 @@ function executeCommand(command, cwd, wsClient, onComplete, collectOutput = fals
   let finished = false; // 防止 close/error 重复处理
 
   // 存储到 entry 中供 clearTimers 读取
-  const entry = { process: proc, wsClients };
+  // stdoutBuf/stderrBuf 始终收集，用于回放给延迟连接的 WS 客户端
+  const entry = { process: proc, wsClients, stdoutBuf: '', stderrBuf: '' };
   runningProcesses.set(execId, entry);
 
   // 超时控制
@@ -160,6 +166,7 @@ function executeCommand(command, cwd, wsClient, onComplete, collectOutput = fals
   proc.stdout.on('data', (chunk) => {
     const str = chunk.toString();
     if (collectOutput) stdoutCollected += str;
+    entry.stdoutBuf += str;
     broadcast({ type: 'stdout', data: str, execId });
   });
 
@@ -167,6 +174,7 @@ function executeCommand(command, cwd, wsClient, onComplete, collectOutput = fals
   proc.stderr.on('data', (chunk) => {
     const str = chunk.toString();
     if (collectOutput) stderrCollected += str;
+    entry.stderrBuf += str;
     broadcast({ type: 'stderr', data: str, execId });
   });
 
@@ -175,12 +183,24 @@ function executeCommand(command, cwd, wsClient, onComplete, collectOutput = fals
     if (finished) return;
     finished = true;
     clearTimers();
-    broadcast({ type: 'exit', exitCode: typeof exitCode === 'number' ? exitCode : -1, execId, killed });
+    const finalExitCode = typeof exitCode === 'number' ? exitCode : -1;
+    broadcast({ type: 'exit', exitCode: finalExitCode, execId, killed });
+    // 移入已完成缓存，解决竞态条件：延迟连接的 WS 客户端可回放输出
+    const cleanupTimeout = setTimeout(() => {
+      completedProcesses.delete(execId);
+    }, COMPLETED_CACHE_TTL);
+    completedProcesses.set(execId, {
+      stdoutBuf: entry.stdoutBuf,
+      stderrBuf: entry.stderrBuf,
+      exitCode: finalExitCode,
+      killed,
+      cleanupTimeout
+    });
     runningProcesses.delete(execId);
     if (onComplete) {
       onComplete({
         execId,
-        exitCode: typeof exitCode === 'number' ? exitCode : -1,
+        exitCode: finalExitCode,
         killed,
         stdout: collectOutput ? stdoutCollected : undefined,
         stderr: collectOutput ? stderrCollected : undefined
@@ -194,6 +214,18 @@ function executeCommand(command, cwd, wsClient, onComplete, collectOutput = fals
     finished = true;
     clearTimers();
     broadcast({ type: 'error', error: err.message, execId });
+    // 移入已完成缓存
+    const cleanupTimeout = setTimeout(() => {
+      completedProcesses.delete(execId);
+    }, COMPLETED_CACHE_TTL);
+    completedProcesses.set(execId, {
+      stdoutBuf: entry.stdoutBuf,
+      stderrBuf: entry.stderrBuf,
+      exitCode: -1,
+      killed: false,
+      error: err.message,
+      cleanupTimeout
+    });
     runningProcesses.delete(execId);
     if (onComplete) {
       onComplete({
@@ -241,6 +273,7 @@ function executeCommandSync(command, cwd) {
 
 /**
  * 添加 WebSocket 客户端到已有进程的监听中
+ * 如果进程已结束，从 completedProcesses 缓存回放全部输出
  */
 function addWsClient(execId, wsClient) {
   const entry = runningProcesses.get(execId);
@@ -248,6 +281,23 @@ function addWsClient(execId, wsClient) {
     entry.wsClients.add(wsClient);
     return true;
   }
+  // 进程已结束，检查缓存并回放全部输出
+  const completed = completedProcesses.get(execId);
+  if (completed) {
+    if (completed.stdoutBuf) {
+      wsClient.send(JSON.stringify({ type: 'stdout', data: completed.stdoutBuf, execId }));
+    }
+    if (completed.stderrBuf) {
+      wsClient.send(JSON.stringify({ type: 'stderr', data: completed.stderrBuf, execId }));
+    }
+    if (completed.error) {
+      wsClient.send(JSON.stringify({ type: 'error', error: completed.error, execId }));
+    }
+    wsClient.send(JSON.stringify({ type: 'exit', exitCode: completed.exitCode, execId, killed: completed.killed }));
+    clearTimeout(completed.cleanupTimeout);
+    completedProcesses.delete(execId);
+    return true;
+  }
   return false;
 }
 

package/src/mcp/client.js

@@ -97,8 +97,7 @@ export class McpClient {
       const toolsResult = await this.client.listTools({});
       if (toolsResult && toolsResult.tools) {
         this.tools = toolsResult.tools;
-        console.log(`[MCP:${this.serverId}] 发现 ${this.tools.length} 个工具:`,
-          this.tools.map(t => t.name).join(', '));
+        console.log(`[MCP:${this.serverId}] 发现 ${this.tools.length} 个工具`);
       } else {
         this.tools = [];
       }

package/src/server.js

@@ -966,6 +966,14 @@ export function startServer() {
     jsonResponse(res, 404, { success: false, error: '未知的 API 路径' });
   }
 
+  // 追踪所有活跃 socket 连接，用于优雅关闭时强制断开
+  const activeSockets = new Set();
+
+  server.on('connection', (socket) => {
+    activeSockets.add(socket);
+    socket.on('close', () => activeSockets.delete(socket));
+  });
+
   // ==================== WebSocket Server ====================
   const wss = new WebSocketServer({ noServer: true });
 
@@ -1000,6 +1008,9 @@ export function startServer() {
         const added = addWsClient(execId, ws);
         if (!added) {
           ws.send(JSON.stringify({ type: 'error', error: '进程不存在或已结束', execId }));
+          // 进程已不存在，发送错误后关闭 WebSocket，避免客户端空等
+          ws.close();
+          return;
         }
         // 客户端断开时，从监听列表中移除；所有客户端都断开后取消超时
         ws.on('close', () => {
@@ -1042,11 +1053,19 @@ export function startServer() {
     }
   });
 
-  // 优雅关闭（异步 + 防并发）
+  // 优雅关闭（异步 + 防并发 + 超时兜底）
   async function shutdown() {
     if (shuttingDown) return;
     shuttingDown = true;
     console.log('[Agent] 正在关闭...');
+
+    // 超时兜底：10 秒后强制退出，防止 server.close() 等待连接挂起
+    const forceExitTimer = setTimeout(() => {
+      console.log('[Agent] 优雅关闭超时，强制退出');
+      process.exit(1);
+    }, 10000);
+    forceExitTimer.unref();
+
     stopPairCodeRotation();
 
     // 终止所有运行中的进程
@@ -1057,6 +1076,16 @@ export function startServer() {
     // 关闭所有 MCP 连接
     try { await shutdownMcpRegistry(); } catch {}
 
+    // 强制断开所有 WebSocket 客户端
+    wss.clients.forEach((client) => {
+      try { client.terminate(); } catch {}
+    });
+
+    // 强制销毁所有活跃 HTTP socket，避免 server.close() 挂起等待
+    for (const socket of activeSockets) {
+      try { socket.destroy(); } catch {}
+    }
+
     // 等待 server 和 wss 关闭
     await Promise.all([
       new Promise(resolve => server.close(resolve)),
@@ -1066,6 +1095,7 @@ export function startServer() {
     // 清理 PID 文件
     try { if (await exists(PID_FILE)) await unlink(PID_FILE); } catch {}
 
+    clearTimeout(forceExitTimer);
     logSystem('server_stop', { reason: 'shutdown' });
     process.exit(0);
   }

package/src/skill/loader.js

@@ -174,7 +174,6 @@ export function loadAllSkills() {
       if (skill) {
         skill.type = 'workflow';
         allSkills.push(skill);
-        console.log(`[Skill Loader] 加载 Workflow Skill: "${skill.name}" v${skill.version} (${skill.steps.length} 步骤)`);
       }
     }
   }

package/src/skill/markdown-loader.js

@@ -197,7 +197,6 @@ export function loadAllMarkdownSkills(skillsDir) {
       const skill = loadMarkdownSkill(entryPath);
       if (skill) {
         skills.push(skill);
-        console.log(`[Markdown Loader] 加载 Agent Skill: "${skill.name}" v${skill.version} (${skill.resources.length} 个资源)`);
       }
     } catch { /* skip */ }
   }

package/src/skill/registry.js

@@ -75,12 +75,10 @@ export function initializeSkillRegistry() {
   skills.clear();
 
   // 0. 种子写入 skill-creator 到文件系统（首次运行或版本升级时）
-  const seeded = seedSkillCreator();
-  console.log(`[Skill Registry] seedSkillCreator 返回: ${seeded}`);
+  seedSkillCreator();
 
   // 1. 加载文件系统中的技能
   const loaded = loadAllSkills();
-  console.log(`[Skill Registry] loadAllSkills 返回 ${loaded.length} 个技能: ${loaded.map(s => s.name).join(', ') || '(无)'}`);
 
   for (const skill of loaded) {
     skills.set(skill.name, skill);
@@ -91,7 +89,6 @@ export function initializeSkillRegistry() {
   for (const skill of builtinSkills) {
     if (!skills.has(skill.name)) {
       skills.set(skill.name, skill);
-      console.log(`[Skill Registry] 注册内置 Skill: "${skill.name}"`);
     }
   }
 
@@ -212,7 +209,12 @@ export function getAgentSkillPrompts() {
   const parts = [];
   parts.push('## 可用技能 (Skills)');
   parts.push('');
-  parts.push('以下是可用的 Agent Skill（AI 能力扩展）列表。当用户需求匹配某个技能时，使用 `agent_skill_load` 工具加载该技能的完整说明，然后由 AI 根据说明自主调用相关工具完成任务。');
+  parts.push('以下是可用的 Agent Skill（AI 能力扩展）列表。当用户需求与某个技能高度匹配时，使用 `agent_skill_load` 工具加载该技能的完整说明，然后根据说明自主完成任务。');
+  parts.push('');
+  parts.push('**使用策略**：');
+  parts.push('- 仅在用户需求明确匹配技能描述时才加载，不要为一般性的编程/技术问题加载技能');
+  parts.push('- 一次只加载一个技能，加载后根据 SKILL.md 说明执行');
+  parts.push('- 技能加载会消耗较多 token，避免无故加载');
   parts.push('');
 
   for (const skill of agentSkills) {