ai-helper-agent 1.13.0 → 1.14.1

package/package.json

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

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

@@ -6,14 +6,33 @@ import { loadConfig, MEMORY_DIR } from './config.js';
 
 const isWin32 = platform() === 'win32';
 
-function normalizePathFormat(pathStr) {
+/**
+ * 路径格式规整（跨平台）
+ * @param {string} pathStr - 待规整的路径
+ * @param {string} [platformOverride] - 平台覆盖（'win32' | 'darwin' | 'linux'），用于单元测试 mock；
+ *   不传则使用当前运行平台 os.platform()
+ * @returns {string} 规整后的路径
+ */
+function normalizePathFormat(pathStr, platformOverride) {
   if (!pathStr || typeof pathStr !== 'string') return pathStr;
-  // 防御性修复：把异常的 "/C:/" 形式（带前导斜杠的盘符）规整为 "C:/"
-  // 仅匹配 /<字母>:/ ，不会误伤 /home/ 等普通路径段
+  const isWin = platformOverride !== undefined ? platformOverride === 'win32' : isWin32;
+  // 1. 把异常的 "/C:/" 形式（带前导斜杠的盘符）规整为 "C:/"
+  //    仅匹配 /<字母>:/ ，不会误伤 /home/ 等普通路径段
   pathStr = pathStr.replace(/\/([a-zA-Z]):(\/|$)/g, '$1:$2');
-  // 统一为正斜杠（path.resolve/normalize 在所有平台都能正确处理正斜杠并归一化到平台分隔符）
-  // 不再做盘符相关的激进转换，避免把 /home/user 误转为 home:\user
-  return pathStr.replace(/\\/g, '/');
+  // 2. MSYS/Git Bash 风格路径：/d/Users/... → D:/Users/...
+  //    前导 / + 单字母盘符 + / ，无冒号，是 MSYS 特有的挂载点表示法
+  if (isWin) {
+    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 (isWin) {
+    pathStr = pathStr.replace(/^([a-zA-Z]):/, m => m.toUpperCase());
+  }
+  return pathStr;
 }
 
 // ==================== 硬阻止目录（任何情况下都不可访问） ====================
@@ -33,17 +52,22 @@ const HARD_BLOCKED_PATHS = [
 
 /**
  * 检查路径是否命中核心敏感文件
+ * 注意：Windows 文件系统不区分大小写，必须做大小写不敏感比较，
+ *       否则 .AI-HELPER-AGENT/config.JSON 等大小写变换可绕过硬阻止
  */
-function isHardBlocked(normalizedPath) {
+function isHardBlocked(normalizedPath, platformOverride) {
+  const isWin = platformOverride !== undefined ? platformOverride === 'win32' : isWin32;
+  const cmpPath = isWin ? normalizedPath.toLowerCase() : normalizedPath;
   for (const blocked of HARD_BLOCKED_PATHS) {
+    const cmpBlocked = isWin ? blocked.toLowerCase() : blocked;
     if (blocked.endsWith(sep)) {
       // 目录：检查是否在该目录下
-      if (normalizedPath.startsWith(blocked) || normalizedPath === blocked.slice(0, -1)) {
+      if (cmpPath.startsWith(cmpBlocked) || cmpPath === cmpBlocked.slice(0, -1)) {
         return true;
       }
     } else {
       // 文件：精确匹配
-      if (normalizedPath === blocked) {
+      if (cmpPath === cmpBlocked) {
         return true;
       }
     }
@@ -303,4 +327,4 @@ function checkCommand(command, force = false) {
   return { safe: true, level: 'allow' };
 }
 
-export { checkPath, checkCommand };
+export { checkPath, checkCommand, normalizePathFormat, isHardBlocked };

package/src/server.js

@@ -12,7 +12,7 @@ import { randomBytes } from 'crypto';
 import os from 'os';
 import { loadConfig, saveConfig } from './config.js';
 import { verifyToken, startPairCodeRotation, stopPairCodeRotation, handlePairRequest } from './auth.js';
-import { checkPath, checkCommand } from './security.js';
+import { checkPath, checkCommand, normalizePathFormat } from './security.js';
 import { moveToTrash, restoreFromTrash, listTrash, startPeriodicCleanup, stopPeriodicCleanup } from './trash.js';
 import { executeCommand, executeCommandSync, addWsClient, disconnectWsClient, killProcess, getRunningProcesses } from './executor.js';
 import { setConsoleOutput, logAuth, logFs, logExec, logSecurity, logSystem, logError, queryLogs, getLogDates } from './logger.js';
@@ -801,6 +801,9 @@ export function startServer() {
         } else if (resolvedWorkdir.startsWith('~/')) {
           resolvedWorkdir = join(homedir(), resolvedWorkdir.slice(2));
         }
+        // 规整路径格式（MSYS /d/Users/... → D:/Users/...、盘符大写统一），
+        // 必须在 isAbsolute/resolve 之前，否则 Windows 上 /d/Users 会被当作 Unix 绝对路径错误解析
+        resolvedWorkdir = normalizePathFormat(resolvedWorkdir);
 
         // 必须是绝对路径（跨平台：path.isAbsolute 覆盖 Unix /、Windows 盘符、UNC 路径）
         if (!isAbsolute(resolvedWorkdir)) {
@@ -844,6 +847,59 @@ export function startServer() {
         }
       }
 
+      // === 移除允许访问的目录（需认证，不可移除当前工作目录） ===
+      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));
+        }
+        // 规整 MSYS 路径格式，与 workdir 切换端点保持一致
+        resolvedPath = normalizePathFormat(resolvedPath);
+        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}` });
+        }
+      }
+
       // === 文件操作 ===
 
       // 搜索文件（按文件名模式）
@@ -877,6 +933,7 @@ export function startServer() {
             body.pattern,
             body.filePattern || null,
             body.caseSensitive || false,
+            body.recursive !== false,
             maxResults,
             body.contextLines !== undefined ? body.contextLines : 2
           );
@@ -1333,6 +1390,10 @@ export function startServer() {
         if (newName.includes('/') || newName.includes('\\')) {
           return jsonResponse(res, 400, { success: false, error: '新名称不能包含路径分隔符' });
         }
+        // Windows 文件名非法字符（仅 Windows 拦截；Unix 允许这些字符）
+        if (os.platform() === 'win32' && /[:*?"<>|]/.test(newName)) {
+          return jsonResponse(res, 400, { success: false, error: '新名称包含 Windows 非法字符 (: * ? " < > |)' });
+        }
         const check = await checkPath(oldPath);
         if (!check.allowed) {
           logSecurity('fs_rename_blocked', { path: oldPath, reason: check.reason });
@@ -1348,6 +1409,12 @@ export function startServer() {
           logSecurity('fs_rename_blocked', { path: newFullPath, reason: newCheck.reason });
           return jsonResponse(res, 403, { success: false, error: `目标路径不允许: ${newCheck.reason}` });
         }
+        // 防止覆盖：目标已存在时统一返回 409。
+        // macOS/Linux 的 fs.rename 会静默覆盖目标文件（仅 Windows 报 EEXIST），
+        // 主动检查避免跨平台数据丢失风险
+        if (await exists(newFullPath)) {
+          return jsonResponse(res, 409, { success: false, error: '目标名称已存在' });
+        }
         try {
           await rename(check.resolved, newFullPath);
           logFs('rename', { from: check.resolved, to: newFullPath });
@@ -1391,6 +1458,10 @@ export function startServer() {
           logSecurity('fs_move_blocked', { path: destPath, reason: destCheck2.reason });
           return jsonResponse(res, 403, { success: false, error: `移动目标路径不允许: ${destCheck2.reason}` });
         }
+        // 防止覆盖：目标已存在时统一返回 409（与 rename 端点一致，避免 macOS/Linux 静默覆盖）
+        if (await exists(destPath)) {
+          return jsonResponse(res, 409, { success: false, error: '目标位置已存在同名文件/目录' });
+        }
         try {
           await rename(srcCheck.resolved, destPath);
           logFs('move', { from: srcCheck.resolved, to: destPath });

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
           );