ai-helper-agent 1.10.0 → 1.12.0

package/bin/agent.js

@@ -399,6 +399,128 @@ if (command === 'start') {
   console.log(`[Agent] 工作目录: ${cfg.workdir}`);
   restartServer();
 
+// ==================== _restart-helper（内部命令，两阶段重启包装器） ====================
+} else if (command === '_restart-helper') {
+  // 由 /api/agent/restart 和 /api/agent/update 调用，detached 运行
+  // 职责：等待老进程退出 + 端口释放后，再以 --background 模式启动新进程
+  // 解决直接 spawn 新进程时 isRunning 检查劝退、端口 EADDRINUSE 的时序问题
+  const helperConfig = applyCliArgs({ port: 18910, host: '127.0.0.1' }, process.argv.slice(3));
+  const oldPidIdx = process.argv.indexOf('--old-pid');
+  const oldPid = oldPidIdx > -1 ? parseInt(process.argv[oldPidIdx + 1], 10) : 0;
+  const scriptIdx = process.argv.indexOf('--script');
+  const agentScript = scriptIdx > -1 ? process.argv[scriptIdx + 1] : process.argv[1];
+
+  const port = helperConfig.port;
+  const host = helperConfig.host;
+  const workdir = helperConfig.workdir || process.cwd();
+
+  const log = (msg) => console.log(`[Agent Restart Helper] ${msg}`);
+  log(`等待老进程 ${oldPid} 退出...`);
+
+  // 1. 等待老进程退出（轮询 PID 探活，process.kill(pid,0) 不发信号只检测存在性）
+  const waitForOldExit = (pid, timeoutMs = 15000) => new Promise((resolve) => {
+    if (!pid) return resolve(true);
+    const start = Date.now();
+    const timer = setInterval(() => {
+      try {
+        process.kill(pid, 0);
+      } catch {
+        clearInterval(timer);
+        resolve(true);
+        return;
+      }
+      if (Date.now() - start > timeoutMs) {
+        clearInterval(timer);
+        log('等待老进程退出超时，尝试强制终止...');
+        try { process.kill(pid, 'SIGKILL'); } catch {}
+        resolve(false);
+      }
+    }, 200);
+  });
+
+  // 2. 等待端口释放（fetch /api/status 失败即视为释放）
+  const waitForPortRelease = async (host, port, timeoutMs = 10000) => {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      try {
+        const resp = await fetch(`http://${host}:${port}/api/status`);
+        if (resp.ok) {
+          await new Promise(r => setTimeout(r, 300));
+          continue;
+        }
+      } catch {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  (async () => {
+    await waitForOldExit(oldPid);
+    await waitForPortRelease(host, port);
+    // 额外等待，确保 socket 完全回收
+    await new Promise(r => setTimeout(r, 500));
+
+    log('老进程已退出，端口已释放，启动新进程...');
+
+    // 清理旧 PID 文件，避免新进程 isRunning 检查误判
+    removePidFile();
+    ensureAgentDir();
+
+    // 直接以前台模式启动服务进程（不经过 --background 中间层）
+    // 原因：--background 会多 spawn 一层中间进程，中间进程退出后其 PID 会被
+    //   本 helper 覆盖写入 PID 文件，导致 stop/restart 读到已死的中间进程 PID。
+    //   前台模式下 child.pid 就是服务进程 PID，与服务进程自身写入的 PID 一致。
+    //   前台 start 不会 isRunning 检查，但本 helper 已确保老进程退出 + 端口释放。
+    const child = spawn(process.execPath, [
+      ...process.execArgv,
+      agentScript,
+      'start',
+      '--port', String(port),
+      '--host', host,
+      '--workdir', workdir
+    ], {
+      detached: true,
+      stdio: 'ignore',
+      cwd: process.cwd(),
+      env: { ...process.env },
+      windowsHide: true
+    });
+
+    let spawnFailed = false;
+    child.on('error', (err) => {
+      spawnFailed = true;
+      log(`启动失败: ${err.message}`);
+      process.exit(1);
+    });
+
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    // 健康检查：确认服务进程已成功监听端口，避免写入已崩溃进程的 PID
+    // （若端口意外未释放导致 EADDRINUSE，服务进程会崩溃，此时不应写错误 PID）
+    let healthy = false;
+    if (!spawnFailed && child.pid) {
+      try {
+        const resp = await fetch(`http://${host}:${port}/api/status`);
+        healthy = resp.ok;
+      } catch {}
+    }
+
+    if (healthy && child.pid) {
+      try {
+        writeFileSync(PID_FILE, String(child.pid));
+      } catch (err) {
+        log(`PID 文件写入失败: ${err.message}`);
+      }
+      child.unref();
+      log(`新进程已启动 (PID: ${child.pid})`);
+    } else if (!spawnFailed && child.pid) {
+      log(`警告：新进程健康检查失败，未更新 PID 文件（可能端口仍被占用或进程已崩溃）`);
+    }
+
+    process.exit(spawnFailed ? 1 : 0);
+  })();
+
 // ==================== status ====================
 } else if (command === 'status') {
   const config = readAgentConfig();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-helper-agent",
-  "version": "1.10.0",
+  "version": "1.12.0",
   "description": "AI Helper 代理服务 - 为 Chrome 扩展提供本地文件读写和系统命令执行能力",
   "type": "module",
   "main": "./src/server.js",
@@ -21,7 +21,9 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "archiver": "^8.0.0",
     "ws": "^8.18.0",
+    "xlsx": "^0.18.5",
     "zod": "^4.4.3"
   },
   "engines": {

package/src/auth.js

@@ -2,7 +2,7 @@
 import crypto from 'crypto';
 import { loadConfig, loadPairings, savePairing } from './config.js';
 
-// 当前有效的配对码（30秒刷新一次）
+// 当前有效的配对码（定时刷新 + 一次性使用）
 let currentPairCode = null;
 let pairCodeTimer = null;
 
@@ -12,11 +12,26 @@ let lastAuthTime = 0;
 // 判定"活跃"的时间窗口：此时间内有过认证则认为仍有扩展连接
 const ACTIVE_WINDOW_MS = 5 * 60 * 1000; // 5 分钟
 
+// 配对码字符表：排除易混淆字符（0/O、1/I/l）；6 位字母数字（≈21亿种，抗暴破）
+const PAIR_CODE_CHARS = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
+const PAIR_CODE_LEN = 6;
+
+// 配对失败锁定：连续失败 PAIR_FAIL_LIMIT 次后锁定 PAIR_LOCK_DURATION_MS 毫秒
+let pairFailCount = 0;
+let pairLockUntil = 0;
+const PAIR_FAIL_LIMIT = 5;
+const PAIR_LOCK_DURATION_MS = 60 * 1000; // 60 秒
+
 /**
- * 生成随机配对码（4位数字，使用密码学安全的随机数）
+ * 生成随机配对码（6位字母数字，使用密码学安全的随机数，排除易混淆字符）
  */
 function generatePairCode() {
-  return String(crypto.randomInt(1000, 10000));
+  const bytes = crypto.randomBytes(PAIR_CODE_LEN);
+  let code = '';
+  for (let i = 0; i < PAIR_CODE_LEN; i++) {
+    code += PAIR_CODE_CHARS[bytes[i] % PAIR_CODE_CHARS.length];
+  }
+  return code;
 }
 
 /**
@@ -39,21 +54,15 @@ function startPairCodeRotation() {
 
   // 有配对且最近有活跃连接，无需刷新配对码
   if (hasPairings && isRecentlyActive) {
-    console.log(`[Agent] 已有 ${Object.keys(pairings).length} 个配对扩展，最近 ${Math.round((Date.now() - lastAuthTime) / 1000)}s 前有认证活动，跳过配对码刷新`);
     currentPairCode = generatePairCode();
-    console.log(`[Agent] 当前配对码（用于新增配对）: ${currentPairCode}`);
+    console.log(`\n[Agent] 配对码: ${currentPairCode}\n`);
     return;
   }
 
-  // 有配对但无活跃连接，给出提示
-  if (hasPairings && !isRecentlyActive) {
-    console.log(`[Agent] 存在配对记录但无活跃连接（超过 ${ACTIVE_WINDOW_MS / 60000} 分钟），恢复配对码刷新`);
-  }
-
   const ttl = (config.pairCodeTTL || 30) * 1000;
 
   currentPairCode = generatePairCode();
-  console.log(`[Agent] 当前配对码: ${currentPairCode}`);
+  console.log(`\n[Agent] 配对码: ${currentPairCode}\n`);
 
   if (pairCodeTimer) clearInterval(pairCodeTimer);
   pairCodeTimer = setInterval(() => {
@@ -89,17 +98,38 @@ function verifyToken(token) {
 
 /**
  * 处理配对请求（异步，支持写入锁）
+ * 安全策略：
+ *   - 失败锁定：连续失败 PAIR_FAIL_LIMIT 次后临时锁定，并立即轮换配对码使已观测码失效
+ *   - 一次性使用：配对成功后立即轮换配对码，防止配对码被重复利用
  */
 async function handlePairRequest(code, extensionId) {
+  // 锁定期内直接拒绝（不泄露是否处于锁定状态细节）
+  if (Date.now() < pairLockUntil) {
+    return { success: false, error: '配对尝试过于频繁，请稍后再试' };
+  }
   if (!code || !extensionId) {
     return { success: false, error: '缺少配对码或扩展ID' };
   }
-  if (code !== currentPairCode) {
+  if (code.toUpperCase() !== currentPairCode) {
+    pairFailCount++;
+    if (pairFailCount >= PAIR_FAIL_LIMIT) {
+      pairLockUntil = Date.now() + PAIR_LOCK_DURATION_MS;
+      pairFailCount = 0;
+      // 锁定时立即轮换配对码，使攻击者已观测到的配对码失效
+      currentPairCode = generatePairCode();
+      console.log('[Agent] 配对失败次数过多，已临时锁定 60s 并轮换配对码');
+    }
     return { success: false, error: '配对码无效' };
   }
+  // 配对码正确：重置失败计数
+  pairFailCount = 0;
+
   // 检查是否已有配对
   const pairings = loadPairings();
   if (pairings[extensionId]) {
+    // 一次性使用：成功后立即轮换配对码
+    currentPairCode = generatePairCode();
+    console.log('[Agent] 配对码校验通过，配对码已轮换（一次性使用）');
     return { success: true, token: pairings[extensionId].token, message: '已配对，返回现有 token' };
   }
   // 生成新 token 并保存
@@ -109,6 +139,9 @@ async function handlePairRequest(code, extensionId) {
   } catch (err) {
     return { success: false, error: `配对保存失败: ${err.message}` };
   }
+  // 一次性使用：成功后立即轮换配对码
+  currentPairCode = generatePairCode();
+  console.log('[Agent] 配对成功，配对码已轮换（一次性使用）');
   return { success: true, token, message: '配对成功' };
 }
 

package/src/executor.js

@@ -54,8 +54,25 @@ function getShellForExec() {
 // 运行中的进程映射：execId → { process, wsClients: Set, timeoutId, forceKillId, stdoutBuf, stderrBuf }
 const runningProcesses = new Map();
 
-// 已完成进程缓存（解决竞态条件：进程完成太快，WebSocket 客户端来不及连接）
-// execId → { stdoutBuf, stderrBuf, exitCode, killed, cleanupTimeout }
+// 输出缓冲区上限（5MB），防止长时间命令内存无限增长
+const MAX_OUTPUT_BUFFER = 5 * 1024 * 1024;
+
+/**
+ * 安全追加字符串到缓冲区，超过上限时截断并标记
+ * @param {string} buf - 当前缓冲区
+ * @param {string} chunk - 要追加的字符串
+ * @param {object} truncState - 截断状态对象 { truncated: boolean }
+ * @returns {string} 更新后的缓冲区
+ */
+function appendWithLimit(buf, chunk, truncState) {
+  if (truncState.truncated) return buf;
+  if (buf.length + chunk.length > MAX_OUTPUT_BUFFER) {
+    truncState.truncated = true;
+    const remaining = MAX_OUTPUT_BUFFER - buf.length;
+    return buf + (remaining > 0 ? chunk.slice(0, remaining) : '');
+  }
+  return buf + chunk;
+}
 const completedProcesses = new Map();
 const COMPLETED_CACHE_TTL = 30000; // 30秒后清理
 
@@ -120,6 +137,7 @@ function executeCommand(command, cwd, wsClient, onComplete, collectOutput = fals
     cwd: workdir,
     env: buildSafeEnv(),
     stdio: ['ignore', 'pipe', 'pipe'],
+    detached: true,       // 独立进程组，防止 kill 父进程后子进程成为孤儿
     windowsHide: true
   });
 
@@ -133,7 +151,8 @@ function executeCommand(command, cwd, wsClient, onComplete, collectOutput = fals
 
   // 存储到 entry 中供 clearTimers 读取
   // stdoutBuf/stderrBuf 始终收集，用于回放给延迟连接的 WS 客户端
-  const entry = { process: proc, wsClients, stdoutBuf: '', stderrBuf: '' };
+  // command/startTime 用于状态详情面板展示运行中进程
+  const entry = { process: proc, wsClients, stdoutBuf: '', stderrBuf: '', truncStdout: false, truncStderr: false, command, startTime: Date.now() };
   runningProcesses.set(execId, entry);
 
   // 超时控制
@@ -166,7 +185,12 @@ function executeCommand(command, cwd, wsClient, onComplete, collectOutput = fals
   proc.stdout.on('data', (chunk) => {
     const str = chunk.toString();
     if (collectOutput) stdoutCollected += str;
-    entry.stdoutBuf += str;
+    const truncState = { truncated: entry.truncStdout };
+    entry.stdoutBuf = appendWithLimit(entry.stdoutBuf, str, truncState);
+    entry.truncStdout = truncState.truncated;
+    if (truncState.truncated) {
+      broadcast({ type: 'stdout_truncated', message: 'stdout 输出超过 5MB 上限，已截断', execId });
+    }
     broadcast({ type: 'stdout', data: str, execId });
   });
 
@@ -174,7 +198,12 @@ function executeCommand(command, cwd, wsClient, onComplete, collectOutput = fals
   proc.stderr.on('data', (chunk) => {
     const str = chunk.toString();
     if (collectOutput) stderrCollected += str;
-    entry.stderrBuf += str;
+    const truncState = { truncated: entry.truncStderr };
+    entry.stderrBuf = appendWithLimit(entry.stderrBuf, str, truncState);
+    entry.truncStderr = truncState.truncated;
+    if (truncState.truncated) {
+      broadcast({ type: 'stderr_truncated', message: 'stderr 输出超过 5MB 上限，已截断', execId });
+    }
     broadcast({ type: 'stderr', data: str, execId });
   });
 
@@ -326,9 +355,9 @@ function disconnectWsClient(execId, wsClient) {
 }
 
 /**
- * 停止正在运行的命令（跨平台兼容）
- * - macOS/Linux: SIGTERM（优雅终止）→ 5s → SIGKILL（强制杀）
- * - Windows: taskkill /PID（优雅终止）→ 5s → taskkill /F /PID（强制杀）
+ * 停止正在运行的命令（跨平台兼容，递归终止全部子进程）
+ * - macOS/Linux: SIGTERM to process group（-pid）→ 5s → SIGKILL to process group
+ * - Windows: taskkill /T /PID（递归终止进程树）→ 5s → taskkill /F /T /PID
  */
 function killProcess(execId) {
   const entry = runningProcesses.get(execId);
@@ -340,18 +369,20 @@ function killProcess(execId) {
   const pid = entry.process.pid;
 
   if (isWin) {
-    // Windows: taskkill 支持优雅终止（/PID 发送 WM_CLOSE）和强制终止（/F）
-    exec(`taskkill /PID ${pid}`, (err) => {
+    // Windows: /T 递归终止整个进程树
+    exec(`taskkill /T /PID ${pid}`, (err) => {
       if (err) {
-        // 尝试强制杀
-        exec(`taskkill /F /PID ${pid}`, () => {});
+        exec(`taskkill /F /T /PID ${pid}`, () => {});
       }
     });
   } else {
-    // macOS/Linux: SIGTERM 优雅终止
+    // Unix: 负 PID 表示杀整个进程组（detached + 未调用 setsid 时有效）
     try {
-      entry.process.kill('SIGTERM');
-    } catch {}
+      process.kill(-pid, 'SIGTERM');
+    } catch {
+      // 回退到单进程
+      try { entry.process.kill('SIGTERM'); } catch {}
+    }
   }
 
   // 清理旧的定时器
@@ -363,14 +394,15 @@ function killProcess(execId) {
     clearTimeout(entry.forceKillId);
   }
 
-  // 5秒后强制杀（绑定到 entry 对象防止闭包引用旧变量）
+  // 5秒后强制杀整个进程组
   entry.forceKillId = setTimeout(() => {
     try {
       if (entry.process.exitCode === null) {
         if (isWin) {
-          exec(`taskkill /F /PID ${pid}`, () => {});
+          exec(`taskkill /F /T /PID ${pid}`, () => {});
         } else {
-          entry.process.kill('SIGKILL');
+          try { process.kill(-pid, 'SIGKILL'); }
+          catch { try { entry.process.kill('SIGKILL'); } catch {} }
         }
       }
     } catch {}
@@ -382,11 +414,19 @@ function killProcess(execId) {
 
 /**
  * 获取运行中的进程列表
+ * 返回每个进程的 execId、pid、command、startTime、duration（已运行毫秒数）
  */
 function getRunningProcesses() {
+  const now = Date.now();
   const list = [];
-  for (const [execId] of runningProcesses) {
-    list.push({ execId });
+  for (const [execId, entry] of runningProcesses) {
+    list.push({
+      execId,
+      pid: entry.process && entry.process.pid ? entry.process.pid : null,
+      command: entry.command || '',
+      startTime: entry.startTime || null,
+      duration: entry.startTime ? now - entry.startTime : 0
+    });
   }
   return list;
 }

package/src/mcp/client.js

@@ -33,7 +33,6 @@ export class McpClient {
       case TRANSPORT_SSE: {
         const url = this.serverConfig.url;
         if (!url) throw new Error('SSE 传输需要提供 url');
-        console.log(`[MCP:${this.serverId}] 使用 SSE 传输，URL: ${url}`);
         const opts = {};
         if (Object.keys(headers).length > 0) {
           opts.requestInit = { headers };
@@ -44,7 +43,6 @@ export class McpClient {
       case TRANSPORT_STREAMABLE_HTTP: {
         const url = this.serverConfig.url;
         if (!url) throw new Error('StreamableHTTP 传输需要提供 url');
-        console.log(`[MCP:${this.serverId}] 使用 StreamableHTTP 传输，URL: ${url}`);
         const opts = {};
         if (Object.keys(headers).length > 0) {
           opts.requestInit = { headers };
@@ -55,7 +53,6 @@ export class McpClient {
       case TRANSPORT_WEBSOCKET: {
         const url = this.serverConfig.url;
         if (!url) throw new Error('WebSocket 传输需要提供 url');
-        console.log(`[MCP:${this.serverId}] 使用 WebSocket 传输，URL: ${url}`);
         return new WebSocketClientTransport(new URL(url));
       }
 
@@ -63,7 +60,6 @@ export class McpClient {
       default: {
         const command = this.serverConfig.command;
         if (!command) throw new Error('stdio 传输需要提供 command');
-        console.log(`[MCP:${this.serverId}] 使用 stdio 传输，命令: ${command}`);
         return new StdioClientTransport({
           command: this.serverConfig.command,
           args: this.serverConfig.args || [],
@@ -92,12 +88,10 @@ export class McpClient {
         serverInfo: this.client.getServerVersion(),
         capabilities: this.client.getServerCapabilities()
       };
-      console.log(`[MCP:${this.serverId}] Initialize 成功, server:`, this.serverInfo.serverInfo?.name);
 
       const toolsResult = await this.client.listTools({});
       if (toolsResult && toolsResult.tools) {
         this.tools = toolsResult.tools;
-        console.log(`[MCP:${this.serverId}] 发现 ${this.tools.length} 个工具`);
       } else {
         this.tools = [];
       }
@@ -105,7 +99,6 @@ export class McpClient {
       this.connected = true;
       return { success: true, toolCount: this.tools.length };
     } catch (err) {
-      console.error(`[MCP:${this.serverId}] 连接失败:`, err.message);
       this.disconnect();
       return { success: false, error: err.message };
     }
@@ -155,8 +148,6 @@ export class McpClient {
       try { await this.transport.close(); } catch {}
       this.transport = null;
     }
-
-    console.log(`[MCP:${this.serverId}] 已断开连接`);
   }
 
   getStatus() {

package/src/mcp/registry.js

@@ -14,14 +14,10 @@ export async function initializeMcpRegistry() {
   const config = loadMcpConfig();
   let connected = 0;
   let failed = 0;
-
-  console.log(`[MCP Registry] 初始化，共配置 ${config.servers.length} 个 MCP Server`);
+  const failedServers = [];
 
   for (const server of config.servers) {
-    if (!server.enabled) {
-      console.log(`[MCP Registry] 跳过禁用的 Server: ${server.id}`);
-      continue;
-    }
+    if (!server.enabled) continue;
 
     const client = new McpClient(server);
     const result = await client.connect();
@@ -29,12 +25,19 @@ export async function initializeMcpRegistry() {
       clients.set(server.id, client);
       connected++;
     } else {
-      console.error(`[MCP Registry] 连接失败 "${server.id}":`, result.error);
       failed++;
+      failedServers.push({ id: server.id, error: result.error });
     }
   }
 
-  console.log(`[MCP Registry] 初始化完成: ${connected} 已连接, ${failed} 失败`);
+  if (config.servers.length > 0) {
+    if (failed > 0) {
+      const failedList = failedServers.map(fs => `${fs.id}(${fs.error})`).join(', ');
+      console.warn(`[MCP] ${connected}/${config.servers.length} 已连接，${failed} 个失败: ${failedList}`);
+    } else if (connected > 0) {
+      console.log(`[MCP] ${connected} 个 Server 已连接`);
+    }
+  }
   return { connected, failed };
 }
 
@@ -154,7 +157,6 @@ export async function disconnectMcpServer(serverId) {
  * 关闭所有 MCP 连接（Agent 关闭时调用）
  */
 export async function shutdownMcpRegistry() {
-  console.log('[MCP Registry] 关闭所有 MCP 连接...');
   for (const [id, client] of clients) {
     try { await client.disconnect(); } catch {}
   }

package/src/search.js

@@ -1,6 +1,7 @@
 // agent/src/search.js - 文件搜索（fd/rg 优先 + Node.js 回退）
 import { spawn } from 'child_process';
 import { readdir, stat, readFile } from 'fs/promises';
+import { statSync } from 'fs';
 import { join, basename, extname, resolve } from 'path';
 import { checkPath } from './security.js';
 
@@ -43,8 +44,6 @@ export async function initSearchTools() {
     const [fd, rg] = await Promise.all([checkFdAvailable(), checkRgAvailable()]);
     fdAvailable = fd;
     rgAvailable = rg;
-    console.log(`[Agent] fd (文件搜索): ${fd ? '✅ 可用' : '❌ 未安装，使用 Node.js 回退'}`);
-    console.log(`[Agent] rg (内容搜索): ${rg ? '✅ 可用' : '❌ 未安装，使用 Node.js 回退'}`);
     return { fd: fdAvailable, rg: rgAvailable };
   })();
   return searchToolsInitPromise;
@@ -81,11 +80,15 @@ function matchGlob(filename, pattern) {
 }
 
 /**
- * 使用 fd 搜索文件（快速）
+ * 使用 fd 搜索文件和目录（快速）
  */
 function searchWithFd(rootPath, filePattern, recursive, maxResults) {
   return new Promise((resolve) => {
-    const args = ['--glob', filePattern, '--type', 'f', '--max-results', String(maxResults)];
+    const args = ['--glob', filePattern, '--type', 'f', '--type', 'd', '--max-results', String(maxResults)];
+    // 排除默认忽略的目录
+    for (const dir of DEFAULT_IGNORE_DIRS) {
+      args.push('--exclude', dir);
+    }
     if (!recursive) args.push('--max-depth', '1');
     args.push(rootPath);
 
@@ -109,11 +112,12 @@ function searchWithFd(rootPath, filePattern, recursive, maxResults) {
       const output = Buffer.concat(stdout).toString('utf-8').trim();
       const lines = output ? output.split('\n').filter(Boolean) : [];
       const results = lines.map(p => {
+        const absPath = join(rootPath, p);
         try {
-          const s = statSync(p);
-          return { path: p, name: basename(p), size: s.size, mtime: s.mtimeMs };
+          const s = statSync(absPath);
+          return { path: absPath, name: basename(p), type: s.isDirectory() ? 'directory' : 'file', size: s.size, mtime: s.mtimeMs };
         } catch {
-          return { path: p, name: basename(p), size: 0, mtime: 0 };
+          return { path: absPath, name: basename(p), type: 'file', size: 0, mtime: 0 };
         }
       });
       resolve(results);
@@ -131,7 +135,7 @@ function yieldEventLoop() {
 }
 
 /**
- * Node.js 原生递归搜索文件（回退方案，异步 + 分片防止阻塞事件循环）
+ * Node.js 原生递归搜索文件和目录（回退方案，异步 + 分片防止阻塞事件循环）
  */
 async function searchFilesNative(rootPath, filePattern, recursive, maxResults) {
   const results = [];
@@ -154,14 +158,23 @@ async function searchFilesNative(rootPath, filePattern, recursive, maxResults) {
       if (entry.isDirectory()) {
         if (DEFAULT_IGNORE_DIRS.has(entry.name)) continue;
         if (entry.name.startsWith('.')) continue;
+        // 目录也参与搜索匹配
+        if (matchGlob(entry.name, filePattern)) {
+          try {
+            const s = await stat(fullPath);
+            results.push({ path: fullPath, name: entry.name, type: 'directory', size: s.size, mtime: s.mtimeMs });
+          } catch {
+            results.push({ path: fullPath, name: entry.name, type: 'directory', size: 0, mtime: 0 });
+          }
+        }
         await walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
         if (matchGlob(entry.name, filePattern)) {
           try {
             const s = await stat(fullPath);
-            results.push({ path: fullPath, name: entry.name, size: s.size, mtime: s.mtimeMs });
+            results.push({ path: fullPath, name: entry.name, type: 'file', size: s.size, mtime: s.mtimeMs });
           } catch {
-            results.push({ path: fullPath, name: entry.name, size: 0, mtime: 0 });
+            results.push({ path: fullPath, name: entry.name, type: 'file', size: 0, mtime: 0 });
           }
         }
       }

package/src/security.js

@@ -28,6 +28,9 @@ const HARD_BLOCKED_PATHS = [
   join(AGENT_DIR, 'pairings.json'),   // 配对记录
   join(AGENT_DIR, 'mcp_servers.json'),// MCP 服务器配置
   join(AGENT_DIR, 'logs') + sep,      // 日志目录
+  join(AGENT_DIR, '.trash') + sep,    // 回收站目录（通过 /api/trash 端点管理）
+  join(AGENT_DIR, 'builtin_skills_state.json'), // 内置技能状态
+  join(AGENT_DIR, 'disabled_skills.json'),      // 停用技能状态
 ];
 
 /**