coding-tool-x 3.2.0

package/src/server/services/mcp-service.js

@@ -0,0 +1,1732 @@
+/**
+ * MCP 服务器管理服务
+ *
+ * 负责 MCP 服务器的 CRUD 操作和多平台配置同步
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const toml = require('@iarna/toml');
+const { spawn } = require('child_process');
+const http = require('http');
+const https = require('https');
+const { McpClient } = require('./mcp-client');
+const { NATIVE_PATHS } = require('../../config/paths');
+
+// MCP 配置文件路径
+const CC_TOOL_DIR = path.join(os.homedir(), '.cc-tool');
+const MCP_SERVERS_FILE = path.join(CC_TOOL_DIR, 'mcp-servers.json');
+
+// 各平台配置文件路径
+const CLAUDE_CONFIG_PATH = path.join(os.homedir(), '.claude.json');
+const CODEX_CONFIG_PATH = path.join(os.homedir(), '.codex', 'config.toml');
+const GEMINI_CONFIG_PATH = path.join(os.homedir(), '.gemini', 'settings.json');
+const OPENCODE_CONFIG_DIR = NATIVE_PATHS.opencode.config;
+const OPENCODE_CONFIG_PATHS = {
+  jsonc: path.join(OPENCODE_CONFIG_DIR, 'opencode.jsonc'),
+  json: path.join(OPENCODE_CONFIG_DIR, 'opencode.json'),
+  legacy: path.join(OPENCODE_CONFIG_DIR, 'config.json')
+};
+
+// MCP 客户端连接池
+// serverId -> { client, timestamp }
+const mcpClientPool = new Map();
+const POOL_TTL = 5 * 60 * 1000; // 5 minutes
+
+// MCP 预设模板
+const MCP_PRESETS = [
+  {
+    id: 'fetch',
+    name: 'mcp-server-fetch',
+    description: '获取网页内容',
+    tags: ['http', 'web', 'fetch'],
+    server: {
+      type: 'stdio',
+      command: 'uvx',
+      args: ['mcp-server-fetch']
+    },
+    homepage: 'https://github.com/modelcontextprotocol/servers',
+    docs: 'https://github.com/modelcontextprotocol/servers/tree/main/src/fetch'
+  },
+  {
+    id: 'time',
+    name: '@modelcontextprotocol/server-time',
+    description: '获取当前时间和时区信息',
+    tags: ['time', 'utility'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-time']
+    },
+    homepage: 'https://github.com/modelcontextprotocol/servers',
+    docs: 'https://github.com/modelcontextprotocol/servers/tree/main/src/time'
+  },
+  {
+    id: 'memory',
+    name: '@modelcontextprotocol/server-memory',
+    description: '知识图谱记忆存储',
+    tags: ['memory', 'graph', 'knowledge'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-memory']
+    },
+    homepage: 'https://github.com/modelcontextprotocol/servers',
+    docs: 'https://github.com/modelcontextprotocol/servers/tree/main/src/memory'
+  },
+  {
+    id: 'sequential-thinking',
+    name: '@modelcontextprotocol/server-sequential-thinking',
+    description: '顺序思维推理',
+    tags: ['thinking', 'reasoning'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-sequential-thinking']
+    },
+    homepage: 'https://github.com/modelcontextprotocol/servers',
+    docs: 'https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking'
+  },
+  {
+    id: 'filesystem',
+    name: '@anthropic/mcp-server-filesystem',
+    description: '文件系统读写访问',
+    tags: ['filesystem', 'files'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@anthropic/mcp-server-filesystem', '/tmp']
+    },
+    homepage: 'https://github.com/anthropics/anthropic-quickstarts',
+    docs: 'https://github.com/anthropics/anthropic-quickstarts/tree/main/mcp-server-filesystem'
+  },
+  {
+    id: 'context7',
+    name: '@upstash/context7-mcp',
+    description: '文档搜索和上下文增强',
+    tags: ['docs', 'search', 'context'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@upstash/context7-mcp']
+    },
+    homepage: 'https://context7.com',
+    docs: 'https://github.com/upstash/context7/blob/master/README.md'
+  },
+  {
+    id: 'brave-search',
+    name: '@anthropic/mcp-server-brave-search',
+    description: 'Brave 搜索引擎',
+    tags: ['search', 'web'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@anthropic/mcp-server-brave-search'],
+      env: {
+        BRAVE_API_KEY: '<your-api-key>'
+      }
+    },
+    homepage: 'https://github.com/anthropics/anthropic-quickstarts',
+    docs: 'https://brave.com/search/api/'
+  },
+  {
+    id: 'github',
+    name: '@modelcontextprotocol/server-github',
+    description: 'GitHub API 集成',
+    tags: ['github', 'git', 'api'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-github'],
+      env: {
+        GITHUB_PERSONAL_ACCESS_TOKEN: '<your-token>'
+      }
+    },
+    homepage: 'https://github.com/modelcontextprotocol/servers',
+    docs: 'https://github.com/modelcontextprotocol/servers/tree/main/src/github'
+  },
+  {
+    id: 'puppeteer',
+    name: '@anthropic/mcp-server-puppeteer',
+    description: '浏览器自动化',
+    tags: ['browser', 'automation', 'web'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@anthropic/mcp-server-puppeteer']
+    },
+    homepage: 'https://github.com/anthropics/anthropic-quickstarts',
+    docs: 'https://pptr.dev/'
+  },
+  {
+    id: 'playwright',
+    name: '@anthropic/mcp-server-playwright',
+    description: 'Playwright 浏览器自动化',
+    tags: ['browser', 'automation', 'testing'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@anthropic/mcp-server-playwright']
+    },
+    homepage: 'https://github.com/anthropics/anthropic-quickstarts',
+    docs: 'https://playwright.dev/'
+  },
+  {
+    id: 'sqlite',
+    name: '@anthropic/mcp-server-sqlite',
+    description: 'SQLite 数据库访问',
+    tags: ['database', 'sql', 'sqlite'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@anthropic/mcp-server-sqlite', '--db-path', '/path/to/database.db']
+    },
+    homepage: 'https://github.com/anthropics/anthropic-quickstarts',
+    docs: 'https://www.sqlite.org/docs.html'
+  },
+  {
+    id: 'postgres',
+    name: '@anthropic/mcp-server-postgres',
+    description: 'PostgreSQL 数据库访问',
+    tags: ['database', 'sql', 'postgres'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@anthropic/mcp-server-postgres'],
+      env: {
+        POSTGRES_CONNECTION_STRING: 'postgresql://user:pass@localhost:5432/db'
+      }
+    },
+    homepage: 'https://github.com/anthropics/anthropic-quickstarts',
+    docs: 'https://www.postgresql.org/docs/'
+  },
+  {
+    id: 'slack',
+    name: '@modelcontextprotocol/server-slack',
+    description: 'Slack 消息和频道访问',
+    tags: ['slack', 'chat', 'messaging'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-slack'],
+      env: {
+        SLACK_BOT_TOKEN: '<your-bot-token>',
+        SLACK_TEAM_ID: '<your-team-id>'
+      }
+    },
+    homepage: 'https://github.com/modelcontextprotocol/servers',
+    docs: 'https://api.slack.com/docs'
+  },
+  {
+    id: 'google-drive',
+    name: '@modelcontextprotocol/server-gdrive',
+    description: 'Google Drive 文件访问',
+    tags: ['google', 'drive', 'files'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-gdrive']
+    },
+    homepage: 'https://github.com/modelcontextprotocol/servers',
+    docs: 'https://developers.google.com/drive'
+  },
+  {
+    id: 'everart',
+    name: '@modelcontextprotocol/server-everart',
+    description: 'AI 图片生成',
+    tags: ['image', 'art', 'generation'],
+    server: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-everart'],
+      env: {
+        EVERART_API_KEY: '<your-api-key>'
+      }
+    },
+    homepage: 'https://github.com/modelcontextprotocol/servers',
+    docs: 'https://everart.ai/docs'
+  }
+];
+
+/**
+ * 确保目录存在
+ */
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+/**
+ * 安全读取 JSON 文件
+ */
+function readJsonFile(filePath, defaultValue = {}) {
+  try {
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      return JSON.parse(content);
+    }
+  } catch (err) {
+    console.error(`[MCP] Failed to read ${filePath}:`, err.message);
+  }
+  return defaultValue;
+}
+
+/**
+ * 安全写入 JSON 文件（原子写入）
+ */
+function writeJsonFile(filePath, data) {
+  ensureDir(path.dirname(filePath));
+  const tempPath = filePath + '.tmp';
+  fs.writeFileSync(tempPath, JSON.stringify(data, null, 2), 'utf-8');
+  fs.renameSync(tempPath, filePath);
+}
+
+/**
+ * 安全读取 TOML 文件
+ */
+function readTomlFile(filePath, defaultValue = {}) {
+  try {
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      return toml.parse(content);
+    }
+  } catch (err) {
+    console.error(`[MCP] Failed to read ${filePath}:`, err.message);
+  }
+  return defaultValue;
+}
+
+/**
+ * 安全写入 TOML 文件（原子写入）
+ */
+function writeTomlFile(filePath, data) {
+  ensureDir(path.dirname(filePath));
+  const tempPath = filePath + '.tmp';
+  fs.writeFileSync(tempPath, toml.stringify(data), 'utf-8');
+  fs.renameSync(tempPath, filePath);
+}
+
+/**
+ * 去除 JSONC 注释
+ */
+function stripJsonComments(input) {
+  let result = '';
+  let inString = false;
+  let quote = '';
+  let index = 0;
+
+  while (index < input.length) {
+    const ch = input[index];
+    const next = input[index + 1];
+
+    if (inString) {
+      result += ch;
+      if (ch === '\\') {
+        if (next) {
+          result += next;
+          index += 2;
+          continue;
+        }
+      } else if (ch === quote) {
+        inString = false;
+      }
+      index += 1;
+      continue;
+    }
+
+    if (ch === '"' || ch === '\'') {
+      inString = true;
+      quote = ch;
+      result += ch;
+      index += 1;
+      continue;
+    }
+
+    if (ch === '/' && next === '/') {
+      index += 2;
+      while (index < input.length && input[index] !== '\n') {
+        index += 1;
+      }
+      continue;
+    }
+
+    if (ch === '/' && next === '*') {
+      index += 2;
+      while (index < input.length - 1 && !(input[index] === '*' && input[index + 1] === '/')) {
+        index += 1;
+      }
+      index += 2;
+      continue;
+    }
+
+    result += ch;
+    index += 1;
+  }
+
+  return result;
+}
+
+/**
+ * 选择 OpenCode 配置文件路径
+ */
+function selectOpenCodeConfigPath() {
+  if (fs.existsSync(OPENCODE_CONFIG_PATHS.jsonc)) return OPENCODE_CONFIG_PATHS.jsonc;
+  if (fs.existsSync(OPENCODE_CONFIG_PATHS.json)) return OPENCODE_CONFIG_PATHS.json;
+  if (fs.existsSync(OPENCODE_CONFIG_PATHS.legacy)) return OPENCODE_CONFIG_PATHS.legacy;
+  return OPENCODE_CONFIG_PATHS.json;
+}
+
+/**
+ * 读取 OpenCode 配置
+ */
+function readOpenCodeConfig() {
+  const filePath = selectOpenCodeConfigPath();
+
+  if (!fs.existsSync(filePath)) {
+    return { path: filePath, config: {} };
+  }
+
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    if (!raw.trim()) {
+      return { path: filePath, config: {} };
+    }
+
+    const content = filePath.endsWith('.jsonc') ? stripJsonComments(raw) : raw;
+    return {
+      path: filePath,
+      config: JSON.parse(content)
+    };
+  } catch (err) {
+    console.error(`[MCP] Failed to read OpenCode config:`, err.message);
+    return { path: filePath, config: {} };
+  }
+}
+
+/**
+ * 写入 OpenCode 配置（保持 JSON 格式）
+ */
+function writeOpenCodeConfig(filePath, data) {
+  ensureDir(path.dirname(filePath));
+  const tempPath = filePath + '.tmp';
+  fs.writeFileSync(tempPath, JSON.stringify(data, null, 2), 'utf-8');
+  fs.renameSync(tempPath, filePath);
+}
+
+// ============================================================================
+// MCP 数据管理
+// ============================================================================
+
+function normalizeServerApps(apps = {}) {
+  return {
+    claude: apps.claude !== undefined ? !!apps.claude : true,
+    codex: !!apps.codex,
+    gemini: !!apps.gemini,
+    opencode: !!apps.opencode
+  };
+}
+
+/**
+ * 获取所有 MCP 服务器
+ */
+function getAllServers() {
+  const servers = readJsonFile(MCP_SERVERS_FILE, {});
+
+  for (const server of Object.values(servers)) {
+    if (!server || typeof server !== 'object') {
+      continue;
+    }
+    server.apps = normalizeServerApps(server.apps);
+  }
+
+  return servers;
+}
+
+/**
+ * 获取单个 MCP 服务器
+ */
+function getServer(id) {
+  const servers = getAllServers();
+  return servers[id] || null;
+}
+
+/**
+ * 保存 MCP 服务器（添加或更新）
+ */
+async function saveServer(server) {
+  if (!server.id || !server.id.trim()) {
+    throw new Error('MCP 服务器 ID 不能为空');
+  }
+
+  // 验证服务器配置
+  validateServerSpec(server.server);
+
+  const servers = getAllServers();
+
+  // 如果是新服务器，设置默认值
+  if (!servers[server.id]) {
+    server.createdAt = Date.now();
+  }
+  server.updatedAt = Date.now();
+
+  // 确保 apps 字段存在
+  if (!server.apps) {
+    server.apps = { claude: true, codex: false, gemini: false, opencode: false };
+  } else {
+    server.apps = normalizeServerApps(server.apps);
+  }
+
+  servers[server.id] = server;
+  writeJsonFile(MCP_SERVERS_FILE, servers);
+
+  // 同步到各平台配置
+  await syncServerToAllPlatforms(server);
+
+  return server;
+}
+
+/**
+ * 删除 MCP 服务器
+ */
+async function deleteServer(id) {
+  const servers = getAllServers();
+  const server = servers[id];
+
+  if (!server) {
+    return false;
+  }
+
+  delete servers[id];
+  writeJsonFile(MCP_SERVERS_FILE, servers);
+
+  // 从所有平台配置中移除
+  await removeServerFromAllPlatforms(id);
+
+  return true;
+}
+
+/**
+ * 切换 MCP 服务器在某平台的启用状态
+ */
+async function toggleServerApp(serverId, app, enabled) {
+  const servers = getAllServers();
+  const server = servers[serverId];
+
+  if (!server) {
+    throw new Error(`MCP 服务器 "${serverId}" 不存在`);
+  }
+
+  if (!['claude', 'codex', 'gemini', 'opencode'].includes(app)) {
+    throw new Error(`无效的平台: ${app}`);
+  }
+
+  server.apps[app] = enabled;
+  server.updatedAt = Date.now();
+
+  writeJsonFile(MCP_SERVERS_FILE, servers);
+
+  // 同步到对应平台
+  if (enabled) {
+    await syncServerToPlatform(server, app);
+  } else {
+    await removeServerFromPlatform(serverId, app);
+  }
+
+  return server;
+}
+
+/**
+ * 获取 MCP 预设模板列表
+ */
+function getPresets() {
+  return MCP_PRESETS;
+}
+
+// ============================================================================
+// 服务器配置验证
+// ============================================================================
+
+/**
+ * 验证 MCP 服务器配置
+ */
+function validateServerSpec(spec) {
+  if (!spec || typeof spec !== 'object') {
+    throw new Error('服务器配置必须是对象');
+  }
+
+  const type = spec.type || 'stdio';
+
+  if (!['stdio', 'http', 'sse'].includes(type)) {
+    throw new Error(`无效的服务器类型: ${type}，必须是 stdio、http 或 sse`);
+  }
+
+  if (type === 'stdio') {
+    if (!spec.command || !spec.command.trim()) {
+      throw new Error('stdio 类型必须指定 command');
+    }
+  } else if (type === 'http' || type === 'sse') {
+    if (!spec.url || !spec.url.trim()) {
+      throw new Error(`${type} 类型必须指定 url`);
+    }
+  }
+}
+
+// ============================================================================
+// 平台配置同步
+// ============================================================================
+
+/**
+ * 同步服务器到所有已启用的平台
+ */
+async function syncServerToAllPlatforms(server) {
+  const { apps } = server;
+
+  if (apps.claude) {
+    await syncServerToPlatform(server, 'claude');
+  } else {
+    await removeServerFromPlatform(server.id, 'claude');
+  }
+
+  if (apps.codex) {
+    await syncServerToPlatform(server, 'codex');
+  } else {
+    await removeServerFromPlatform(server.id, 'codex');
+  }
+
+  if (apps.gemini) {
+    await syncServerToPlatform(server, 'gemini');
+  } else {
+    await removeServerFromPlatform(server.id, 'gemini');
+  }
+
+  if (apps.opencode) {
+    await syncServerToPlatform(server, 'opencode');
+  } else {
+    await removeServerFromPlatform(server.id, 'opencode');
+  }
+}
+
+/**
+ * 从所有平台移除服务器
+ */
+async function removeServerFromAllPlatforms(serverId) {
+  await removeServerFromPlatform(serverId, 'claude');
+  await removeServerFromPlatform(serverId, 'codex');
+  await removeServerFromPlatform(serverId, 'gemini');
+  await removeServerFromPlatform(serverId, 'opencode');
+}
+
+/**
+ * 同步服务器到指定平台
+ */
+async function syncServerToPlatform(server, platform) {
+  try {
+    switch (platform) {
+      case 'claude':
+        syncToClaudeConfig(server);
+        break;
+      case 'codex':
+        syncToCodexConfig(server);
+        break;
+      case 'gemini':
+        syncToGeminiConfig(server);
+        break;
+      case 'opencode':
+        syncToOpenCodeConfig(server);
+        break;
+    }
+    console.log(`[MCP] Synced "${server.id}" to ${platform}`);
+  } catch (err) {
+    console.error(`[MCP] Failed to sync "${server.id}" to ${platform}:`, err.message);
+    throw err;
+  }
+}
+
+/**
+ * 从指定平台移除服务器
+ */
+async function removeServerFromPlatform(serverId, platform) {
+  try {
+    switch (platform) {
+      case 'claude':
+        removeFromClaudeConfig(serverId);
+        break;
+      case 'codex':
+        removeFromCodexConfig(serverId);
+        break;
+      case 'gemini':
+        removeFromGeminiConfig(serverId);
+        break;
+      case 'opencode':
+        removeFromOpenCodeConfig(serverId);
+        break;
+    }
+    console.log(`[MCP] Removed "${serverId}" from ${platform}`);
+  } catch (err) {
+    console.error(`[MCP] Failed to remove "${serverId}" from ${platform}:`, err.message);
+  }
+}
+
+// ============================================================================
+// Claude 配置同步
+// ============================================================================
+
+/**
+ * 同步到 Claude 配置
+ */
+function syncToClaudeConfig(server) {
+  const config = readJsonFile(CLAUDE_CONFIG_PATH, {});
+
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+
+  // 只写入 server spec，不写入元数据
+  config.mcpServers[server.id] = extractServerSpec(server.server);
+
+  writeJsonFile(CLAUDE_CONFIG_PATH, config);
+}
+
+/**
+ * 从 Claude 配置移除
+ */
+function removeFromClaudeConfig(serverId) {
+  const config = readJsonFile(CLAUDE_CONFIG_PATH, {});
+
+  if (config.mcpServers && config.mcpServers[serverId]) {
+    delete config.mcpServers[serverId];
+    writeJsonFile(CLAUDE_CONFIG_PATH, config);
+  }
+}
+
+// ============================================================================
+// Codex 配置同步 (TOML 格式)
+// ============================================================================
+
+/**
+ * 同步到 Codex 配置
+ */
+function syncToCodexConfig(server) {
+  const config = readTomlFile(CODEX_CONFIG_PATH, {});
+
+  if (!config.mcp_servers) {
+    config.mcp_servers = {};
+  }
+
+  // 转换为 Codex TOML 格式
+  config.mcp_servers[server.id] = convertToCodexFormat(server.server);
+
+  writeTomlFile(CODEX_CONFIG_PATH, config);
+}
+
+/**
+ * 从 Codex 配置移除
+ */
+function removeFromCodexConfig(serverId) {
+  const config = readTomlFile(CODEX_CONFIG_PATH, {});
+
+  if (config.mcp_servers && config.mcp_servers[serverId]) {
+    delete config.mcp_servers[serverId];
+    writeTomlFile(CODEX_CONFIG_PATH, config);
+  }
+}
+
+/**
+ * 转换为 Codex TOML 格式
+ */
+function convertToCodexFormat(spec) {
+  const result = {
+    type: spec.type || 'stdio'
+  };
+
+  if (result.type === 'stdio') {
+    result.command = spec.command || '';
+    if (spec.args && spec.args.length > 0) {
+      result.args = spec.args;
+    }
+    if (spec.env && Object.keys(spec.env).length > 0) {
+      result.env = spec.env;
+    }
+    if (spec.cwd) {
+      result.cwd = spec.cwd;
+    }
+  } else if (result.type === 'http' || result.type === 'sse') {
+    result.url = spec.url || '';
+    if (spec.headers && Object.keys(spec.headers).length > 0) {
+      result.http_headers = spec.headers;
+    }
+  }
+
+  return result;
+}
+
+// ============================================================================
+// Gemini 配置同步
+// ============================================================================
+
+/**
+ * 同步到 Gemini 配置
+ */
+function syncToGeminiConfig(server) {
+  const config = readJsonFile(GEMINI_CONFIG_PATH, {});
+
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+
+  // 只写入 server spec，不写入元数据
+  config.mcpServers[server.id] = extractServerSpec(server.server);
+
+  writeJsonFile(GEMINI_CONFIG_PATH, config);
+}
+
+/**
+ * 从 Gemini 配置移除
+ */
+function removeFromGeminiConfig(serverId) {
+  const config = readJsonFile(GEMINI_CONFIG_PATH, {});
+
+  if (config.mcpServers && config.mcpServers[serverId]) {
+    delete config.mcpServers[serverId];
+    writeJsonFile(GEMINI_CONFIG_PATH, config);
+  }
+}
+
+// ============================================================================
+// OpenCode 配置同步
+// ============================================================================
+
+/**
+ * 转换为 OpenCode 配置格式
+ */
+function convertToOpenCodeFormat(spec) {
+  const sourceType = spec.type || 'stdio';
+
+  if (sourceType === 'local' || sourceType === 'remote') {
+    const result = { ...spec };
+    result.enabled = spec.enabled !== false;
+    if (sourceType === 'local' && typeof result.command === 'string') {
+      result.command = result.command ? [result.command] : [];
+    }
+    return result;
+  }
+
+  if (sourceType === 'stdio') {
+    const command = [];
+    if (spec.command) {
+      command.push(spec.command);
+    }
+    if (Array.isArray(spec.args) && spec.args.length > 0) {
+      command.push(...spec.args);
+    }
+
+    const result = {
+      type: 'local',
+      command,
+      enabled: true
+    };
+
+    if (spec.env && Object.keys(spec.env).length > 0) {
+      result.environment = spec.env;
+    }
+    if (spec.cwd) {
+      result.cwd = spec.cwd;
+    }
+
+    return result;
+  }
+
+  const result = {
+    type: 'remote',
+    url: spec.url || '',
+    enabled: true
+  };
+
+  if (spec.headers && Object.keys(spec.headers).length > 0) {
+    result.headers = spec.headers;
+  }
+
+  return result;
+}
+
+/**
+ * 从 OpenCode 格式转换到通用格式
+ */
+function convertFromOpenCodeFormat(spec) {
+  const sourceType = spec.type || (Array.isArray(spec.command) ? 'local' : 'remote');
+
+  if (sourceType === 'local') {
+    const result = { type: 'stdio' };
+    if (Array.isArray(spec.command) && spec.command.length > 0) {
+      result.command = spec.command[0];
+      if (spec.command.length > 1) {
+        result.args = spec.command.slice(1);
+      }
+    } else if (typeof spec.command === 'string') {
+      result.command = spec.command;
+    } else {
+      result.command = '';
+    }
+
+    if (spec.environment && typeof spec.environment === 'object') {
+      result.env = spec.environment;
+    } else if (spec.env && typeof spec.env === 'object') {
+      result.env = spec.env;
+    }
+    if (spec.cwd) {
+      result.cwd = spec.cwd;
+    }
+    return result;
+  }
+
+  if (sourceType === 'remote') {
+    const result = {
+      type: 'http',
+      url: spec.url || ''
+    };
+    if (spec.headers && typeof spec.headers === 'object') {
+      result.headers = spec.headers;
+    }
+    return result;
+  }
+
+  // 已经是通用格式时直接兼容处理
+  if (sourceType === 'stdio' || sourceType === 'http' || sourceType === 'sse') {
+    return convertFromCodexFormat(spec);
+  }
+
+  return {
+    type: 'stdio',
+    command: ''
+  };
+}
+
+/**
+ * 同步到 OpenCode 配置
+ */
+function syncToOpenCodeConfig(server) {
+  const { path: configPath, config } = readOpenCodeConfig();
+  const nextConfig = config && typeof config === 'object' ? config : {};
+
+  if (!nextConfig.mcp || typeof nextConfig.mcp !== 'object') {
+    nextConfig.mcp = {};
+  }
+
+  nextConfig.mcp[server.id] = convertToOpenCodeFormat(server.server);
+  writeOpenCodeConfig(configPath, nextConfig);
+}
+
+/**
+ * 从 OpenCode 配置移除
+ */
+function removeFromOpenCodeConfig(serverId) {
+  const { path: configPath, config } = readOpenCodeConfig();
+  const nextConfig = config && typeof config === 'object' ? config : {};
+
+  if (nextConfig.mcp && nextConfig.mcp[serverId]) {
+    delete nextConfig.mcp[serverId];
+    writeOpenCodeConfig(configPath, nextConfig);
+  }
+}
+
+// ============================================================================
+// 导入功能
+// ============================================================================
+
+/**
+ * 从指定平台导入 MCP 配置
+ */
+async function importFromPlatform(platform) {
+  let importedCount = 0;
+  const servers = getAllServers();
+
+  switch (platform) {
+    case 'claude':
+      importedCount = importFromClaude(servers);
+      break;
+    case 'codex':
+      importedCount = importFromCodex(servers);
+      break;
+    case 'gemini':
+      importedCount = importFromGemini(servers);
+      break;
+    case 'opencode':
+      importedCount = importFromOpenCode(servers);
+      break;
+    default:
+      throw new Error(`无效的平台: ${platform}`);
+  }
+
+  if (importedCount > 0) {
+    writeJsonFile(MCP_SERVERS_FILE, servers);
+  }
+
+  return importedCount;
+}
+
+/**
+ * 从 Claude 导入
+ */
+function importFromClaude(servers) {
+  const config = readJsonFile(CLAUDE_CONFIG_PATH, {});
+  const mcpServers = config.mcpServers || {};
+  let count = 0;
+
+  for (const [id, spec] of Object.entries(mcpServers)) {
+    if (servers[id]) {
+      // 已存在，只启用 Claude
+      if (!servers[id].apps.claude) {
+        servers[id].apps.claude = true;
+        count++;
+      }
+    } else {
+      // 新服务器
+      servers[id] = {
+        id,
+        name: id,
+        server: spec,
+        apps: { claude: true, codex: false, gemini: false, opencode: false },
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      count++;
+    }
+  }
+
+  return count;
+}
+
+/**
+ * 从 Codex 导入
+ */
+function importFromCodex(servers) {
+  const config = readTomlFile(CODEX_CONFIG_PATH, {});
+  const mcpServers = config.mcp_servers || {};
+  let count = 0;
+
+  for (const [id, spec] of Object.entries(mcpServers)) {
+    // 转换 Codex 格式到通用格式
+    const convertedSpec = convertFromCodexFormat(spec);
+
+    if (servers[id]) {
+      // 已存在，只启用 Codex
+      if (!servers[id].apps.codex) {
+        servers[id].apps.codex = true;
+        count++;
+      }
+    } else {
+      // 新服务器
+      servers[id] = {
+        id,
+        name: id,
+        server: convertedSpec,
+        apps: { claude: false, codex: true, gemini: false, opencode: false },
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      count++;
+    }
+  }
+
+  return count;
+}
+
+/**
+ * 从 Gemini 导入
+ */
+function importFromGemini(servers) {
+  const config = readJsonFile(GEMINI_CONFIG_PATH, {});
+  const mcpServers = config.mcpServers || {};
+  let count = 0;
+
+  for (const [id, spec] of Object.entries(mcpServers)) {
+    if (servers[id]) {
+      // 已存在，只启用 Gemini
+      if (!servers[id].apps.gemini) {
+        servers[id].apps.gemini = true;
+        count++;
+      }
+    } else {
+      // 新服务器
+      servers[id] = {
+        id,
+        name: id,
+        server: spec,
+        apps: { claude: false, codex: false, gemini: true, opencode: false },
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      count++;
+    }
+  }
+
+  return count;
+}
+
+/**
+ * 从 OpenCode 导入
+ */
+function importFromOpenCode(servers) {
+  const { config } = readOpenCodeConfig();
+  const mcpServers = config.mcp || {};
+  let count = 0;
+
+  for (const [id, spec] of Object.entries(mcpServers)) {
+    const convertedSpec = convertFromOpenCodeFormat(spec || {});
+
+    if (servers[id]) {
+      if (!servers[id].apps.opencode) {
+        servers[id].apps.opencode = true;
+        count++;
+      }
+    } else {
+      servers[id] = {
+        id,
+        name: id,
+        server: convertedSpec,
+        apps: { claude: false, codex: false, gemini: false, opencode: true },
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      count++;
+    }
+  }
+
+  return count;
+}
+
+/**
+ * 从 Codex 格式转换
+ */
+function convertFromCodexFormat(spec) {
+  const result = {
+    type: spec.type || 'stdio'
+  };
+
+  if (result.type === 'stdio') {
+    result.command = spec.command || '';
+    if (spec.args) {
+      result.args = spec.args;
+    }
+    if (spec.env) {
+      result.env = spec.env;
+    }
+    if (spec.cwd) {
+      result.cwd = spec.cwd;
+    }
+  } else if (result.type === 'http' || result.type === 'sse') {
+    result.url = spec.url || '';
+    if (spec.http_headers) {
+      result.headers = spec.http_headers;
+    } else if (spec.headers) {
+      result.headers = spec.headers;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 提取纯净的服务器规范（移除元数据）
+ */
+function extractServerSpec(spec) {
+  const result = { ...spec };
+  // 移除可能存在的非规范字段
+  delete result.id;
+  delete result.name;
+  delete result.description;
+  delete result.tags;
+  delete result.homepage;
+  delete result.docs;
+  delete result.apps;
+  delete result.createdAt;
+  delete result.updatedAt;
+  return result;
+}
+
+/**
+ * 获取统计信息
+ */
+function getStats() {
+  const servers = getAllServers();
+  const serverList = Object.values(servers);
+
+  return {
+    total: serverList.length,
+    claude: serverList.filter(s => s.apps?.claude).length,
+    codex: serverList.filter(s => s.apps?.codex).length,
+    gemini: serverList.filter(s => s.apps?.gemini).length,
+    opencode: serverList.filter(s => s.apps?.opencode).length
+  };
+}
+
+// ============================================================================
+// 服务器测试功能
+// ============================================================================
+
+/**
+ * 测试 MCP 服务器连接
+ * @param {string} serverId - 服务器 ID
+ * @returns {Promise<{success: boolean, message: string, duration?: number}>}
+ */
+async function testServer(serverId) {
+  const server = getServer(serverId);
+  if (!server) {
+    throw new Error(`MCP 服务器 "${serverId}" 不存在`);
+  }
+
+  const spec = server.server;
+  const type = spec.type || 'stdio';
+  const startTime = Date.now();
+
+  try {
+    if (type === 'stdio') {
+      return await testStdioServer(spec);
+    } else if (type === 'http' || type === 'sse') {
+      return await testHttpServer(spec);
+    } else {
+      return { success: false, message: `不支持的服务器类型: ${type}` };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      message: err.message,
+      duration: Date.now() - startTime
+    };
+  }
+}
+
+/**
+ * 测试 stdio 类型服务器
+ */
+async function testStdioServer(spec) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    const timeout = 10000; // 10 秒超时
+
+    // 检查命令是否存在
+    const command = spec.command;
+    const args = spec.args || [];
+
+    let child;
+    let resolved = false;
+    let stdout = '';
+    let stderr = '';
+
+    const cleanup = () => {
+      if (child && !child.killed) {
+        child.kill('SIGTERM');
+        setTimeout(() => {
+          if (!child.killed) child.kill('SIGKILL');
+        }, 1000);
+      }
+    };
+
+    const done = (result) => {
+      if (resolved) return;
+      resolved = true;
+      cleanup();
+      resolve(result);
+    };
+
+    try {
+      child = spawn(command, args, {
+        env: { ...process.env, ...spec.env },
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: spec.cwd || process.cwd()
+      });
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+        // MCP 服务器启动成功通常会输出 JSON-RPC 相关内容
+        if (stdout.includes('{') || stdout.length > 0) {
+          done({
+            success: true,
+            message: '服务器启动成功',
+            duration: Date.now() - startTime
+          });
+        }
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+          done({
+            success: false,
+            message: `命令 "${command}" 未找到，请确保已安装`,
+            duration: Date.now() - startTime
+          });
+        } else {
+          done({
+            success: false,
+            message: `启动失败: ${err.message}`,
+            duration: Date.now() - startTime
+          });
+        }
+      });
+
+      child.on('close', (code) => {
+        if (code === 0 || stdout.length > 0) {
+          done({
+            success: true,
+            message: '服务器测试通过',
+            duration: Date.now() - startTime
+          });
+        } else {
+          done({
+            success: false,
+            message: stderr || `进程退出码: ${code}`,
+            duration: Date.now() - startTime
+          });
+        }
+      });
+
+      // 超时处理
+      setTimeout(() => {
+        // 如果进程还在运行，说明服务器正常启动了
+        if (!resolved && child && !child.killed) {
+          done({
+            success: true,
+            message: '服务器正常运行中',
+            duration: Date.now() - startTime
+          });
+        }
+      }, 3000); // 3 秒后如果还在运行就认为成功
+
+      // 最终超时
+      setTimeout(() => {
+        done({
+          success: false,
+          message: '测试超时',
+          duration: timeout
+        });
+      }, timeout);
+
+    } catch (err) {
+      done({
+        success: false,
+        message: `测试失败: ${err.message}`,
+        duration: Date.now() - startTime
+      });
+    }
+  });
+}
+
+/**
+ * 测试 http/sse 类型服务器
+ */
+async function testHttpServer(spec) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    const timeout = 10000;
+
+    try {
+      const url = new URL(spec.url);
+      const isHttps = url.protocol === 'https:';
+      const client = isHttps ? https : http;
+
+      const options = {
+        hostname: url.hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: url.pathname + url.search,
+        method: 'GET',
+        timeout: timeout,
+        headers: {
+          ...spec.headers
+        }
+      };
+
+      const req = client.request(options, (res) => {
+        resolve({
+          success: res.statusCode >= 200 && res.statusCode < 500,
+          message: res.statusCode >= 200 && res.statusCode < 400
+            ? `服务器响应正常 (HTTP ${res.statusCode})`
+            : `服务器响应异常 (HTTP ${res.statusCode})`,
+          duration: Date.now() - startTime
+        });
+      });
+
+      req.on('error', (err) => {
+        resolve({
+          success: false,
+          message: `连接失败: ${err.message}`,
+          duration: Date.now() - startTime
+        });
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        resolve({
+          success: false,
+          message: '连接超时',
+          duration: timeout
+        });
+      });
+
+      req.end();
+    } catch (err) {
+      resolve({
+        success: false,
+        message: `URL 无效: ${err.message}`,
+        duration: Date.now() - startTime
+      });
+    }
+  });
+}
+
+/**
+ * Get tools list from MCP server
+ * @param {string} serverId - Server ID from config
+ * @returns {Promise<{tools: Array, duration: number, status: string}>}
+ */
+async function getServerTools(serverId) {
+  const server = getServer(serverId);
+  if (!server) {
+    throw new Error(`MCP 服务器 "${serverId}" 不存在`);
+  }
+
+  const startTime = Date.now();
+  const spec = server.server;
+
+  try {
+    // Check if we have a cached connection
+    const cached = mcpClientPool.get(serverId);
+    const now = Date.now();
+
+    let client;
+    let needsInitialization = false;
+
+    if (cached && now - cached.timestamp < POOL_TTL && cached.client.connected) {
+      // Reuse existing connection
+      client = cached.client;
+      console.log(`[MCP] Reusing pooled connection for "${serverId}"`);
+    } else {
+      // Create new connection
+      if (cached) {
+        // Clean up expired connection
+        try {
+          await cached.client.disconnect();
+        } catch (err) {
+          console.error(`[MCP] Error disconnecting expired client: ${err.message}`);
+        }
+        mcpClientPool.delete(serverId);
+      }
+
+      // Create new client with 10s timeout
+      client = new McpClient(spec, { timeout: 10000 });
+      needsInitialization = true;
+      console.log(`[MCP] Creating new connection for "${serverId}"`);
+    }
+
+    // Connect and initialize if needed
+    if (needsInitialization) {
+      await client.connect();
+      await client.initialize();
+
+      // Cache the connection
+      mcpClientPool.set(serverId, {
+        client,
+        timestamp: Date.now()
+      });
+    }
+
+    // Get tools list
+    const tools = await client.listTools();
+
+    return {
+      tools,
+      duration: Date.now() - startTime,
+      status: 'online'
+    };
+
+  } catch (err) {
+    // Clean up failed connection from pool
+    const cached = mcpClientPool.get(serverId);
+    if (cached) {
+      try {
+        await cached.client.disconnect();
+      } catch (e) {
+        // ignore
+      }
+      mcpClientPool.delete(serverId);
+    }
+
+    return {
+      tools: [],
+      duration: Date.now() - startTime,
+      status: 'error',
+      error: err.message
+    };
+  }
+}
+
+/**
+ * Execute a tool on MCP server
+ * @param {string} serverId - Server ID
+ * @param {string} toolName - Tool name
+ * @param {Object} arguments - Tool arguments
+ * @returns {Promise<{result: Object, duration: number, isError: boolean, truncated?: boolean, truncatedSize?: number}>}
+ */
+async function callServerTool(serverId, toolName, arguments = {}) {
+  const server = getServer(serverId);
+  if (!server) {
+    throw new Error(`MCP 服务器 "${serverId}" 不存在`);
+  }
+
+  const startTime = Date.now();
+  const spec = server.server;
+
+  try {
+    // Check if we have a cached connection
+    const cached = mcpClientPool.get(serverId);
+    const now = Date.now();
+
+    let client;
+    let needsInitialization = false;
+
+    if (cached && now - cached.timestamp < POOL_TTL && cached.client.connected) {
+      // Reuse existing connection
+      client = cached.client;
+      // Update timestamp
+      cached.timestamp = now;
+      console.log(`[MCP] Reusing pooled connection for "${serverId}"`);
+    } else {
+      // Create new connection
+      if (cached) {
+        // Clean up expired connection
+        try {
+          await cached.client.disconnect();
+        } catch (err) {
+          console.error(`[MCP] Error disconnecting expired client: ${err.message}`);
+        }
+        mcpClientPool.delete(serverId);
+      }
+
+      // Create new client with 30s timeout
+      client = new McpClient(spec, { timeout: 30000 });
+      needsInitialization = true;
+      console.log(`[MCP] Creating new connection for "${serverId}"`);
+    }
+
+    // Connect and initialize if needed
+    if (needsInitialization) {
+      await client.connect();
+      await client.initialize();
+
+      // Cache the connection
+      mcpClientPool.set(serverId, {
+        client,
+        timestamp: Date.now()
+      });
+    }
+
+    // Call the tool
+    const result = await client.callTool(toolName, arguments);
+
+    const duration = Date.now() - startTime;
+
+    // Check result size, truncate if > 10KB
+    const resultStr = JSON.stringify(result);
+    if (resultStr.length > 10 * 1024) {
+      return {
+        result: {
+          ...result,
+          truncated: true
+        },
+        truncatedSize: resultStr.length,
+        duration,
+        isError: result.isError || false
+      };
+    }
+
+    return {
+      result,
+      duration,
+      isError: result.isError || false
+    };
+
+  } catch (err) {
+    // Clean up failed connection from pool
+    const cached = mcpClientPool.get(serverId);
+    if (cached) {
+      try {
+        await cached.client.disconnect();
+      } catch (e) {
+        // ignore
+      }
+      mcpClientPool.delete(serverId);
+    }
+
+    return {
+      result: {
+        error: err.message,
+        code: err.code,
+        data: err.data
+      },
+      duration: Date.now() - startTime,
+      isError: true
+    };
+  }
+}
+
+/**
+ * 更新服务器状态
+ */
+async function updateServerStatus(serverId, status) {
+  const servers = getAllServers();
+  const server = servers[serverId];
+
+  if (!server) {
+    throw new Error(`MCP 服务器 "${serverId}" 不存在`);
+  }
+
+  server.status = status;
+  server.lastChecked = Date.now();
+
+  writeJsonFile(MCP_SERVERS_FILE, servers);
+  return server;
+}
+
+// ============================================================================
+// 排序功能
+// ============================================================================
+
+/**
+ * 更新服务器排序
+ * @param {string[]} serverIds - 按顺序排列的服务器 ID 数组
+ */
+function updateServerOrder(serverIds) {
+  const servers = getAllServers();
+
+  // 更新每个服务器的排序索引
+  serverIds.forEach((id, index) => {
+    if (servers[id]) {
+      servers[id].order = index;
+    }
+  });
+
+  writeJsonFile(MCP_SERVERS_FILE, servers);
+  return servers;
+}
+
+// ============================================================================
+// 导出功能
+// ============================================================================
+
+/**
+ * 导出所有 MCP 配置
+ * @param {string} format - 导出格式: 'json' | 'claude' | 'codex' | 'opencode'
+ */
+function exportServers(format = 'json') {
+  const servers = getAllServers();
+
+  switch (format) {
+    case 'claude':
+      return exportForClaude(servers);
+    case 'codex':
+      return exportForCodex(servers);
+    case 'opencode':
+      return exportForOpenCode(servers);
+    case 'json':
+    default:
+      return exportAsJson(servers);
+  }
+}
+
+/**
+ * 导出为通用 JSON 格式
+ */
+function exportAsJson(servers) {
+  const mcpServers = {};
+
+  for (const [id, server] of Object.entries(servers)) {
+    mcpServers[id] = extractServerSpec(server.server);
+  }
+
+  return {
+    format: 'json',
+    content: JSON.stringify({ mcpServers }, null, 2),
+    filename: 'mcp-servers.json'
+  };
+}
+
+/**
+ * 导出为 Claude 格式
+ */
+function exportForClaude(servers) {
+  const mcpServers = {};
+
+  for (const [id, server] of Object.entries(servers)) {
+    if (server.apps?.claude) {
+      mcpServers[id] = extractServerSpec(server.server);
+    }
+  }
+
+  return {
+    format: 'claude',
+    content: JSON.stringify({ mcpServers }, null, 2),
+    filename: 'claude-mcp-config.json'
+  };
+}
+
+/**
+ * 导出为 Codex 格式
+ */
+function exportForCodex(servers) {
+  const mcp_servers = {};
+
+  for (const [id, server] of Object.entries(servers)) {
+    if (server.apps?.codex) {
+      mcp_servers[id] = convertToCodexFormat(server.server);
+    }
+  }
+
+  return {
+    format: 'codex',
+    content: toml.stringify({ mcp_servers }),
+    filename: 'codex-mcp-config.toml'
+  };
+}
+
+/**
+ * 导出为 OpenCode 格式
+ */
+function exportForOpenCode(servers) {
+  const mcp = {};
+
+  for (const [id, server] of Object.entries(servers)) {
+    if (server.apps?.opencode) {
+      mcp[id] = convertToOpenCodeFormat(server.server);
+    }
+  }
+
+  return {
+    format: 'opencode',
+    content: JSON.stringify({ mcp }, null, 2),
+    filename: 'opencode-mcp-config.json'
+  };
+}
+
+module.exports = {
+  getAllServers,
+  getServer,
+  saveServer,
+  deleteServer,
+  toggleServerApp,
+  getPresets,
+  importFromPlatform,
+  getStats,
+  validateServerSpec,
+  // 新增功能
+  testServer,
+  getServerTools,
+  callServerTool,
+  updateServerStatus,
+  updateServerOrder,
+  exportServers
+};