ai-helper-agent 1.12.2 → 1.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-helper-agent",
-  "version": "1.12.2",
+  "version": "1.13.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 {}
@@ -370,10 +371,8 @@ function killProcess(execId) {
 
   if (isWin) {
     // Windows: /T 递归终止整个进程树
-    exec(`taskkill /T /PID ${pid}`, (err) => {
-      if (err) {
-        exec(`taskkill /F /T /PID ${pid}`, () => {});
-      }
+    spawn('taskkill', ['/T', '/PID', String(pid)], { windowsHide: true }).on('error', () => {
+      spawn('taskkill', ['/F', '/T', '/PID', String(pid)], { windowsHide: true });
     });
   } else {
     // Unix: 负 PID 表示杀整个进程组（detached + 未调用 setsid 时有效）
@@ -399,7 +398,7 @@ function killProcess(execId) {
     try {
       if (entry.process.exitCode === null) {
         if (isWin) {
-          exec(`taskkill /F /T /PID ${pid}`, () => {});
+          spawn('taskkill', ['/F', '/T', '/PID', String(pid)], { windowsHide: true });
         } else {
           try { process.kill(-pid, 'SIGKILL'); }
           catch { try { entry.process.kill('SIGKILL'); } catch {} }

package/src/security.js

@@ -8,14 +8,12 @@ const isWin32 = platform() === 'win32';
 
 function normalizePathFormat(pathStr) {
   if (!pathStr || typeof pathStr !== 'string') return pathStr;
-
-  if (isWin32) {
-    pathStr = pathStr.replace(/\/([a-zA-Z])\//g, '$1:/');
-    pathStr = pathStr.replace(/\/([a-zA-Z]):/g, '$1:/');
-    pathStr = pathStr.replace(/\//g, '\\');
-  }
-
-  return pathStr;
+  // 防御性修复：把异常的 "/C:/" 形式（带前导斜杠的盘符）规整为 "C:/"
+  // 仅匹配 /<字母>:/ ，不会误伤 /home/ 等普通路径段
+  pathStr = pathStr.replace(/\/([a-zA-Z]):(\/|$)/g, '$1:$2');
+  // 统一为正斜杠（path.resolve/normalize 在所有平台都能正确处理正斜杠并归一化到平台分隔符）
+  // 不再做盘符相关的激进转换，避免把 /home/user 误转为 home:\user
+  return pathStr.replace(/\\/g, '/');
 }
 
 // ==================== 硬阻止目录（任何情况下都不可访问） ====================
@@ -90,6 +88,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 +208,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 +233,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 +270,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();
+
     // ---------- 无需认证的接口 ----------
 
     // 配对
@@ -420,6 +448,7 @@ export function startServer() {
         version: AGENT_VERSION,
         running: true,
         platform: PLATFORM_INFO.platform,
+        platformName: PLATFORM_INFO.platformName,
         arch: PLATFORM_INFO.arch,
         nodeVersion: PLATFORM_INFO.nodeVersion,
         searchTools: getSearchToolsAvailable()
@@ -439,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) {
@@ -537,7 +571,8 @@ export function startServer() {
           const result = await new Promise((resolvePromise) => {
             const npm = spawn('npm', ['install', '-g', 'ai-helper-agent@latest', '--no-audit', '--no-fund'], {
               shell: true,
-              env: { ...process.env }
+              env: { ...process.env },
+              windowsHide: true
             });
             npm.stdout.on('data', d => npmOutput.push(d.toString().trim()));
             npm.stderr.on('data', d => npmOutput.push(d.toString().trim()));
@@ -752,6 +787,63 @@ 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}` });
+        }
+      }
+
       // === 文件操作 ===
 
       // 搜索文件（按文件名模式）
@@ -1010,19 +1102,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 });
@@ -1103,16 +1183,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`;
@@ -1347,7 +1418,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

@@ -1,9 +1,9 @@
 // skill/executor.js - Skill 执行引擎
 // 解析 Skill 定义的步骤 DAG，按拓扑排序执行，支持并行
 import { render } from './template.js';
-import { readFile, writeFile, readdir, stat } from 'fs/promises';
+import { readFile, writeFile, readdir, stat, unlink } from 'fs/promises';
 import { checkPath, checkCommand } from '../security.js';
-import { join } from 'path';
+import { join, basename } from 'path';
 
 // 执行上下文（当前活跃的执行任务）
 const activeExecutions = new Map(); // execId → { skill, status, steps, results }
@@ -47,32 +47,53 @@ async function executeToolCall(toolName, args) {
   // 映射 Skill 步骤中的 tool 到实际 Agent API
   try {
     switch (toolName) {
-      case 'agent_read_file': {
-        const check = await checkPath(args.path);
-        if (!check.allowed) return { success: false, error: check.reason };
-        const content = await readFile(check.resolved, 'utf-8');
-        return { success: true, content, size: content.length, path: check.resolved };
-      }
-
-      case 'agent_write_file': {
+      case 'agent_file':
+      case 'agent_read_file':
+      case 'agent_write_file':
+      case 'agent_list_dir':
+      case 'agent_delete_file':
+      case 'agent_download_file': {
+        const action = args.action || (
+          toolName === 'agent_read_file' ? 'read' :
+          toolName === 'agent_write_file' ? 'write' :
+          toolName === 'agent_list_dir' ? 'list' :
+          toolName === 'agent_delete_file' ? 'delete' :
+          toolName === 'agent_download_file' ? 'download' :
+          (args.content ? 'write' : 'read')
+        );
         const check = await checkPath(args.path);
         if (!check.allowed) return { success: false, error: check.reason };
-        await writeFile(check.resolved, String(args.content || ''), 'utf-8');
-        return { success: true, message: `文件已写入: ${check.resolved}` };
-      }
-
-      case 'agent_list_dir': {
-        const check = await checkPath(args.path || '.');
-        if (!check.allowed) return { success: false, error: check.reason };
-        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 };
+        switch (action) {
+          case 'read': {
+            const content = await readFile(check.resolved, 'utf-8');
+            return { success: true, content, size: content.length, path: check.resolved };
+          }
+          case 'write': {
+            await writeFile(check.resolved, String(args.content || ''), 'utf-8');
+            return { success: true, message: `文件已写入: ${check.resolved}` };
+          }
+          case 'list': {
+            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 };
+          }
+          case 'delete': {
+            await unlink(check.resolved);
+            return { success: true, message: `已删除: ${check.resolved}` };
+          }
+          case 'download': {
+            const content = await readFile(check.resolved);
+            return { success: true, content, path: check.resolved, filename: basename(check.resolved) };
+          }
+          default:
+            return { success: false, error: `未知 action: ${action}` };
+        }
       }
 
-      case 'agent_exec_command': {
+      case 'agent_exec': {
         const cmdCheck = checkCommand(args.command, false);
         if (cmdCheck.level === 'deny') {
           return { success: false, error: cmdCheck.reason };
@@ -87,7 +108,8 @@ async function executeToolCall(toolName, args) {
             cwd: args.cwd || process.cwd(),
             encoding: 'utf-8',
             timeout: 30000,
-            maxBuffer: 10 * 1024 * 1024
+            maxBuffer: 10 * 1024 * 1024,
+            windowsHide: true
           }, (error, stdout, stderr) => {
             if (error) {
               resolve({ success: false, error: error.message, stdout, stderr });
@@ -98,8 +120,23 @@ async function executeToolCall(toolName, args) {
         });
       }
 
-      case 'agent_search_files': {
-        const { searchFiles } = await import('../search.js');
+      case 'agent_search':
+      case 'agent_search_files':
+      case 'agent_search_content': {
+        const searchType = args.searchType || (
+          toolName === 'agent_search_content' ? 'content' : 'file'
+        );
+        const { searchFiles, searchContent } = await import('../search.js');
+        if (searchType === 'content') {
+          return await searchContent(
+            args.path || '.',
+            args.pattern,
+            args.filePattern || null,
+            args.caseSensitive || false,
+            Math.min(args.maxResults || 100, 5000),
+            args.contextLines || 2
+          );
+        }
         return await searchFiles(
           args.path || '.',
           args.pattern || '*',
@@ -108,18 +145,6 @@ async function executeToolCall(toolName, args) {
         );
       }
 
-      case 'agent_search_content': {
-        const { searchContent } = await import('../search.js');
-        return await searchContent(
-          args.path || '.',
-          args.pattern,
-          args.filePattern || null,
-          args.caseSensitive || false,
-          Math.min(args.maxResults || 100, 5000),
-          args.contextLines || 2
-        );
-      }
-
       default:
         return { success: false, error: `未知工具: ${toolName}` };
     }

package/src/skill/loader.js

@@ -256,19 +256,23 @@ export function deleteSkillFile(name, type) {
 /**
  * 种子 skill-creator 内置技能到文件系统
  * 首次运行时将 skill-creator 的 SKILL.md 写入 ~/.ai-helper-agent/skills/skill-creator/
- * 之后用户可在工具箱中编辑、优化此技能（如调整为 Windows cmd 兼容）
+ * 当种子版本号高于已安装版本时自动更新
  * @returns {boolean} 是否执行了种子写入
  */
 export function seedSkillCreator() {
   const skillDir = join(SKILLS_DIR, SKILL_CREATOR_DIR);
   const skillMdPath = join(skillDir, 'SKILL.md');
 
+  // 从种子内容中提取目标版本号
+  const seedVersionMatch = SKILL_CREATOR_SEED_MD.match(/^version:\s*([\d.]+)/m);
+  const seedVersion = seedVersionMatch ? seedVersionMatch[1] : '0.0.0';
+
   if (existsSync(skillMdPath)) {
     try {
       const content = readFileSync(skillMdPath, 'utf-8');
       const versionMatch = content.match(/^version:\s*([\d.]+)/m);
-      const currentVersion = versionMatch ? versionMatch[1] : '0.0.0';
-      if (currentVersion === '1.1.0') {
+      const installedVersion = versionMatch ? versionMatch[1] : '0.0.0';
+      if (installedVersion === seedVersion) {
         return false;
       }
     } catch { /* 读取失败则覆盖 */ }

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 });
+    // 解压到临时目录（跨平台：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 });
+    // 复制（跨平台：fs.cpSync 替代 cp -r，Windows 无 cp 命令；destDir 已被 rmSync 清空）
+    cpSync(skillDir, destDir, { recursive: true });
 
     // 重新加载
     const skill = loadMarkdownSkill(destDir);

package/src/skill/registry.js

@@ -194,7 +194,7 @@ export async function runSkill(name, params = {}, onStepUpdate) {
 /**
  * 获取所有启用的 Agent Skill 的轻量列表
  * 仅包含名称和描述，用于注入到 AI System Prompt 中。
- * AI 需要使用 agent_skill_load 工具按需加载完整内容。
+ * AI 需要使用 agent_skill 工具按需加载完整内容。
  * @returns {string} - 格式化的技能列表文本
  */
 export function getAgentSkillPrompts() {
@@ -210,7 +210,7 @@ export function getAgentSkillPrompts() {
   const parts = [];
   parts.push('## 可用技能 (Skills)');
   parts.push('');
-  parts.push('以下是可用的 Agent Skill（AI 能力扩展）列表。当用户需求与某个技能高度匹配时，使用 `agent_skill_load` 工具加载该技能的完整说明，然后根据说明自主完成任务。');
+  parts.push('以下是可用的 Agent Skill（AI 能力扩展）列表。当用户需求与某个技能高度匹配时，使用 `agent_skill` 工具（action: load）加载该技能的完整说明，然后根据说明自主完成任务。');
   parts.push('');
   parts.push('**使用策略**：');
   parts.push('- 仅在用户需求明确匹配技能描述时才加载，不要为一般性的编程/技术问题加载技能');

package/src/skill/skill-creator-seed.js

@@ -8,7 +8,7 @@ export const SKILL_CREATOR_SEED_MD = `---
 name: skill-creator
 description: "创建新技能的元技能。当用户要求创建技能、沉淀技能、新增技能、或任何创建/添加技能的意图时，必须立即调用此技能。"
 enabled: true
-version: 1.1.0
+version: 1.2.1
 ---
 
 # Skill Creator
@@ -99,18 +99,20 @@ enabled: true
    - 示例（正例和反例）
    - 注意事项（容易踩的坑）
 
+   > 💡 **多轮对话沉淀技巧**：当对话涉及多轮工具调用（ReAct 循环）时，先调用 \`exec_log\` 工具（scope: full_session）提取完整的执行日志。从**成功路径**中提炼经过验证的有效操作步骤，从**失败教训**中提炼注意事项和避坑指南，从**反思建议**中提炼优化方案。这能确保沉淀的技能内容覆盖完整的操作过程，而不仅仅是最终结果。
+
 4. **创建技能目录**：
-   - 使用 \`agent_exec_command\` 创建技能子目录。
+   - 使用 \`agent_exec\` 创建技能子目录。
    - **macOS/Linux**：\`mkdir -p ~/.ai-helper-agent/skills/<skill-name>\`
    - **Windows (cmd)**：\`mkdir %USERPROFILE%\\.ai-helper-agent\\skills\\<skill-name>\`
    - **Windows (PowerShell)**：\`New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\\.ai-helper-agent\\skills\\<skill-name>"\`
-   - 如果 \`mkdir\` 报错，尝试不带参数或使用 \`agent_write_file\` 工具在目标路径写入一个临时文件，让系统自动创建父目录。
+   - 如果 \`mkdir\` 报错，尝试不带参数或使用 \`agent_file\`（action: write）在目标路径写入一个临时文件，让系统自动创建父目录。
 
-5. **写入 SKILL.md**：使用 \`agent_write_file\` 工具将内容写入目标文件。
+5. **写入 SKILL.md**：使用 \`agent_file\`（action: write）工具将内容写入目标文件。
 
-   > ⚠️ **关键限制**：\`agent_write_file\` 不接受 \`~\` 或相对路径，**必须传入绝对路径**。
+   > ⚠️ **关键限制**：\`agent_file\` 不接受 \`~\` 或相对路径，**必须传入绝对路径**。
 
-   **推荐做法**：先用 \`agent_exec_command\` 获取用户主目录的绝对路径，再拼接完整路径。
+   **推荐做法**：先用 \`agent_exec\` 获取用户主目录的绝对路径，再拼接完整路径。
 
 6. **告知用户**：创建完成后，告知用户技能已就绪，说明触发关键词。建议用户在工具箱页面点击「重新加载」使技能生效。
 
@@ -119,10 +121,10 @@ enabled: true
 当用户要求更新/完善已有技能时：
 
 1. **确认技能名称**：与用户确认要更新的技能名称
-2. **读取现有内容**：使用 \`agent_read_file\` 读取目标 SKILL.md（路径规则同创建流程，需使用绝对路径，如 \`/Users/<你的用户名>/.ai-helper-agent/skills/<skill-name>/SKILL.md\`）
+2. **读取现有内容**：使用 \`agent_file\`（action: read）读取目标 SKILL.md（路径规则同创建流程，需使用绝对路径，如 \`/Users/<你的用户名>/.ai-helper-agent/skills/<skill-name>/SKILL.md\`）
 3. **分析更新需求**：结合当前对话上下文，识别需要更新的部分
 4. **合并内容**：保留原技能的核心结构，将新内容融入适当位置
-5. **覆盖写入**：使用 \`agent_write_file\` 覆盖写入 SKILL.md（路径规则同上，必须使用绝对路径）
+5. **覆盖写入**：使用 \`agent_file\`（action: write）覆盖写入 SKILL.md（路径规则同上，必须使用绝对路径）
 6. **告知用户**：告知更新内容，建议重新加载
 
 ## 更新注意事项