ai-helper-agent 1.3.4 → 1.5.0

package/src/mcp/registry.js

@@ -0,0 +1,165 @@
+// mcp/registry.js - MCP 工具注册表
+// 管理所有 MCP Client 实例，提供统一的工具发现和调用接口
+import { McpClient } from './client.js';
+import { loadMcpConfig, addMcpServer, removeMcpServer, toggleMcpServer } from './mcp-config.js';
+
+// 已连接的 MCP Client 映射表: serverId → McpClient
+const clients = new Map();
+
+/**
+ * 启动时加载并连接所有启用的 MCP Server
+ * @returns {Promise<{connected: number, failed: number}>}
+ */
+export async function initializeMcpRegistry() {
+  const config = loadMcpConfig();
+  let connected = 0;
+  let failed = 0;
+
+  console.log(`[MCP Registry] 初始化，共配置 ${config.servers.length} 个 MCP Server`);
+
+  for (const server of config.servers) {
+    if (!server.enabled) {
+      console.log(`[MCP Registry] 跳过禁用的 Server: ${server.id}`);
+      continue;
+    }
+
+    const client = new McpClient(server);
+    const result = await client.connect();
+    if (result.success) {
+      clients.set(server.id, client);
+      connected++;
+    } else {
+      console.error(`[MCP Registry] 连接失败 "${server.id}":`, result.error);
+      failed++;
+    }
+  }
+
+  console.log(`[MCP Registry] 初始化完成: ${connected} 已连接, ${failed} 失败`);
+  return { connected, failed };
+}
+
+/**
+ * 获取所有 MCP Server 及其状态
+ */
+export function getMcpServersStatus() {
+  const config = loadMcpConfig();
+  const statuses = config.servers.map(server => {
+    const client = clients.get(server.id);
+    if (client && client.connected) {
+      return {
+        ...server,
+        connected: true,
+        toolCount: client.tools.length,
+        tools: client.tools,
+        serverInfo: client.serverInfo?.serverInfo || null
+      };
+    }
+    return {
+      ...server,
+      connected: false,
+      toolCount: 0,
+      tools: [],
+      serverInfo: null
+    };
+  });
+
+  return { success: true, servers: statuses };
+}
+
+/**
+ * 获取所有已连接 MCP Server 的工具列表（扁平化）
+ * @param {string} [serverId] - 可选，只获取指定 Server 的工具
+ */
+export function getMcpTools(serverId) {
+  const tools = [];
+
+  for (const [id, client] of clients) {
+    if (serverId && id !== serverId) continue;
+    if (!client.connected) continue;
+
+    for (const tool of client.tools) {
+      tools.push({
+        serverId: id,
+        serverName: client.serverName,
+        name: tool.name,
+        description: tool.description || '',
+        inputSchema: tool.inputSchema || { type: 'object', properties: {} }
+      });
+    }
+  }
+
+  return { success: true, tools };
+}
+
+/**
+ * 调用指定 MCP Server 的工具
+ * @param {string} serverId
+ * @param {string} toolName
+ * @param {Object} args
+ */
+export async function callMcpTool(serverId, toolName, args) {
+  const client = clients.get(serverId);
+  if (!client) {
+    return { success: false, error: `MCP Server "${serverId}" 不存在` };
+  }
+  if (!client.connected) {
+    return { success: false, error: `MCP Server "${serverId}" 未连接` };
+  }
+
+  console.log(`[MCP Registry] 调用工具: ${serverId}/${toolName}`, args);
+  const result = await client.callTool(toolName, args);
+  return result;
+}
+
+/**
+ * 连接指定 MCP Server
+ */
+export async function connectMcpServer(serverId) {
+  const config = loadMcpConfig();
+  const server = config.servers.find(s => s.id === serverId);
+  if (!server) {
+    return { success: false, error: `MCP Server "${serverId}" 不存在` };
+  }
+
+  // 先断开已有连接
+  const existingClient = clients.get(serverId);
+  if (existingClient) {
+    existingClient.disconnect();
+    clients.delete(serverId);
+  }
+
+  const client = new McpClient(server);
+  const result = await client.connect();
+  if (result.success) {
+    clients.set(serverId, client);
+    return { success: true, toolCount: result.toolCount };
+  }
+  return result;
+}
+
+/**
+ * 断开指定 MCP Server
+ */
+export function disconnectMcpServer(serverId) {
+  const client = clients.get(serverId);
+  if (client) {
+    client.disconnect();
+    clients.delete(serverId);
+    return { success: true };
+  }
+  return { success: false, error: `MCP Server "${serverId}" 未连接` };
+}
+
+/**
+ * 关闭所有 MCP 连接（Agent 关闭时调用）
+ */
+export function shutdownMcpRegistry() {
+  console.log('[MCP Registry] 关闭所有 MCP 连接...');
+  for (const [id, client] of clients) {
+    try { client.disconnect(); } catch {}
+  }
+  clients.clear();
+}
+
+// 重新导出配置管理函数，方便 server.js 使用
+export { loadMcpConfig, addMcpServer, removeMcpServer, toggleMcpServer };

package/src/mcp/transport.js

@@ -0,0 +1,100 @@
+// mcp/transport.js - MCP stdio 传输层
+// MCP 协议使用 JSON-RPC 2.0 over stdin/stdout，每行一个 JSON 消息
+import { spawn } from 'child_process';
+
+/**
+ * 创建 MCP 子进程传输
+ * MCP 协议中，客户端先发 initialize 请求，服务端才会响应。因此 spawn 后立即 resolve，
+ * 由上层 McpClient 负责发送 initialize 和等待响应。
+ *
+ * @param {Object} serverConfig - { command, args, env }
+ * @returns {Promise<{send: Function, close: Function, onData: Function}>}
+ */
+export function createStdioTransport(serverConfig) {
+  const { command, args = [], env = {} } = serverConfig;
+
+  return new Promise((resolve, reject) => {
+    let resolved = false;
+    let responseBuffer = '';
+    let dataHandler = null;
+    let exitHandler = null;
+
+    const child = spawn(command, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, ...env },
+      detached: false
+    });
+
+    const cleanup = () => {
+      if (child.stdout) child.stdout.removeAllListeners();
+      if (child.stderr) child.stderr.removeAllListeners();
+      child.removeAllListeners();
+    };
+
+    child.stderr.on('data', (data) => {
+      const text = data.toString();
+      if (text.trim()) {
+        console.log(`[MCP:stderr] [${serverConfig.id || command}] ${text.trim()}`);
+      }
+    });
+
+    child.on('error', (err) => {
+      if (!resolved) {
+        resolved = true;
+        cleanup();
+        reject(new Error(`无法启动 MCP Server "${command}": ${err.message}`));
+      }
+    });
+
+    child.on('exit', (code, signal) => {
+      console.log(`[MCP] Server 进程退出: ${command} (code=${code}, signal=${signal})`);
+      if (!resolved) {
+        resolved = true;
+        cleanup();
+        reject(new Error(`MCP Server 异常退出 (code=${code}, signal=${signal}): ${command}`));
+      } else if (exitHandler) {
+        exitHandler(code, signal);
+      }
+    });
+
+    child.stdout.on('data', (data) => {
+      responseBuffer += data.toString();
+
+      let newlineIdx;
+      while ((newlineIdx = responseBuffer.indexOf('\n')) !== -1) {
+        const line = responseBuffer.slice(0, newlineIdx).trim();
+        responseBuffer = responseBuffer.slice(newlineIdx + 1);
+
+        if (!line) continue;
+
+        if (dataHandler) {
+          try { dataHandler(line); } catch {}
+        }
+      }
+    });
+
+    if (!resolved) {
+      resolved = true;
+      resolve({
+        send: (jsonRpcMessage) => {
+          const msg = JSON.stringify(jsonRpcMessage) + '\n';
+          child.stdin.write(msg);
+        },
+        close: () => {
+          cleanup();
+          dataHandler = null;
+          try { child.stdin.end(); } catch {}
+          setTimeout(() => {
+            try { child.kill('SIGTERM'); } catch {}
+          }, 1000);
+        },
+        onData: (handler) => {
+          dataHandler = handler;
+        },
+        onExit: (handler) => {
+          exitHandler = handler;
+        }
+      });
+    }
+  });
+}

package/src/security.js

@@ -1,8 +1,41 @@
 // agent/src/security.js - 安全管控：文件沙箱 + 命令分级
-import { resolve, normalize, sep, isAbsolute } from 'path';
+import { resolve, normalize, sep, isAbsolute, join } from 'path';
 import { realpathSync } from 'fs';
+import { homedir } from 'os';
 import { loadConfig } from './config.js';
 
+// ==================== 硬阻止目录（任何情况下都不可访问） ====================
+
+const AGENT_DIR = join(homedir(), '.ai-helper-agent');
+
+/** 核心敏感文件/目录（硬阻止，不可绕过）。其他子目录（如 workspace）由白名单控制。 */
+const HARD_BLOCKED_PATHS = [
+  join(AGENT_DIR, 'config.json'),     // 代理配置文件
+  join(AGENT_DIR, 'pairings.json'),   // 配对记录
+  join(AGENT_DIR, 'mcp_servers.json'),// MCP 服务器配置
+  join(AGENT_DIR, 'logs') + sep,      // 日志目录
+];
+
+/**
+ * 检查路径是否命中核心敏感文件
+ */
+function isHardBlocked(normalizedPath) {
+  for (const blocked of HARD_BLOCKED_PATHS) {
+    if (blocked.endsWith(sep)) {
+      // 目录：检查是否在该目录下
+      if (normalizedPath.startsWith(blocked) || normalizedPath === blocked.slice(0, -1)) {
+        return true;
+      }
+    } else {
+      // 文件：精确匹配
+      if (normalizedPath === blocked) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 /**
  * 检查路径是否在白名单内
  * 使用 realpathSync 防止符号链接绕过
@@ -20,6 +53,11 @@ function checkPath(pathStr) {
     const resolved = isAbsolute(pathStr) ? resolve(pathStr) : resolve(config.workdir, pathStr);
     const normalized = normalize(resolved);
 
+    // 0. 硬阻止检查（优先级最高，不可绕过）
+    if (isHardBlocked(normalized)) {
+      return { allowed: false, reason: '禁止访问代理系统文件' };
+    }
+
     const allowedPaths = config.allowedPaths.length > 0 ? config.allowedPaths : [config.workdir];
 
     // 先做前缀检查（快速路径，兼容 Windows/Unix）
@@ -43,14 +81,34 @@ function checkPath(pathStr) {
       realPath = realpathSync(resolved);
     } catch (err) {
       if (err.code === 'ENOENT') {
-        // 文件不存在时，检查父目录
-        const parentDir = resolve(resolved, '..');
-        realPath = realpathSync(parentDir) + sep + normalized.split(sep).pop();
+        // 文件/目录不存在时，向上查找直到找到存在的父目录
+        let existing = resolved;
+        while (existing !== sep && existing !== '' && existing !== '/') {
+          const parent = resolve(existing, '..');
+          try {
+            realPath = realpathSync(parent) + sep + normalized.slice(resolve(parent).length).replace(/^[/\\]/, '');
+            break;
+          } catch (parentErr) {
+            if (parentErr.code === 'ENOENT') {
+              existing = parent;
+              continue;
+            }
+            return { allowed: false, reason: `无法解析路径: ${parentErr.message}` };
+          }
+        }
+        if (!realPath) {
+          return { allowed: false, reason: `路径检查异常: ${err.message}` };
+        }
       } else {
         return { allowed: false, reason: `无法解析路径: ${err.message}` };
       }
     }
 
+    // 对 realPath 做硬阻止检查（防止通过符号链接绕过）
+    if (isHardBlocked(realPath)) {
+      return { allowed: false, reason: '禁止访问代理系统文件' };
+    }
+
     // 对 realPath 再次做前缀检查
     for (const allowed of allowedPaths) {
       const allowedResolved = resolve(allowed);
@@ -98,7 +156,6 @@ const BLACKLIST_PATTERNS = [
   /^\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*\([^)]*\)/,
 ];
-
 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)';
 
@@ -144,6 +201,17 @@ function checkCommand(command, force = false) {
     }
   }
 
+  // 1.5 禁止访问核心敏感文件（通过命令也一样拦截）
+  for (const blocked of HARD_BLOCKED_PATHS) {
+    if (trimmed.includes(blocked)) {
+      return {
+        safe: false,
+        level: 'deny',
+        reason: '禁止访问代理系统文件'
+      };
+    }
+  }
+
   // 2. 强制模式：跳过灰名单检查
   if (force) {
     return { safe: true, level: 'allow' };