ai-helper-agent 1.9.2 → 1.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-helper-agent",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "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/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 = [];
       }
@@ -143,15 +142,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';
@@ -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}` });
@@ -956,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 });
 
@@ -990,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', () => {
@@ -1032,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();
 
     // 终止所有运行中的进程
@@ -1045,7 +1074,17 @@ export function startServer() {
     }
 
     // 关闭所有 MCP 连接
-    try { shutdownMcpRegistry(); } catch {}
+    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([
@@ -1054,8 +1093,9 @@ export function startServer() {
     ]);
 
     // 清理 PID 文件
-    try { if (existsSync(PID_FILE)) unlinkSync(PID_FILE); } catch {}
+    try { if (await exists(PID_FILE)) await unlink(PID_FILE); } catch {}
 
+    clearTimeout(forceExitTimer);
     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/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_load` 工具加载该技能的完整说明。');
+  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) {