ai-helper-agent 1.12.3 → 1.14.0

package/package.json

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

package/src/auth.js

@@ -42,30 +42,35 @@ function getCurrentPairCode() {
 }
 
 /**
- * 启动配对码定时刷新
- * - 如果有配对记录且最近有活跃认证（5分钟内），跳过刷新
- * - 否则启动定时刷新，允许新扩展配对
+ * 启动配对码定时刷新（运行中持续重新评估）
+ * - 每个 tick 检查：有配对记录且最近有活跃认证（5分钟内）→ 停止刷新配对码
+ * - 否则（无配对 / 插件离线超时）→ 刷新配对码，允许新扩展配对
+ * - 这样：插件在线时不刷新配对码；插件断开超时后自动恢复刷新
  */
 function startPairCodeRotation() {
   const config = loadConfig();
-  const pairings = loadPairings();
-  const hasPairings = Object.keys(pairings).length > 0;
-  const isRecentlyActive = (Date.now() - lastAuthTime) < ACTIVE_WINDOW_MS;
-
-  // 有配对且最近有活跃连接，无需刷新配对码
-  if (hasPairings && isRecentlyActive) {
-    currentPairCode = generatePairCode();
-    console.log(`\n[Agent] 配对码: ${currentPairCode}\n`);
-    return;
-  }
-
   const ttl = (config.pairCodeTTL || 30) * 1000;
 
+  // 启动时立即生成一个配对码（供首次配对；启动时 lastAuthTime=0，必然需要刷新）
   currentPairCode = generatePairCode();
   console.log(`\n[Agent] 配对码: ${currentPairCode}\n`);
 
   if (pairCodeTimer) clearInterval(pairCodeTimer);
   pairCodeTimer = setInterval(() => {
+    const pairings = loadPairings();
+    const hasPairings = Object.keys(pairings).length > 0;
+    const isRecentlyActive = (Date.now() - lastAuthTime) < ACTIVE_WINDOW_MS;
+
+    // 有配对且最近有活跃连接：停止刷新配对码（插件在线，无需新配对）
+    if (hasPairings && isRecentlyActive) {
+      if (currentPairCode !== null) {
+        currentPairCode = null;
+        console.log('[Agent] 检测到活跃连接，停止刷新配对码');
+      }
+      return;
+    }
+
+    // 无配对或插件离线超时：刷新配对码，允许新扩展配对
     currentPairCode = generatePairCode();
     console.log(`[Agent] 配对码已更新: ${currentPairCode}`);
   }, ttl);

package/src/executor.js

@@ -1,5 +1,6 @@
 // agent/src/executor.js - 命令执行器（child_process + 流式输出）
 import { spawn, exec } from 'child_process';
+import { existsSync } from 'fs';
 import crypto from 'crypto';
 import os from 'os';
 import { loadConfig } from './config.js';
@@ -23,7 +24,7 @@ function getShellForExec() {
       ];
       for (const path of gitBashPaths) {
         try {
-          if (require('fs').existsSync(path)) {
+          if (existsSync(path)) {
             return { shell: path, args: ['-c'] };
           }
         } catch {}

package/src/search.js

@@ -231,13 +231,21 @@ export async function searchFiles(rootPath, filePattern = '*', recursive = true,
 /**
  * 使用 rg 搜索文件内容（快速）
  */
-function searchContentWithRg(rootPath, pattern, filePattern, maxResults, contextLines) {
+function searchContentWithRg(rootPath, pattern, filePattern, caseSensitive, recursive, maxResults, contextLines) {
   return new Promise((resolve) => {
     const args = [
       '--no-heading', '--line-number',
       '--max-count', String(maxResults),
       '-C', String(contextLines)
     ];
+    // 大小写不敏感时添加 -i（与 searchContentNative 的 caseSensitive 语义对齐）
+    if (!caseSensitive) {
+      args.push('-i');
+    }
+    // 非递归搜索：仅搜索直接子文件，不进入子目录（与 fd --max-depth 1 语义一致）
+    if (!recursive) {
+      args.push('--max-depth', '1');
+    }
     if (filePattern) {
       args.push('--glob', filePattern);
     }
@@ -255,10 +263,12 @@ function searchContentWithRg(rootPath, pattern, filePattern, maxResults, context
 
     proc.stdout.on('data', (chunk) => stdout.push(chunk));
 
-    proc.on('close', (code) => {
+    proc.on('close', () => {
       clearTimeout(timeout);
       if (timedOut) return;
-      if (code !== 0 && code !== 1) { resolve([]); return; } // 1 = no matches
+      // 不再按退出码过滤：Windows 下 rg 可能返回退出码 2（错误）但仍带有效匹配结果，
+      // 原逻辑 `code !== 0 && code !== 1` 会把这种情况的输出一并丢弃，导致有匹配却返回 0 条。
+      // 只要 stdout 有内容就解析；stdout 为空时 parseRgOutput 自然返回 []。
       const output = Buffer.concat(stdout).toString('utf-8').trim();
       resolve(parseRgOutput(output, contextLines));
     });
@@ -298,7 +308,7 @@ function parseRgOutput(output, contextLines) {
 /**
  * Node.js 原生搜索文件内容（回退方案，异步 + 分片防止阻塞事件循环）
  */
-async function searchContentNative(rootPath, pattern, filePattern, caseSensitive, maxResults, contextLines) {
+async function searchContentNative(rootPath, pattern, filePattern, caseSensitive, recursive, maxResults, contextLines) {
   const results = [];
   const searchPattern = caseSensitive ? pattern : pattern.toLowerCase();
 
@@ -319,6 +329,8 @@ async function searchContentNative(rootPath, pattern, filePattern, caseSensitive
       if (entry.isDirectory()) {
         if (DEFAULT_IGNORE_DIRS.has(entry.name)) continue;
         if (entry.name.startsWith('.')) continue;
+        // 非递归搜索：跳过子目录，仅搜索当前目录下的文件
+        if (!recursive) continue;
         await walk(fullPath);
       } else if (entry.isFile()) {
         if (filePattern && !matchGlob(entry.name, filePattern)) continue;
@@ -366,11 +378,12 @@ async function searchContentNative(rootPath, pattern, filePattern, caseSensitive
  * @param {string} pattern - 搜索文本
  * @param {string} [filePattern] - 可选文件类型过滤，如 "*.js"
  * @param {boolean} caseSensitive - 是否大小写敏感
+ * @param {boolean} recursive - 是否递归搜索子目录
  * @param {number} maxResults - 最大结果数
  * @param {number} contextLines - 上下文行数
  * @returns {{ success: boolean, results: Array, total: number, engine: string }}
  */
-export async function searchContent(rootPath, pattern, filePattern = null, caseSensitive = false, maxResults = 100, contextLines = 2) {
+export async function searchContent(rootPath, pattern, filePattern = null, caseSensitive = false, recursive = true, maxResults = 100, contextLines = 2) {
   const pathCheck = await checkPath(rootPath);
   if (!pathCheck.allowed) {
     return { success: false, error: pathCheck.reason };
@@ -389,9 +402,9 @@ export async function searchContent(rootPath, pattern, filePattern = null, caseS
 
   let results;
   if (rgAvailable) {
-    results = await searchContentWithRg(resolved, pattern, filePattern, maxResults, contextLines);
+    results = await searchContentWithRg(resolved, pattern, filePattern, caseSensitive, recursive, maxResults, contextLines);
   } else {
-    results = await searchContentNative(resolved, pattern, filePattern, caseSensitive, maxResults, contextLines);
+    results = await searchContentNative(resolved, pattern, filePattern, caseSensitive, recursive, maxResults, contextLines);
   }
 
   return {

package/src/security.js

@@ -8,13 +8,22 @@ const isWin32 = platform() === 'win32';
 
 function normalizePathFormat(pathStr) {
   if (!pathStr || typeof pathStr !== 'string') return pathStr;
-
+  // 1. 把异常的 "/C:/" 形式（带前导斜杠的盘符）规整为 "C:/"
+  //    仅匹配 /<字母>:/ ，不会误伤 /home/ 等普通路径段
+  pathStr = pathStr.replace(/\/([a-zA-Z]):(\/|$)/g, '$1:$2');
+  // 2. MSYS/Git Bash 风格路径：/d/Users/... → D:/Users/...
+  //    前导 / + 单字母盘符 + / ，无冒号，是 MSYS 特有的挂载点表示法
   if (isWin32) {
-    pathStr = pathStr.replace(/\/([a-zA-Z])\//g, '$1:/');
-    pathStr = pathStr.replace(/\/([a-zA-Z]):/g, '$1:/');
-    pathStr = pathStr.replace(/\//g, '\\');
+    pathStr = pathStr.replace(/^\/([a-zA-Z])\//, '$1:/');
+  }
+  // 3. 统一为正斜杠（path.resolve/normalize 在所有平台都能正确处理正斜杠并归一化到平台分隔符）
+  pathStr = pathStr.replace(/\\/g, '/');
+  // 4. Windows 盘符统一为大写：d:/ → D:/
+  //    path.resolve 保留盘符原始大小写，而白名单前缀比较是大小写敏感的字符串比较，
+  //    小写盘符路径与大写盘符白名单前缀比较会失败（d:\Users\.startsWith(D:\Users\) → false）
+  if (isWin32) {
+    pathStr = pathStr.replace(/^([a-zA-Z]):/, m => m.toUpperCase());
   }
-
   return pathStr;
 }
 
@@ -90,6 +99,28 @@ async function checkPath(pathStr) {
       return { allowed: true, resolved: normalized };
     }
 
+    // 0.6. 工作目录永远放行（不受 allowedPaths 配置控制）
+    //      workdir 是用户当前选定的操作目录，必须始终可访问，即使未在 allowedPaths 中也不应被拦截
+    if (normalizedWorkdir) {
+      const workdirResolved = resolve(normalizedWorkdir);
+      const workdirPrefix = workdirResolved.endsWith(sep) ? workdirResolved : workdirResolved + sep;
+      if (normalized.startsWith(workdirPrefix) || normalized === workdirResolved) {
+        // realpath 硬阻止检查：防止通过 workdir 内的符号链接绕过到代理系统文件
+        try {
+          const realPath = await realpath(resolved);
+          if (isHardBlocked(realPath)) {
+            return { allowed: false, reason: '禁止访问代理系统文件' };
+          }
+        } catch (err) {
+          if (err.code !== 'ENOENT') {
+            return { allowed: false, reason: `无法解析路径: ${err.message}` };
+          }
+          // ENOENT：路径尚不存在（如待创建的文件），无法通过符号链接绕过，放行
+        }
+        return { allowed: true, resolved: normalized };
+      }
+    }
+
     const allowedPaths = config.allowedPaths.length > 0 ? config.allowedPaths.map(p => normalizePathFormat(p)) : [normalizedWorkdir];
 
     // 先做前缀检查（快速路径，兼容 Windows/Unix）
@@ -188,6 +219,11 @@ const BLACKLIST_PATTERNS = [
   // Shell 命令替换注入 — 允许 echo/printf 等纯输出命令中使用
   /^\s*(?!(echo|printf|cat|head|tail|wc|ls|pwd|date|whoami|hostname|uname|id|env|printenv|which|type)\s).*`[^`]*`/,
   /^\s*(?!(echo|printf|cat|head|tail|wc|ls|pwd|date|whoami|hostname|uname|id|env|printenv|which|type)\s).*\$\s*\([^)]*\)/,
+  // Windows 高危破坏性命令（大小写不敏感）
+  /^\s*format\s+[a-zA-Z]:/i,                                                          // 格式化磁盘
+  /^\s*diskpart\b/i,                                                                  // 磁盘分区操作
+  /^\s*>\s*[a-zA-Z]:[\\\/][^\n]*[\\\/]Windows[\\\/]System32[\\\/]config[\\\/](SAM|SYSTEM|SECURITY|DEFAULT|NTUSER)/i, // 覆盖注册表蜂巢
+  /^\s*>\s*[a-zA-Z]:[\\\/][^\n]*[\\\/]drivers[\\\/]etc[\\\/]hosts/i,                  // 覆盖 hosts
 ];
 const SCRIPT_EXTENSIONS = '(sh|bash|zsh|py|js|mjs|rb|pl|php|lua)';
 const SCRIPT_INTERPRETERS = '(bash|sh|zsh|python3?|node|ruby|perl|php|lua)';
@@ -208,7 +244,17 @@ const GRAYLIST_PATTERNS = [
   // 直接执行脚本
   { pattern: new RegExp(`^\\s*\\.?\\/\\S*\\.${SCRIPT_EXTENSIONS}\\b`), reason: '直接执行脚本文件' },
   // chmod +x 授予执行权限
-  { pattern: /^\s*chmod\s+(\+x|a\+x|u\+x|g\+x|o\+x|[0-7]*[1-7][0-7][0-7])\s/, reason: '修改文件执行权限' },
+  { pattern: /^\s*chmod\s+(\+x|a\+x|u\+x|g\+x|o\+x|[0-7]*[1-7][0-9][0-9])\s/, reason: '修改文件执行权限' },
+
+  // Windows 命令（大小写不敏感）
+  { pattern: /^\s*rmdir?\s+\/s\b/i, reason: '递归删除目录 (rd/rmdir /s)' },
+  { pattern: /^\s*(del|erase)\s+\/[a-zA-Z]*f/i, reason: '强制删除文件 (del /f)' },
+  { pattern: /^\s*icacls\b/i, reason: '修改文件权限 (icacls)' },
+  { pattern: /^\s*takeown\b/i, reason: '夺取文件所有权 (takeown)' },
+  { pattern: /^\s*reg\s+(add|delete|import|load|restore)\b/i, reason: '修改注册表 (reg)' },
+  { pattern: /^\s*net\s+(user|localgroup)\b/i, reason: '用户/用户组管理 (net)' },
+  { pattern: /^\s*sc\s+(stop|delete|config)\b/i, reason: '服务管理 (sc)' },
+  { pattern: /^\s*taskkill\s+\/[a-zA-Z]*f/i, reason: '强制结束进程 (taskkill /f)' },
 ];
 
 /**
@@ -235,8 +281,11 @@ function checkCommand(command, force = false) {
   }
 
   // 1.5 禁止访问核心敏感文件（通过命令也一样拦截）
+  // Windows 文件系统不区分大小写，归一化比较防止 .AI-HELPER-AGENT 等大小写变换绕过
+  const cmpTrimmed = isWin32 ? trimmed.toLowerCase() : trimmed;
   for (const blocked of HARD_BLOCKED_PATHS) {
-    if (trimmed.includes(blocked)) {
+    const cmpBlocked = isWin32 ? blocked.toLowerCase() : blocked;
+    if (cmpTrimmed.includes(cmpBlocked)) {
       return {
         safe: false,
         level: 'deny',

package/src/server.js

@@ -3,14 +3,14 @@ import http from 'http';
 import { WebSocketServer } from 'ws';
 import { readFileSync, createWriteStream, createReadStream, statSync, existsSync } from 'fs';
 import { readFile, writeFile, readdir, stat, unlink, rmdir, chmod, mkdir, rename } from 'fs/promises';
-import { join, dirname, basename, resolve } from 'path';
-import { fileURLToPath } from 'url';
+import { join, dirname, basename, resolve, isAbsolute, relative } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { ZipArchive } from 'archiver';
 import { homedir, tmpdir } from 'os';
 import { spawn } from 'child_process';
 import { randomBytes } from 'crypto';
 import os from 'os';
-import { loadConfig } from './config.js';
+import { loadConfig, saveConfig } from './config.js';
 import { verifyToken, startPairCodeRotation, stopPairCodeRotation, handlePairRequest } from './auth.js';
 import { checkPath, checkCommand } from './security.js';
 import { moveToTrash, restoreFromTrash, listTrash, startPeriodicCleanup, stopPeriodicCleanup } from './trash.js';
@@ -50,6 +50,30 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const AGENT_VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8')).version;
 const AGENT_START_TIME = Date.now();
 
+/**
+ * 计算多个路径的共同父目录（跨平台，正确处理 Windows 盘符）
+ * 用 path.dirname + path.relative 替代手工 split('/')，避免破坏盘符（如 /C:/Users）
+ * @param {string[]} paths - 绝对路径数组
+ * @returns {string} 共同父目录（始终为目录路径）
+ */
+function computeCommonParent(paths) {
+  if (!paths || paths.length === 0) return '';
+  let common = dirname(resolve(paths[0]));
+  for (let i = 1; i < paths.length; i++) {
+    const p = resolve(paths[i]);
+    // 逐层上移 common，直到 p 落在 common 之下或 common 已到根
+    while (true) {
+      const parent = dirname(common);
+      if (parent === common) break; // 已到根目录（如 / 或 C:\）
+      const rel = relative(common, p);
+      // rel 为空表示同路径；不以 '..' 开头且非绝对路径表示 p 在 common 之下
+      if (rel === '' || (!rel.startsWith('..') && !isAbsolute(rel))) break;
+      common = parent;
+    }
+  }
+  return common;
+}
+
 /**
  * 跨平台 ZIP 打包（使用 archiver，替换 spawn zip）
  * @param {string[]} sourceNames - 源文件/目录名（basename）
@@ -397,6 +421,10 @@ export function startServer() {
     }
     const pathname = url.pathname;
 
+    // 每次请求重新加载配置（切换 workdir 后立即生效，避免启动快照过期）
+    // 遮蔽 startServer 外层的启动快照 config；loadConfig 有 mtime 缓存，无变化时仅一次 statSync
+    const config = loadConfig();
+
     // ---------- 无需认证的接口 ----------
 
     // 配对
@@ -440,6 +468,11 @@ export function startServer() {
       return jsonResponse(res, 403, { success: false, error: '认证 token 无效' });
     }
 
+    // 心跳接口（需认证）：仅刷新 lastAuthTime 维持"插件在线"状态，不返回敏感信息
+    if (req.method === 'GET' && pathname === '/api/heartbeat') {
+      return jsonResponse(res, 200, { success: true, time: Date.now() });
+    }
+
     // Agent 关闭（需认证）
     if (req.method === 'POST' && pathname === '/api/shutdown') {
       if (agentOperationInProgress) {
@@ -754,6 +787,114 @@ export function startServer() {
       try { body = await parseBody(req); }
       catch (err) { return jsonResponse(res, 400, { success: false, error: err.message }); }
 
+      // === 工作目录切换（需认证） ===
+      if (pathname === '/api/config/workdir' && req.method === 'POST') {
+        const newWorkdir = body.workdir;
+        if (!newWorkdir || typeof newWorkdir !== 'string') {
+          return jsonResponse(res, 400, { success: false, error: '缺少 workdir 参数' });
+        }
+
+        // 展开 ~ 到用户主目录
+        let resolvedWorkdir = newWorkdir.trim();
+        if (resolvedWorkdir === '~') {
+          resolvedWorkdir = homedir();
+        } else if (resolvedWorkdir.startsWith('~/')) {
+          resolvedWorkdir = join(homedir(), resolvedWorkdir.slice(2));
+        }
+
+        // 必须是绝对路径（跨平台：path.isAbsolute 覆盖 Unix /、Windows 盘符、UNC 路径）
+        if (!isAbsolute(resolvedWorkdir)) {
+          return jsonResponse(res, 400, { success: false, error: 'workdir 必须是绝对路径' });
+        }
+        resolvedWorkdir = resolve(resolvedWorkdir);
+
+        // 禁止设为 Agent 系统目录本身（防敏感文件暴露）
+        const AGENT_DIR_PATH = join(homedir(), '.ai-helper-agent');
+        if (resolvedWorkdir === AGENT_DIR_PATH) {
+          logSecurity('workdir_switch_blocked', { path: resolvedWorkdir, reason: '禁止设为 Agent 系统目录' });
+          return jsonResponse(res, 403, { success: false, error: '不能将 Agent 系统目录设为工作目录' });
+        }
+
+        try {
+          // 目录不存在则自动创建（mkdir -p）
+          await mkdir(resolvedWorkdir, { recursive: true });
+
+          // 重新加载最新配置（防并发修改），更新 workdir + allowedPaths（只增不减）
+          const freshConfig = loadConfig();
+          const updatedConfig = { ...freshConfig };
+          updatedConfig.workdir = resolvedWorkdir;
+          if (!Array.isArray(updatedConfig.allowedPaths)) {
+            updatedConfig.allowedPaths = [resolvedWorkdir];
+          } else if (!updatedConfig.allowedPaths.includes(resolvedWorkdir)) {
+            updatedConfig.allowedPaths = [...updatedConfig.allowedPaths, resolvedWorkdir];
+          }
+
+          await saveConfig(updatedConfig);
+
+          logSystem('workdir_switched', { old: freshConfig.workdir, new: resolvedWorkdir, extId });
+          return jsonResponse(res, 200, {
+            success: true,
+            workdir: resolvedWorkdir,
+            allowedPaths: updatedConfig.allowedPaths,
+            message: '工作目录已切换'
+          });
+        } catch (err) {
+          logError('config', 'workdir_switch_error', { path: resolvedWorkdir, error: err.message });
+          return jsonResponse(res, 500, { success: false, error: `切换工作目录失败: ${err.message}` });
+        }
+      }
+
+      // === 移除允许访问的目录（需认证，不可移除当前工作目录） ===
+      if (pathname === '/api/config/allowed-paths/remove' && req.method === 'POST') {
+        const targetPath = body.path;
+        if (!targetPath || typeof targetPath !== 'string') {
+          return jsonResponse(res, 400, { success: false, error: '缺少 path 参数' });
+        }
+
+        let resolvedPath = targetPath.trim();
+        if (resolvedPath === '~') {
+          resolvedPath = homedir();
+        } else if (resolvedPath.startsWith('~/')) {
+          resolvedPath = join(homedir(), resolvedPath.slice(2));
+        }
+        if (!isAbsolute(resolvedPath)) {
+          return jsonResponse(res, 400, { success: false, error: 'path 必须是绝对路径' });
+        }
+        resolvedPath = resolve(resolvedPath);
+
+        try {
+          const freshConfig = loadConfig();
+          const currentWorkdir = resolve(freshConfig.workdir || '');
+          // 禁止移除当前工作目录
+          if (resolvedPath === currentWorkdir) {
+            return jsonResponse(res, 400, { success: false, error: '不能移除当前工作目录，请先切换到其它目录' });
+          }
+
+          const allowedPaths = Array.isArray(freshConfig.allowedPaths) ? freshConfig.allowedPaths : [];
+          // 跨平台路径比较：统一分隔符 + 大小写不敏感
+          const norm = s => s.replace(/\\/g, '/').toLowerCase();
+          const filtered = allowedPaths.filter(p => norm(p) !== norm(resolvedPath));
+
+          // 没有变化说明该路径不在列表中
+          if (filtered.length === allowedPaths.length) {
+            return jsonResponse(res, 200, { success: true, allowedPaths: filtered, message: '该目录不在允许列表中' });
+          }
+
+          const updatedConfig = { ...freshConfig, allowedPaths: filtered };
+          await saveConfig(updatedConfig);
+
+          logSystem('allowed_path_removed', { path: resolvedPath, extId });
+          return jsonResponse(res, 200, {
+            success: true,
+            allowedPaths: updatedConfig.allowedPaths,
+            message: '已从允许列表中移除'
+          });
+        } catch (err) {
+          logError('config', 'allowed_path_remove_error', { path: resolvedPath, error: err.message });
+          return jsonResponse(res, 500, { success: false, error: `移除允许目录失败: ${err.message}` });
+        }
+      }
+
       // === 文件操作 ===
 
       // 搜索文件（按文件名模式）
@@ -787,6 +928,7 @@ export function startServer() {
             body.pattern,
             body.filePattern || null,
             body.caseSensitive || false,
+            body.recursive !== false,
             maxResults,
             body.contextLines !== undefined ? body.contextLines : 2
           );
@@ -1012,19 +1154,7 @@ export function startServer() {
           const tmpFile = join(tmpdir(), `ws-dl-${randomBytes(6).toString('hex')}.zip`);
           try {
             const zipArgs = resolvedPaths.map(p => basename(p));
-            const commonParent = resolvedPaths.reduce((a, b) => {
-              const sep = '/';
-              const partsA = a.replace(/\\/g, '/').split('/').filter(Boolean);
-              const partsB = b.replace(/\\/g, '/').split('/').filter(Boolean);
-              const common = [];
-              for (let i = 0; i < Math.min(partsA.length, partsB.length); i++) {
-                if (partsA[i] === partsB[i]) common.push(partsA[i]);
-                else break;
-              }
-              const result = sep + common.join(sep);
-              // Windows 盘符处理：C:/Users -> 而不是 /C:/Users
-              return result;
-            });
+            const commonParent = computeCommonParent(resolvedPaths);
 
             const zipBuffer = await createZipBuffer(zipArgs, commonParent, tmpFile);
             logFs('download_multi', { paths: resolvedPaths, zipSize: zipBuffer.length });
@@ -1105,16 +1235,7 @@ export function startServer() {
             const tmpFile = join(tmpdir(), `ws-dl-${randomBytes(6).toString('hex')}.zip`);
             try {
               const zipArgs = resolvedPaths.map(p => basename(p));
-              const commonParent = resolvedPaths.reduce((a, b) => {
-                const partsA = a.split('/').filter(Boolean);
-                const partsB = b.split('/').filter(Boolean);
-                const common = [];
-                for (let i = 0; i < Math.min(partsA.length, partsB.length); i++) {
-                  if (partsA[i] === partsB[i]) common.push(partsA[i]);
-                  else break;
-                }
-                return '/' + common.join('/');
-              });
+              const commonParent = computeCommonParent(resolvedPaths);
               const zipBuffer = await createZipBuffer(zipArgs, commonParent, tmpFile);
               logFs('download_multi_stream', { paths: resolvedPaths, zipSize: zipBuffer.length });
               const zipName = `workspace_${new Date().toISOString().slice(0, 19).replace(/:/g, '-')}.zip`;
@@ -1349,7 +1470,7 @@ export function startServer() {
           return jsonResponse(res, 404, { success: false, error: '文件不存在' });
         }
 
-        const fileUrl = `file://${check.resolved}`;
+        const fileUrl = pathToFileURL(check.resolved).href;
         const platform = os.platform();
         let cmd, args, spawnOpts;
         if (platform === 'darwin') {

package/src/skill/executor.js

@@ -133,6 +133,7 @@ async function executeToolCall(toolName, args) {
             args.pattern,
             args.filePattern || null,
             args.caseSensitive || false,
+            args.recursive !== false,
             Math.min(args.maxResults || 100, 5000),
             args.contextLines || 2
           );

package/src/skill/markdown-loader.js

@@ -1,6 +1,6 @@
 // skill/markdown-loader.js - Markdown Skill 加载器
 // 扫描子目录中的 SKILL.md，解析 YAML frontmatter 和正文内容
-import { readFileSync, readdirSync, existsSync, statSync, writeFileSync, mkdirSync, rmSync } from 'fs';
+import { readFileSync, readdirSync, existsSync, statSync, writeFileSync, mkdirSync, rmSync, cpSync } from 'fs';
 import { join, basename, extname, normalize, sep } from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
@@ -359,8 +359,18 @@ export async function importMarkdownSkillFromZip(skillsDir, zipBuffer, skillName
     mkdirSync(tmpDir, { recursive: true });
     writeFileSync(tmpZip, zipBuffer);
 
-    // 解压到临时目录（execFile 数组参数，不经 shell，杜绝命令注入）
-    await execFileAsync('unzip', ['-o', tmpZip, '-d', tmpDir], { timeout: 30000, windowsHide: true });
+    // 解压到临时目录（跨平台：Windows 用 PowerShell Expand-Archive，Unix 用 unzip）
+    if (process.platform === 'win32') {
+      // PowerShell 单引号转义：路径中的单引号用两个单引号表示（tmpZip/tmpDir 由程序生成，正常不含单引号）
+      const esc = (s) => s.replace(/'/g, "''");
+      await execFileAsync('powershell.exe',
+        ['-NoProfile', '-NonInteractive', '-Command',
+         `Expand-Archive -LiteralPath '${esc(tmpZip)}' -DestinationPath '${esc(tmpDir)}' -Force`],
+        { timeout: 30000, windowsHide: true });
+    } else {
+      // execFile 数组参数，不经 shell，杜绝命令注入
+      await execFileAsync('unzip', ['-o', tmpZip, '-d', tmpDir], { timeout: 30000, windowsHide: true });
+    }
 
     // 查找 SKILL.md
     const entries = readdirSync(tmpDir);
@@ -413,8 +423,8 @@ export async function importMarkdownSkillFromZip(skillsDir, zipBuffer, skillName
       rmSync(destDir, { recursive: true, force: true });
     }
 
-    // 复制（execFile 数组参数，不经 shell）
-    await execFileAsync('cp', ['-r', skillDir + '/.', destDir], { timeout: 30000, windowsHide: true });
+    // 复制（跨平台：fs.cpSync 替代 cp -r，Windows 无 cp 命令；destDir 已被 rmSync 清空）
+    cpSync(skillDir, destDir, { recursive: true });
 
     // 重新加载
     const skill = loadMarkdownSkill(destDir);