ai-helper-agent 1.9.1 → 1.9.3

package/package.json

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

package/src/executor.js

@@ -1,5 +1,5 @@
 // agent/src/executor.js - 命令执行器（child_process + 流式输出）
-import { spawn } from 'child_process';
+import { spawn, exec } from 'child_process';
 import crypto from 'crypto';
 import os from 'os';
 import { loadConfig } from './config.js';
@@ -252,7 +252,33 @@ function addWsClient(execId, wsClient) {
 }
 
 /**
- * 停止正在运行的命令
+ * 断开 WebSocket 客户端连接
+ * 当所有客户端都断开后，取消超时定时器，让进程自由运行（不再自动杀）
+ */
+function disconnectWsClient(execId, wsClient) {
+  const entry = runningProcesses.get(execId);
+  if (!entry) return false;
+
+  entry.wsClients.delete(wsClient);
+
+  // 所有客户端都断开了 → 取消超时，进程继续运行
+  if (entry.wsClients.size === 0) {
+    if (entry.timeoutId) {
+      clearTimeout(entry.timeoutId);
+      entry.timeoutId = null;
+    }
+    if (entry.forceKillId) {
+      clearTimeout(entry.forceKillId);
+      entry.forceKillId = null;
+    }
+  }
+  return true;
+}
+
+/**
+ * 停止正在运行的命令（跨平台兼容）
+ * - macOS/Linux: SIGTERM（优雅终止）→ 5s → SIGKILL（强制杀）
+ * - Windows: taskkill /PID（优雅终止）→ 5s → taskkill /F /PID（强制杀）
  */
 function killProcess(execId) {
   const entry = runningProcesses.get(execId);
@@ -260,11 +286,25 @@ function killProcess(execId) {
 
   if (entry.process.exitCode !== null) return false; // 已退出
 
-  try {
-    entry.process.kill('SIGTERM');
-  } catch {}
+  const isWin = os.platform() === 'win32';
+  const pid = entry.process.pid;
+
+  if (isWin) {
+    // Windows: taskkill 支持优雅终止（/PID 发送 WM_CLOSE）和强制终止（/F）
+    exec(`taskkill /PID ${pid}`, (err) => {
+      if (err) {
+        // 尝试强制杀
+        exec(`taskkill /F /PID ${pid}`, () => {});
+      }
+    });
+  } else {
+    // macOS/Linux: SIGTERM 优雅终止
+    try {
+      entry.process.kill('SIGTERM');
+    } catch {}
+  }
 
-  // 5秒后强制 kill（绑定到 entry 对象防止闭包引用旧变量）
+  // 清理旧的定时器
   if (entry.timeoutId) {
     clearTimeout(entry.timeoutId);
     entry.timeoutId = null;
@@ -272,10 +312,16 @@ function killProcess(execId) {
   if (entry.forceKillId) {
     clearTimeout(entry.forceKillId);
   }
+
+  // 5秒后强制杀（绑定到 entry 对象防止闭包引用旧变量）
   entry.forceKillId = setTimeout(() => {
     try {
       if (entry.process.exitCode === null) {
-        entry.process.kill('SIGKILL');
+        if (isWin) {
+          exec(`taskkill /F /PID ${pid}`, () => {});
+        } else {
+          entry.process.kill('SIGKILL');
+        }
       }
     } catch {}
     entry.forceKillId = null;
@@ -295,4 +341,4 @@ function getRunningProcesses() {
   return list;
 }
 
-export { executeCommand, executeCommandSync, addWsClient, killProcess, getRunningProcesses };
+export { executeCommand, executeCommandSync, addWsClient, disconnectWsClient, killProcess, getRunningProcesses };

package/src/mcp/client.js

@@ -143,15 +143,20 @@ export class McpClient {
     }
   }
 
-  disconnect() {
+  async disconnect() {
     this.connected = false;
     this.tools = [];
 
     if (this.client) {
-      try { this.client.close(); } catch {}
+      try { await this.client.close(); } catch {}
       this.client = null;
     }
 
+    if (this.transport) {
+      try { await this.transport.close(); } catch {}
+      this.transport = null;
+    }
+
     console.log(`[MCP:${this.serverId}] 已断开连接`);
   }
 

package/src/mcp/registry.js

@@ -124,7 +124,7 @@ export async function connectMcpServer(serverId) {
   // 先断开已有连接
   const existingClient = clients.get(serverId);
   if (existingClient) {
-    existingClient.disconnect();
+    await existingClient.disconnect();
     clients.delete(serverId);
   }
 
@@ -140,10 +140,10 @@ export async function connectMcpServer(serverId) {
 /**
  * 断开指定 MCP Server
  */
-export function disconnectMcpServer(serverId) {
+export async function disconnectMcpServer(serverId) {
   const client = clients.get(serverId);
   if (client) {
-    client.disconnect();
+    await client.disconnect();
     clients.delete(serverId);
     return { success: true };
   }
@@ -153,10 +153,10 @@ export function disconnectMcpServer(serverId) {
 /**
  * 关闭所有 MCP 连接（Agent 关闭时调用）
  */
-export function shutdownMcpRegistry() {
+export async function shutdownMcpRegistry() {
   console.log('[MCP Registry] 关闭所有 MCP 连接...');
   for (const [id, client] of clients) {
-    try { client.disconnect(); } catch {}
+    try { await client.disconnect(); } catch {}
   }
   clients.clear();
 }

package/src/search.js

@@ -1,6 +1,6 @@
 // agent/src/search.js - 文件搜索（fd/rg 优先 + Node.js 回退）
 import { spawn } from 'child_process';
-import { readdirSync, statSync, readFileSync, existsSync } from 'fs';
+import { readdir, stat, readFile } from 'fs/promises';
 import { join, basename, extname, resolve } from 'path';
 import { checkPath } from './security.js';
 
@@ -124,19 +124,29 @@ function searchWithFd(rootPath, filePattern, recursive, maxResults) {
 }
 
 /**
- * Node.js 原生递归搜索文件（回退方案）
+ * 让出事件循环，防止长时间同步操作阻塞其他请求
  */
-function searchFilesNative(rootPath, filePattern, recursive, maxResults) {
+function yieldEventLoop() {
+  return new Promise(resolve => setImmediate(resolve));
+}
+
+/**
+ * Node.js 原生递归搜索文件（回退方案，异步 + 分片防止阻塞事件循环）
+ */
+async function searchFilesNative(rootPath, filePattern, recursive, maxResults) {
   const results = [];
 
-  function walk(dir, depth) {
+  async function walk(dir, depth) {
     if (results.length >= maxResults) return;
     if (!recursive && depth > 1) return;
 
     let entries;
-    try { entries = readdirSync(dir, { withFileTypes: true }); }
+    try { entries = await readdir(dir, { withFileTypes: true }); }
     catch { return; }
 
+    // 每处理一个目录后让出事件循环
+    await yieldEventLoop();
+
     for (const entry of entries) {
       if (results.length >= maxResults) return;
       const fullPath = join(dir, entry.name);
@@ -144,11 +154,11 @@ function searchFilesNative(rootPath, filePattern, recursive, maxResults) {
       if (entry.isDirectory()) {
         if (DEFAULT_IGNORE_DIRS.has(entry.name)) continue;
         if (entry.name.startsWith('.')) continue;
-        walk(fullPath, depth + 1);
+        await walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
         if (matchGlob(entry.name, filePattern)) {
           try {
-            const s = statSync(fullPath);
+            const s = await stat(fullPath);
             results.push({ path: fullPath, name: entry.name, size: s.size, mtime: s.mtimeMs });
           } catch {
             results.push({ path: fullPath, name: entry.name, size: 0, mtime: 0 });
@@ -158,7 +168,7 @@ function searchFilesNative(rootPath, filePattern, recursive, maxResults) {
     }
   }
 
-  walk(rootPath, 0);
+  await walk(rootPath, 0);
   return results;
 }
 
@@ -171,17 +181,19 @@ function searchFilesNative(rootPath, filePattern, recursive, maxResults) {
  * @returns {Array<{path, name, size, mtime}>}
  */
 export async function searchFiles(rootPath, filePattern = '*', recursive = true, maxResults = 200) {
-  const pathCheck = checkPath(rootPath);
+  const pathCheck = await checkPath(rootPath);
   if (!pathCheck.allowed) {
     return { success: false, error: pathCheck.reason };
   }
 
   const resolved = pathCheck.resolved;
-  if (!existsSync(resolved)) {
+  try {
+    await stat(resolved);
+  } catch {
     return { success: false, error: '搜索路径不存在' };
   }
 
-  const s = statSync(resolved);
+  const s = await stat(resolved);
   if (!s.isDirectory()) {
     return { success: false, error: '搜索路径不是目录' };
   }
@@ -190,7 +202,7 @@ export async function searchFiles(rootPath, filePattern = '*', recursive = true,
   if (fdAvailable) {
     results = await searchWithFd(resolved, filePattern, recursive, maxResults);
   } else {
-    results = searchFilesNative(resolved, filePattern, recursive, maxResults);
+    results = await searchFilesNative(resolved, filePattern, recursive, maxResults);
   }
 
   return {
@@ -271,19 +283,22 @@ function parseRgOutput(output, contextLines) {
 }
 
 /**
- * Node.js 原生搜索文件内容（回退方案）
+ * Node.js 原生搜索文件内容（回退方案，异步 + 分片防止阻塞事件循环）
  */
-function searchContentNative(rootPath, pattern, filePattern, caseSensitive, maxResults, contextLines) {
+async function searchContentNative(rootPath, pattern, filePattern, caseSensitive, maxResults, contextLines) {
   const results = [];
   const searchPattern = caseSensitive ? pattern : pattern.toLowerCase();
 
-  function walk(dir) {
+  async function walk(dir) {
     if (results.length >= maxResults) return;
 
     let entries;
-    try { entries = readdirSync(dir, { withFileTypes: true }); }
+    try { entries = await readdir(dir, { withFileTypes: true }); }
     catch { return; }
 
+    // 每处理一个目录后让出事件循环
+    await yieldEventLoop();
+
     for (const entry of entries) {
       if (results.length >= maxResults) return;
       const fullPath = join(dir, entry.name);
@@ -291,7 +306,7 @@ function searchContentNative(rootPath, pattern, filePattern, caseSensitive, maxR
       if (entry.isDirectory()) {
         if (DEFAULT_IGNORE_DIRS.has(entry.name)) continue;
         if (entry.name.startsWith('.')) continue;
-        walk(fullPath);
+        await walk(fullPath);
       } else if (entry.isFile()) {
         if (filePattern && !matchGlob(entry.name, filePattern)) continue;
         // 跳过压缩和映射文件
@@ -299,10 +314,10 @@ function searchContentNative(rootPath, pattern, filePattern, caseSensitive, maxR
         if (entry.name.endsWith('.map')) continue;
 
         try {
-          const s = statSync(fullPath);
+          const s = await stat(fullPath);
           if (s.size > 1024 * 1024) continue; // 跳过 1MB 以上的文件
 
-          const content = readFileSync(fullPath, 'utf-8');
+          const content = await readFile(fullPath, 'utf-8');
           const fileLines = content.split('\n');
 
           for (let i = 0; i < fileLines.length; i++) {
@@ -328,7 +343,7 @@ function searchContentNative(rootPath, pattern, filePattern, caseSensitive, maxR
     }
   }
 
-  walk(rootPath);
+  await walk(rootPath);
   return results;
 }
 
@@ -343,13 +358,15 @@ function searchContentNative(rootPath, pattern, filePattern, caseSensitive, maxR
  * @returns {{ success: boolean, results: Array, total: number, engine: string }}
  */
 export async function searchContent(rootPath, pattern, filePattern = null, caseSensitive = false, maxResults = 100, contextLines = 2) {
-  const pathCheck = checkPath(rootPath);
+  const pathCheck = await checkPath(rootPath);
   if (!pathCheck.allowed) {
     return { success: false, error: pathCheck.reason };
   }
 
   const resolved = pathCheck.resolved;
-  if (!existsSync(resolved)) {
+  try {
+    await stat(resolved);
+  } catch {
     return { success: false, error: '搜索路径不存在' };
   }
 
@@ -361,7 +378,7 @@ export async function searchContent(rootPath, pattern, filePattern = null, caseS
   if (rgAvailable) {
     results = await searchContentWithRg(resolved, pattern, filePattern, maxResults, contextLines);
   } else {
-    results = searchContentNative(resolved, pattern, filePattern, caseSensitive, maxResults, contextLines);
+    results = await searchContentNative(resolved, pattern, filePattern, caseSensitive, maxResults, contextLines);
   }
 
   return {

package/src/security.js

@@ -1,6 +1,6 @@
 // agent/src/security.js - 安全管控：文件沙箱 + 命令分级
 import { resolve, normalize, sep, isAbsolute, join, dirname } from 'path';
-import { realpathSync } from 'fs';
+import { realpath } from 'fs/promises';
 import { homedir, platform } from 'os';
 import { loadConfig, MEMORY_DIR } from './config.js';
 
@@ -52,10 +52,10 @@ function isHardBlocked(normalizedPath) {
 
 /**
  * 检查路径是否在白名单内
- * 使用 realpathSync 防止符号链接绕过
+ * 使用 realpath 防止符号链接绕过
  * @returns {{ allowed: boolean, reason?: string, resolved?: string }}
  */
-function checkPath(pathStr) {
+async function checkPath(pathStr) {
   if (!pathStr || typeof pathStr !== 'string') {
     return { allowed: false, reason: '路径无效' };
   }
@@ -106,7 +106,7 @@ function checkPath(pathStr) {
     // realpath 校验：防止符号链接绕过
     let realPath;
     try {
-      realPath = realpathSync(resolved);
+      realPath = await realpath(resolved);
     } catch (err) {
       if (err.code === 'ENOENT') {
         let existing = resolved;
@@ -116,7 +116,7 @@ function checkPath(pathStr) {
             break;
           }
           try {
-            realPath = realpathSync(parent) + sep + normalized.slice(resolve(parent).length).replace(/^[/\\]/, '');
+            realPath = await realpath(parent) + sep + normalized.slice(resolve(parent).length).replace(/^[/\\]/, '');
             break;
           } catch (parentErr) {
             if (parentErr.code === 'ENOENT') {

package/src/server.js

@@ -1,7 +1,8 @@
 // agent/src/server.js - HTTP Router + WebSocket 服务器
 import http from 'http';
 import { WebSocketServer } from 'ws';
-import { readFileSync, writeFileSync, readdirSync, statSync, unlinkSync, rmdirSync, existsSync, chmodSync, mkdirSync } from 'fs';
+import { readFileSync } from 'fs';
+import { readFile, writeFile, readdir, stat, unlink, rmdir, chmod, mkdir } from 'fs/promises';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { homedir } from 'os';
@@ -10,7 +11,7 @@ import os from 'os';
 import { loadConfig } from './config.js';
 import { verifyToken, getCurrentPairCode, startPairCodeRotation, stopPairCodeRotation, handlePairRequest } from './auth.js';
 import { checkPath, checkCommand } from './security.js';
-import { executeCommand, executeCommandSync, addWsClient, killProcess, getRunningProcesses } from './executor.js';
+import { executeCommand, executeCommandSync, addWsClient, disconnectWsClient, killProcess, getRunningProcesses } from './executor.js';
 import { setConsoleOutput, logAuth, logFs, logExec, logSecurity, logSystem, logError, queryLogs, getLogDates } from './logger.js';
 import { initSearchTools, getSearchToolsAvailable, searchFiles, searchContent } from './search.js';
 import {
@@ -98,6 +99,14 @@ function detectShell() {
   return '/bin/bash';
 }
 
+/**
+ * 异步检查文件/目录是否存在
+ */
+async function exists(path) {
+  try { await stat(path); return true; }
+  catch { return false; }
+}
+
 const PLATFORM_INFO = {
   platform: os.platform(),
   platformName: (() => {
@@ -361,21 +370,21 @@ export function startServer() {
 
         // 去重：如果文件已存在，添加后缀
         let finalPath = destPath;
-        if (existsSync(finalPath)) {
+        if (await exists(finalPath)) {
           const ext = safeName.lastIndexOf('.') > 0 ? safeName.substring(safeName.lastIndexOf('.')) : '';
           const base = safeName.substring(0, safeName.length - ext.length) || safeName;
           let counter = 1;
-          while (existsSync(finalPath)) {
+          while (await exists(finalPath)) {
             finalPath = join(config.workdir, `${base}_${counter}${ext}`);
             counter++;
           }
         }
 
         // 确保工作目录存在
-        mkdirSync(config.workdir, { recursive: true });
+        await mkdir(config.workdir, { recursive: true });
 
         // 写入文件
-        writeFileSync(finalPath, fileBuffer);
+        await writeFile(finalPath, fileBuffer);
 
         logFs('upload', { path: finalPath, size: fileBuffer.length, mimeType });
 
@@ -446,23 +455,23 @@ export function startServer() {
 
       // 读取文件
       if (pathname === '/api/fs/read') {
-        const check = checkPath(body.path);
+        const check = await checkPath(body.path);
         if (!check.allowed) {
           logSecurity('fs_read_blocked', { path: body.path, reason: check.reason });
           return jsonResponse(res, 403, { success: false, error: check.reason });
         }
-        if (!existsSync(check.resolved)) return jsonResponse(res, 404, { success: false, error: '文件不存在' });
-        const fstat = statSync(check.resolved);
+        if (!await exists(check.resolved)) return jsonResponse(res, 404, { success: false, error: '文件不存在' });
+        const fstat = await stat(check.resolved);
         if (fstat.isDirectory()) return jsonResponse(res, 400, { success: false, error: '路径是目录' });
         if (fstat.size > maxSize) return jsonResponse(res, 400, { success: false, error: `文件过大 (${fstat.size} > ${maxSize})` });
-        const content = readFileSync(check.resolved, 'utf-8');
+        const content = await readFile(check.resolved, 'utf-8');
         logFs('read', { path: check.resolved, size: fstat.size });
         return jsonResponse(res, 200, { success: true, content, size: fstat.size, path: check.resolved });
       }
 
       // 写入文件
       if (pathname === '/api/fs/write') {
-        const check = checkPath(body.path);
+        const check = await checkPath(body.path);
         if (!check.allowed) {
           logSecurity('fs_write_blocked', { path: body.path, reason: check.reason });
           return jsonResponse(res, 403, { success: false, error: check.reason });
@@ -471,8 +480,8 @@ export function startServer() {
         const buf = Buffer.from(rawContent, 'utf-8');
         if (buf.length > maxSize) return jsonResponse(res, 400, { success: false, error: `内容过大 (${buf.length} > ${maxSize})` });
         // 确保父目录存在
-        mkdirSync(dirname(check.resolved), { recursive: true });
-        writeFileSync(check.resolved, rawContent, 'utf-8');
+        await mkdir(dirname(check.resolved), { recursive: true });
+        await writeFile(check.resolved, rawContent, 'utf-8');
 
         // 如果写入的是脚本文件，剥离执行权限防止直接运行
         const SCRIPT_EXT_RE = /\.(sh|bash|zsh|py|js|mjs|rb|pl|php|lua)$/i;
@@ -480,7 +489,7 @@ export function startServer() {
         const hasShebang = rawContent.startsWith('#!');
         if (isScriptExt || hasShebang) {
           try {
-            chmodSync(check.resolved, 0o644);
+            await chmod(check.resolved, 0o644);
           } catch {}
         }
 
@@ -491,39 +500,40 @@ export function startServer() {
       // 列出目录
       if (pathname === '/api/fs/list') {
         const dirPath = body.path || '.';
-        const check = checkPath(dirPath);
+        const check = await checkPath(dirPath);
         if (!check.allowed) {
           logSecurity('fs_list_blocked', { path: dirPath, reason: check.reason });
           return jsonResponse(res, 403, { success: false, error: check.reason });
         }
-        if (!existsSync(check.resolved)) return jsonResponse(res, 404, { success: false, error: '目录不存在' });
-        const dstat = statSync(check.resolved);
+        if (!await exists(check.resolved)) return jsonResponse(res, 404, { success: false, error: '目录不存在' });
+        const dstat = await stat(check.resolved);
         if (!dstat.isDirectory()) return jsonResponse(res, 400, { success: false, error: '路径不是目录' });
-        const entries = readdirSync(check.resolved).map(name => {
+        const names = await readdir(check.resolved);
+        const entries = await Promise.all(names.map(async (name) => {
           const fullPath = join(check.resolved, name);
           try {
-            const s = statSync(fullPath);
+            const s = await stat(fullPath);
             return { name, type: s.isDirectory() ? 'directory' : 'file', size: s.size, mtime: s.mtimeMs };
           } catch { return { name, type: 'unknown', size: 0, mtime: 0 }; }
-        });
+        }));
         logFs('list', { path: check.resolved, entryCount: entries.length });
         return jsonResponse(res, 200, { success: true, entries, path: check.resolved });
       }
 
       // 删除文件/目录
       if (pathname === '/api/fs/delete') {
-        const check = checkPath(body.path);
+        const check = await checkPath(body.path);
         if (!check.allowed) {
           logSecurity('fs_delete_blocked', { path: body.path, reason: check.reason });
           return jsonResponse(res, 403, { success: false, error: check.reason });
         }
-        if (!existsSync(check.resolved)) return jsonResponse(res, 404, { success: false, error: '文件/目录不存在' });
-        const fstat2 = statSync(check.resolved);
+        if (!await exists(check.resolved)) return jsonResponse(res, 404, { success: false, error: '文件/目录不存在' });
+        const fstat2 = await stat(check.resolved);
         const isDir = fstat2.isDirectory();
         if (isDir) {
-          rmdirSync(check.resolved, { recursive: true });
+          await rmdir(check.resolved, { recursive: true });
         } else {
-          unlinkSync(check.resolved);
+          await unlink(check.resolved);
         }
         logFs('delete', { path: check.resolved, type: isDir ? 'directory' : 'file', size: fstat2.size });
         return jsonResponse(res, 200, { success: true, path: check.resolved });
@@ -535,12 +545,12 @@ export function startServer() {
         if (!targetPath || typeof targetPath !== 'string') {
           return jsonResponse(res, 400, { success: false, error: '缺少 path 参数' });
         }
-        const check = checkPath(targetPath);
+        const check = await checkPath(targetPath);
         if (!check.allowed) {
           logSecurity('browser_open_blocked', { path: targetPath, reason: check.reason });
           return jsonResponse(res, 403, { success: false, error: check.reason });
         }
-        if (!existsSync(check.resolved)) {
+        if (!await exists(check.resolved)) {
           return jsonResponse(res, 404, { success: false, error: '文件不存在' });
         }
 
@@ -575,7 +585,7 @@ export function startServer() {
 
         // 校验 cwd
         let resolvedCwd = cwd || config.workdir;
-        const cwdCheck = checkPath(resolvedCwd);
+        const cwdCheck = await checkPath(resolvedCwd);
         if (!cwdCheck.allowed) {
           logSecurity('exec_cwd_blocked', { command, cwd: resolvedCwd, reason: cwdCheck.reason });
           return jsonResponse(res, 403, { success: false, error: '执行目录校验失败: ' + cwdCheck.reason });
@@ -932,7 +942,7 @@ export function startServer() {
         return jsonResponse(res, 404, { success: false, error: `资源 "${resource}" 不存在` });
       }
       try {
-        const content = readFileSync(resInfo.path, 'utf-8');
+        const content = await readFile(resInfo.path, 'utf-8');
         return jsonResponse(res, 200, { success: true, name: resource, content, size: resInfo.size });
       } catch (err) {
         return jsonResponse(res, 500, { success: false, error: `读取资源失败: ${err.message}` });
@@ -991,6 +1001,10 @@ export function startServer() {
         if (!added) {
           ws.send(JSON.stringify({ type: 'error', error: '进程不存在或已结束', execId }));
         }
+        // 客户端断开时，从监听列表中移除；所有客户端都断开后取消超时
+        ws.on('close', () => {
+          disconnectWsClient(execId, ws);
+        });
       });
     } else {
       socket.destroy();
@@ -1041,7 +1055,7 @@ export function startServer() {
     }
 
     // 关闭所有 MCP 连接
-    try { shutdownMcpRegistry(); } catch {}
+    try { await shutdownMcpRegistry(); } catch {}
 
     // 等待 server 和 wss 关闭
     await Promise.all([
@@ -1050,7 +1064,7 @@ export function startServer() {
     ]);
 
     // 清理 PID 文件
-    try { if (existsSync(PID_FILE)) unlinkSync(PID_FILE); } catch {}
+    try { if (await exists(PID_FILE)) await unlink(PID_FILE); } catch {}
 
     logSystem('server_stop', { reason: 'shutdown' });
     process.exit(0);

package/src/skill/executor.js

@@ -1,7 +1,7 @@
 // skill/executor.js - Skill 执行引擎
 // 解析 Skill 定义的步骤 DAG，按拓扑排序执行，支持并行
 import { render } from './template.js';
-import { readFileSync } from 'fs';
+import { readFile, writeFile, readdir, stat } from 'fs/promises';
 import { checkPath, checkCommand } from '../security.js';
 import { join } from 'path';
 
@@ -48,28 +48,27 @@ async function executeToolCall(toolName, args) {
   try {
     switch (toolName) {
       case 'agent_read_file': {
-        const check = checkPath(args.path);
+        const check = await checkPath(args.path);
         if (!check.allowed) return { success: false, error: check.reason };
-        const content = readFileSync(check.resolved, 'utf-8');
+        const content = await readFile(check.resolved, 'utf-8');
         return { success: true, content, size: content.length, path: check.resolved };
       }
 
       case 'agent_write_file': {
-        const check = checkPath(args.path);
+        const check = await checkPath(args.path);
         if (!check.allowed) return { success: false, error: check.reason };
-        const { writeFileSync } = await import('fs');
-        writeFileSync(check.resolved, String(args.content || ''), 'utf-8');
+        await writeFile(check.resolved, String(args.content || ''), 'utf-8');
         return { success: true, message: `文件已写入: ${check.resolved}` };
       }
 
       case 'agent_list_dir': {
-        const check = checkPath(args.path || '.');
+        const check = await checkPath(args.path || '.');
         if (!check.allowed) return { success: false, error: check.reason };
-        const { readdirSync, statSync } = await import('fs');
-        const entries = readdirSync(check.resolved).map(name => {
-          const s = statSync(join(check.resolved, name));
+        const names = await readdir(check.resolved);
+        const entries = await Promise.all(names.map(async (name) => {
+          const s = await stat(join(check.resolved, name));
           return { name, type: s.isDirectory() ? 'directory' : 'file', size: s.size };
-        });
+        }));
         return { success: true, entries, path: check.resolved };
       }
 
@@ -82,14 +81,21 @@ async function executeToolCall(toolName, args) {
         if (cmdCheck.level === 'confirm') {
           return { success: false, error: `需要用户确认的命令: ${cmdCheck.reason}` };
         }
-        const { execSync } = await import('child_process');
-        const result = execSync(args.command, {
-          cwd: args.cwd || process.cwd(),
-          encoding: 'utf-8',
-          timeout: 30000,
-          maxBuffer: 10 * 1024 * 1024
+        const { exec } = await import('child_process');
+        return new Promise((resolve) => {
+          exec(args.command, {
+            cwd: args.cwd || process.cwd(),
+            encoding: 'utf-8',
+            timeout: 30000,
+            maxBuffer: 10 * 1024 * 1024
+          }, (error, stdout, stderr) => {
+            if (error) {
+              resolve({ success: false, error: error.message, stdout, stderr });
+            } else {
+              resolve({ success: true, stdout, exitCode: 0, stderr });
+            }
+          });
         });
-        return { success: true, stdout: result, exitCode: 0 };
       }
 
       case 'agent_search_files': {

package/src/skill/registry.js

@@ -212,7 +212,7 @@ export function getAgentSkillPrompts() {
   const parts = [];
   parts.push('## 可用技能 (Skills)');
   parts.push('');
-  parts.push('以下是可用的专业技能列表。当用户需求匹配某个技能时，使用 `agent_skill_load` 工具加载该技能的完整说明。');
+  parts.push('以下是可用的 Agent Skill（AI 能力扩展）列表。当用户需求匹配某个技能时，使用 `agent_skill_load` 工具加载该技能的完整说明，然后由 AI 根据说明自主调用相关工具完成任务。');
   parts.push('');
 
   for (const skill of agentSkills) {