ai-helper-agent 1.0.0 → 1.2.0

package/src/search.js

@@ -0,0 +1,375 @@
+// agent/src/search.js - 文件搜索（fd/rg 优先 + Node.js 回退）
+import { spawn } from 'child_process';
+import { readdirSync, statSync, readFileSync, existsSync } from 'fs';
+import { join, basename, extname, resolve } from 'path';
+import { checkPath } from './security.js';
+
+// 缓存检测结果，避免每次启动重复检测
+let fdAvailable = null;
+let rgAvailable = null;
+
+/**
+ * 检测系统是否安装了 fd（快速文件搜索，带 5s 超时）
+ */
+function checkFdAvailable() {
+  return new Promise((resolve) => {
+    const proc = spawn('fd', ['--version'], { stdio: 'ignore' });
+    const timeout = setTimeout(() => { proc.kill(); resolve(false); }, 5000);
+    proc.on('close', (code) => { clearTimeout(timeout); resolve(code === 0); });
+    proc.on('error', () => { clearTimeout(timeout); resolve(false); });
+  });
+}
+
+/**
+ * 检测系统是否安装了 rg（ripgrep 快速内容搜索，带 5s 超时）
+ */
+function checkRgAvailable() {
+  return new Promise((resolve) => {
+    const proc = spawn('rg', ['--version'], { stdio: 'ignore' });
+    const timeout = setTimeout(() => { proc.kill(); resolve(false); }, 5000);
+    proc.on('close', (code) => { clearTimeout(timeout); resolve(code === 0); });
+    proc.on('error', () => { clearTimeout(timeout); resolve(false); });
+  });
+}
+
+/**
+ * 初始化检测 fd/rg 可用性（仅允许单次初始化）
+ */
+let searchToolsInitPromise = null;
+
+export async function initSearchTools() {
+  if (searchToolsInitPromise) return searchToolsInitPromise;
+  searchToolsInitPromise = (async () => {
+    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;
+}
+
+/**
+ * 获取搜索工具可用性
+ */
+export function getSearchToolsAvailable() {
+  return { fd: fdAvailable, rg: rgAvailable };
+}
+
+// 默认忽略的目录（模拟 .gitignore 行为）
+const DEFAULT_IGNORE_DIRS = new Set([
+  'node_modules', '.git', '.svn', '.hg',
+  '__pycache__', '.cache', 'dist', 'build',
+  '.next', '.nuxt', 'target', 'vendor',
+  '.idea', '.vscode', '.DS_Store'
+]);
+
+/**
+ * 文件名模式匹配（支持 glob：*.js, test*.ts, ** / *.js 等）
+ */
+function matchGlob(filename, pattern) {
+  // 转换 glob 为简单正则
+  const regexStr = pattern
+    .replace(/\./g, '\\.')
+    .replace(/\*\*/g, '<<<ANY>>>')  // 先保护 **
+    .replace(/\*/g, '[^/]*')
+    .replace(/<<<ANY>>>/g, '.*')
+    .replace(/\?/g, '.');
+  const regex = new RegExp('^' + regexStr + '$', 'i');
+  return regex.test(filename);
+}
+
+/**
+ * 使用 fd 搜索文件（快速）
+ */
+function searchWithFd(rootPath, filePattern, recursive, maxResults) {
+  return new Promise((resolve) => {
+    const args = ['--glob', filePattern, '--type', 'f', '--max-results', String(maxResults)];
+    if (!recursive) args.push('--max-depth', '1');
+    args.push(rootPath);
+
+    const proc = spawn('fd', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    const stdout = [];
+    const stderr = [];
+    let timedOut = false;
+
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      proc.kill();
+      resolve([]);
+    }, 30000);
+
+    proc.stdout.on('data', (chunk) => stdout.push(chunk));
+    proc.stderr.on('data', (chunk) => stderr.push(chunk));
+
+    proc.on('close', (code) => {
+      clearTimeout(timeout);
+      if (timedOut) return;
+      const output = Buffer.concat(stdout).toString('utf-8').trim();
+      const lines = output ? output.split('\n').filter(Boolean) : [];
+      const results = lines.map(p => {
+        try {
+          const s = statSync(p);
+          return { path: p, name: basename(p), size: s.size, mtime: s.mtimeMs };
+        } catch {
+          return { path: p, name: basename(p), size: 0, mtime: 0 };
+        }
+      });
+      resolve(results);
+    });
+
+    proc.on('error', () => { clearTimeout(timeout); resolve([]); });
+  });
+}
+
+/**
+ * Node.js 原生递归搜索文件（回退方案）
+ */
+function searchFilesNative(rootPath, filePattern, recursive, maxResults) {
+  const results = [];
+
+  function walk(dir, depth) {
+    if (results.length >= maxResults) return;
+    if (!recursive && depth > 1) return;
+
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); }
+    catch { return; }
+
+    for (const entry of entries) {
+      if (results.length >= maxResults) return;
+      const fullPath = join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        if (DEFAULT_IGNORE_DIRS.has(entry.name)) continue;
+        if (entry.name.startsWith('.')) continue;
+        walk(fullPath, depth + 1);
+      } else if (entry.isFile()) {
+        if (matchGlob(entry.name, filePattern)) {
+          try {
+            const s = statSync(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 });
+          }
+        }
+      }
+    }
+  }
+
+  walk(rootPath, 0);
+  return results;
+}
+
+/**
+ * 搜索文件（按文件名模式）
+ * @param {string} rootPath - 搜索根目录
+ * @param {string} filePattern - 文件名模式（glob），如 "*.js"
+ * @param {boolean} recursive - 是否递归
+ * @param {number} maxResults - 最大结果数
+ * @returns {Array<{path, name, size, mtime}>}
+ */
+export async function searchFiles(rootPath, filePattern = '*', recursive = true, maxResults = 200) {
+  const pathCheck = checkPath(rootPath);
+  if (!pathCheck.allowed) {
+    return { success: false, error: pathCheck.reason };
+  }
+
+  const resolved = pathCheck.resolved;
+  if (!existsSync(resolved)) {
+    return { success: false, error: '搜索路径不存在' };
+  }
+
+  const s = statSync(resolved);
+  if (!s.isDirectory()) {
+    return { success: false, error: '搜索路径不是目录' };
+  }
+
+  let results;
+  if (fdAvailable) {
+    results = await searchWithFd(resolved, filePattern, recursive, maxResults);
+  } else {
+    results = searchFilesNative(resolved, filePattern, recursive, maxResults);
+  }
+
+  return {
+    success: true,
+    results,
+    total: results.length,
+    engine: fdAvailable ? 'fd' : 'nodejs',
+    path: resolved,
+    pattern: filePattern
+  };
+}
+
+/**
+ * 使用 rg 搜索文件内容（快速）
+ */
+function searchContentWithRg(rootPath, pattern, filePattern, maxResults, contextLines) {
+  return new Promise((resolve) => {
+    const args = [
+      '--no-heading', '--line-number',
+      '--max-count', String(maxResults),
+      '-C', String(contextLines)
+    ];
+    if (filePattern) {
+      args.push('--glob', filePattern);
+    }
+    args.push(pattern, rootPath);
+
+    const proc = spawn('rg', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    const stdout = [];
+    let timedOut = false;
+
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      proc.kill();
+      resolve([]);
+    }, 30000);
+
+    proc.stdout.on('data', (chunk) => stdout.push(chunk));
+
+    proc.on('close', (code) => {
+      clearTimeout(timeout);
+      if (timedOut) return;
+      if (code !== 0 && code !== 1) { resolve([]); return; } // 1 = no matches
+      const output = Buffer.concat(stdout).toString('utf-8').trim();
+      resolve(parseRgOutput(output, contextLines));
+    });
+
+    proc.on('error', () => { clearTimeout(timeout); resolve([]); });
+  });
+}
+
+/**
+ * 解析 rg 输出格式：file:line:content
+ * 上下文行格式：file-line:content
+ * 注：Windows 路径含 `:` 可能导致解析偏差，建议在 WSL/Mac/Linux 中使用
+ */
+function parseRgOutput(output, contextLines) {
+  if (!output) return [];
+  const lines = output.split('\n');
+  const results = [];
+
+  for (const line of lines) {
+    // 匹配行分隔符（rg 用 -- 分隔不同文件的匹配）
+    if (line === '--') continue;
+
+    // 匹配文件名:行号:内容（非贪婪匹配文件名）
+    const match = line.match(/^(.+?):(\d+):(.*)$/);
+    if (match) {
+      results.push({
+        file: match[1],
+        line: parseInt(match[2], 10),
+        content: match[3]
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Node.js 原生搜索文件内容（回退方案）
+ */
+function searchContentNative(rootPath, pattern, filePattern, caseSensitive, maxResults, contextLines) {
+  const results = [];
+  const searchPattern = caseSensitive ? pattern : pattern.toLowerCase();
+
+  function walk(dir) {
+    if (results.length >= maxResults) return;
+
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); }
+    catch { return; }
+
+    for (const entry of entries) {
+      if (results.length >= maxResults) return;
+      const fullPath = join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        if (DEFAULT_IGNORE_DIRS.has(entry.name)) continue;
+        if (entry.name.startsWith('.')) continue;
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        if (filePattern && !matchGlob(entry.name, filePattern)) continue;
+        // 跳过压缩和映射文件
+        if (entry.name.endsWith('.min.js')) continue;
+        if (entry.name.endsWith('.map')) continue;
+
+        try {
+          const s = statSync(fullPath);
+          if (s.size > 1024 * 1024) continue; // 跳过 1MB 以上的文件
+
+          const content = readFileSync(fullPath, 'utf-8');
+          const fileLines = content.split('\n');
+
+          for (let i = 0; i < fileLines.length; i++) {
+            if (results.length >= maxResults) break;
+            const line = caseSensitive ? fileLines[i] : fileLines[i].toLowerCase();
+            if (line.includes(searchPattern)) {
+              const ctx = [];
+              const start = Math.max(0, i - contextLines);
+              const end = Math.min(fileLines.length - 1, i + contextLines);
+              for (let j = start; j <= end; j++) {
+                ctx.push({ line: j + 1, content: fileLines[j], isMatch: j === i });
+              }
+              results.push({
+                file: fullPath,
+                line: i + 1,
+                content: fileLines[i],
+                context: ctx
+              });
+            }
+          }
+        } catch {}
+      }
+    }
+  }
+
+  walk(rootPath);
+  return results;
+}
+
+/**
+ * 搜索文件内容
+ * @param {string} rootPath - 搜索根目录
+ * @param {string} pattern - 搜索文本
+ * @param {string} [filePattern] - 可选文件类型过滤，如 "*.js"
+ * @param {boolean} caseSensitive - 是否大小写敏感
+ * @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) {
+  const pathCheck = checkPath(rootPath);
+  if (!pathCheck.allowed) {
+    return { success: false, error: pathCheck.reason };
+  }
+
+  const resolved = pathCheck.resolved;
+  if (!existsSync(resolved)) {
+    return { success: false, error: '搜索路径不存在' };
+  }
+
+  if (!pattern || !pattern.trim()) {
+    return { success: false, error: '搜索内容不能为空' };
+  }
+
+  let results;
+  if (rgAvailable) {
+    results = await searchContentWithRg(resolved, pattern, filePattern, maxResults, contextLines);
+  } else {
+    results = searchContentNative(resolved, pattern, filePattern, caseSensitive, maxResults, contextLines);
+  }
+
+  return {
+    success: true,
+    results,
+    total: results.length,
+    engine: rgAvailable ? 'rg' : 'nodejs',
+    path: resolved,
+    pattern
+  };
+}

package/src/security.js

@@ -1,5 +1,5 @@
 // agent/src/security.js - 安全管控：文件沙箱 + 命令分级
-import { resolve, normalize } from 'path';
+import { resolve, normalize, sep } from 'path';
 import { realpathSync } from 'fs';
 import { loadConfig } from './config.js';
 
@@ -20,23 +20,22 @@ function checkPath(pathStr) {
     const config = loadConfig();
     const allowedPaths = config.allowedPaths.length > 0 ? config.allowedPaths : [config.workdir];
 
-    // 先做前缀检查（快速路径）
+    // 先做前缀检查（快速路径，兼容 Windows/Unix）
     let prefixMatch = false;
-    let matchedAllowed = null;
     for (const allowed of allowedPaths) {
       const allowedResolved = resolve(allowed);
-      if (normalized.startsWith(allowedResolved + '/') || normalized === allowedResolved) {
+      // 统一使用 OS 分隔符构造前缀
+      const prefix = allowedResolved.endsWith(sep) ? allowedResolved : allowedResolved + sep;
+      if (normalized.startsWith(prefix) || normalized === allowedResolved) {
         prefixMatch = true;
-        matchedAllowed = allowedResolved;
         break;
       }
     }
     if (!prefixMatch) {
-      return { allowed: false, reason: `路径不在允许的目录范围内` };
+      return { allowed: false, reason: '路径不在允许的目录范围内' };
     }
 
     // realpath 校验：防止符号链接绕过
-    // 注意：文件可能尚未创建，realpathSync 会抛出 ENOENT
     let realPath;
     try {
       realPath = realpathSync(resolved);
@@ -44,7 +43,7 @@ function checkPath(pathStr) {
       if (err.code === 'ENOENT') {
         // 文件不存在时，检查父目录
         const parentDir = resolve(resolved, '..');
-        realPath = realpathSync(parentDir) + '/' + normalized.split('/').pop();
+        realPath = realpathSync(parentDir) + sep + normalized.split(sep).pop();
       } else {
         return { allowed: false, reason: `无法解析路径: ${err.message}` };
       }
@@ -53,12 +52,13 @@ function checkPath(pathStr) {
     // 对 realPath 再次做前缀检查
     for (const allowed of allowedPaths) {
       const allowedResolved = resolve(allowed);
-      if (realPath.startsWith(allowedResolved + '/') || realPath === allowedResolved) {
+      const prefix = allowedResolved.endsWith(sep) ? allowedResolved : allowedResolved + sep;
+      if (realPath.startsWith(prefix) || realPath === allowedResolved) {
         return { allowed: true, resolved: normalized };
       }
     }
 
-    return { allowed: false, reason: `路径指向了允许范围之外的位置` };
+    return { allowed: false, reason: '路径指向了允许范围之外的位置' };
   } catch (err) {
     return { allowed: false, reason: `路径检查异常: ${err.message}` };
   }
@@ -84,19 +84,22 @@ const BLACKLIST_PATTERNS = [
   /^\s*>\s*\/etc\/sudoers/,
   // fork bomb
   /:\(\)\s*{\s*:\s*\|\s*:\s*&\s*};\s*:/,
-  /#!/,
+  // shebang 直接执行（出现在命令开头）
+  /^\s*#!/,
   // 恶意管道执行
   /(curl|wget|lynx|links)\s+.*\|\s*(ba)?sh/,
   /git\s+clone\s+.*\|\s*(ba)?sh/,
   // 修改根目录权限
   /^\s*chmod\s+(-R\s+)?(0?777|a\+rwx)\s+\//,
   /^\s*chown\s+-R\s+\S+\s+\//,
-  // Shell 命令替换注入
-  /`[^`]*`/,                   // 反引号命令替换
-  /\$\([^)]*\)/,               // $() 命令替换
-  /\$\{[^}]*\}/,               // ${} 变量替换（可能含命令）
+  // Shell 命令替换注入（仅匹配反引号内的可执行命令模式）
+  /`[^`]*`/,
+  /\$\([^)]*\)/,
 ];
 
+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)';
+
 const GRAYLIST_PATTERNS = [
   { pattern: /^\s*sudo\s/, reason: '命令需要管理员权限 (sudo)' },
   { pattern: /npm\s+(i|install)\s+-g\s/, reason: '全局安装 npm 包' },
@@ -107,11 +110,18 @@ const GRAYLIST_PATTERNS = [
   { pattern: /^\s*(shutdown|reboot|halt|poweroff)/, reason: '关机或重启系统' },
   { pattern: /^\s*>\s*\/etc\/hosts/, reason: '修改系统 hosts 文件' },
   { pattern: /\beval\s+/, reason: '使用 eval 执行命令' },
+
+  // 脚本解释器执行外部文件
+  { pattern: new RegExp(`^\\s*${SCRIPT_INTERPRETERS}(\\s+[^-]\\S*)*\\s+\\S*\\.${SCRIPT_EXTENSIONS}\\b`), reason: '执行外部脚本文件' },
+  // 直接执行脚本
+  { 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: '修改文件执行权限' },
 ];
 
 /**
  * 检查命令安全性
- * @param {boolean} [force=false] - 强制放行（用户确认后的调用）
+ * @param {boolean} [force=false] - 用户已确认（跳过灰名单但保留黑名单）
  * @returns {{ safe: boolean, level: 'allow'|'confirm'|'deny', reason?: string }}
  */
 function checkCommand(command, force = false) {
@@ -121,12 +131,7 @@ function checkCommand(command, force = false) {
 
   const trimmed = command.trim();
 
-  // 强制模式：跳过所有检查
-  if (force) {
-    return { safe: true, level: 'allow' };
-  }
-
-  // 1. 先检查黑名单
+  // 1. 黑名单始终生效（即使是 force 模式也不可绕过）
   for (const pattern of BLACKLIST_PATTERNS) {
     if (pattern.test(trimmed)) {
       return {
@@ -137,7 +142,12 @@ function checkCommand(command, force = false) {
     }
   }
 
-  // 2. 检查灰名单
+  // 2. 强制模式：跳过灰名单检查
+  if (force) {
+    return { safe: true, level: 'allow' };
+  }
+
+  // 3. 检查灰名单
   for (const entry of GRAYLIST_PATTERNS) {
     if (entry.pattern.test(trimmed)) {
       return {
@@ -148,7 +158,7 @@ function checkCommand(command, force = false) {
     }
   }
 
-  // 3. 通过安全检查
+  // 4. 通过安全检查
   return { safe: true, level: 'allow' };
 }