coding-tool-x 3.6.12 → 3.7.0

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

@@ -19,7 +19,7 @@ const HOME_DIR = resolvePreferredHomeDir(process.platform, process.env, os.homed
 const MCP_SERVERS_FILE = PATHS.mcpServers;
 
 // 各平台配置文件路径
-const CLAUDE_CONFIG_PATH = path.join(HOME_DIR, '.claude.json');
+const CLAUDE_CONFIG_PATH = NATIVE_PATHS.claude.mcp || path.join(HOME_DIR, '.claude.json');
 const CODEX_CONFIG_PATH = NATIVE_PATHS.codex.config;
 const GEMINI_CONFIG_PATH = path.join(path.dirname(NATIVE_PATHS.gemini.env), 'settings.json');
 const OPENCODE_CONFIG_DIR = NATIVE_PATHS.opencode.config;
@@ -28,6 +28,8 @@ const OPENCODE_CONFIG_PATHS = {
   json: path.join(OPENCODE_CONFIG_DIR, 'opencode.json'),
   legacy: path.join(OPENCODE_CONFIG_DIR, 'config.json')
 };
+const PI_MCP_CONFIG_PATH = NATIVE_PATHS.pi?.mcp
+  || path.join(NATIVE_PATHS.pi?.dir || path.join(HOME_DIR, '.omp', 'agent'), 'mcp.json');
 
 // MCP 客户端连接池
 // serverId -> { client, timestamp }
@@ -36,6 +38,9 @@ const POOL_TTL = 5 * 60 * 1000; // 5 minutes
 const STREAMABLE_HTTP_TYPE = 'streamable_http';
 const MCP_SERVER_TYPES = ['stdio', STREAMABLE_HTTP_TYPE, 'sse'];
 const REMOTE_MCP_SERVER_TYPES = [STREAMABLE_HTTP_TYPE, 'sse'];
+const MCP_PLATFORM_KEYS = ['claude', 'codex', 'gemini', 'opencode', 'pi'];
+const OMP_MCP_SCHEMA_URL = 'https://raw.githubusercontent.com/can1357/oh-my-pi/main/packages/coding-agent/src/config/mcp-schema.json';
+const OMP_SERVER_NAME_PATTERN = /^[a-zA-Z0-9_.-]{1,100}$/;
 
 function normalizeServerSpec(spec = {}) {
   if (!spec || typeof spec !== 'object') {
@@ -532,7 +537,8 @@ const DEFAULT_SERVER_APPS = {
   claude: true,
   codex: false,
   gemini: false,
-  opencode: false
+  opencode: false,
+  pi: false
 };
 
 function normalizeServerApps(apps = {}, fallbackApps = DEFAULT_SERVER_APPS) {
@@ -540,7 +546,8 @@ function normalizeServerApps(apps = {}, fallbackApps = DEFAULT_SERVER_APPS) {
     claude: apps.claude !== undefined ? !!apps.claude : !!fallbackApps.claude,
     codex: apps.codex !== undefined ? !!apps.codex : !!fallbackApps.codex,
     gemini: apps.gemini !== undefined ? !!apps.gemini : !!fallbackApps.gemini,
-    opencode: apps.opencode !== undefined ? !!apps.opencode : !!fallbackApps.opencode
+    opencode: apps.opencode !== undefined ? !!apps.opencode : !!fallbackApps.opencode,
+    pi: apps.pi !== undefined ? !!apps.pi : !!fallbackApps.pi
   };
 }
 
@@ -648,7 +655,7 @@ async function toggleServerApp(serverId, app, enabled) {
     throw new Error(`MCP 服务器 "${serverId}" 不存在`);
   }
 
-  if (!['claude', 'codex', 'gemini', 'opencode'].includes(app)) {
+  if (!MCP_PLATFORM_KEYS.includes(app)) {
     throw new Error(`无效的平台: ${app}`);
   }
 
@@ -720,28 +727,12 @@ async function syncServerToAllPlatforms(server, previousApps = null) {
     return previous[platform] && !apps[platform];
   };
 
-  if (apps.claude) {
-    await syncServerToPlatform(server, 'claude');
-  } else if (shouldRemoveFromPlatform('claude')) {
-    await removeServerFromPlatform(server.id, 'claude');
-  }
-
-  if (apps.codex) {
-    await syncServerToPlatform(server, 'codex');
-  } else if (shouldRemoveFromPlatform('codex')) {
-    await removeServerFromPlatform(server.id, 'codex');
-  }
-
-  if (apps.gemini) {
-    await syncServerToPlatform(server, 'gemini');
-  } else if (shouldRemoveFromPlatform('gemini')) {
-    await removeServerFromPlatform(server.id, 'gemini');
-  }
-
-  if (apps.opencode) {
-    await syncServerToPlatform(server, 'opencode');
-  } else if (shouldRemoveFromPlatform('opencode')) {
-    await removeServerFromPlatform(server.id, 'opencode');
+  for (const platform of MCP_PLATFORM_KEYS) {
+    if (apps[platform]) {
+      await syncServerToPlatform(server, platform);
+    } else if (shouldRemoveFromPlatform(platform)) {
+      await removeServerFromPlatform(server.id, platform);
+    }
   }
 }
 
@@ -749,10 +740,9 @@ async function syncServerToAllPlatforms(server, previousApps = null) {
  * 从所有平台移除服务器
  */
 async function removeServerFromAllPlatforms(serverId) {
-  await removeServerFromPlatform(serverId, 'claude');
-  await removeServerFromPlatform(serverId, 'codex');
-  await removeServerFromPlatform(serverId, 'gemini');
-  await removeServerFromPlatform(serverId, 'opencode');
+  for (const platform of MCP_PLATFORM_KEYS) {
+    await removeServerFromPlatform(serverId, platform);
+  }
 }
 
 /**
@@ -773,6 +763,9 @@ async function syncServerToPlatform(server, platform) {
       case 'opencode':
         syncToOpenCodeConfig(server);
         break;
+      case 'pi':
+        syncToOmpMcpConfig(server);
+        break;
     }
     console.log(`[MCP] Synced "${server.id}" to ${platform}`);
   } catch (err) {
@@ -799,6 +792,9 @@ async function removeServerFromPlatform(serverId, platform) {
       case 'opencode':
         removeFromOpenCodeConfig(serverId);
         break;
+      case 'pi':
+        removeFromOmpMcpConfig(serverId);
+        break;
     }
     console.log(`[MCP] Removed "${serverId}" from ${platform}`);
   } catch (err) {
@@ -947,6 +943,133 @@ function removeFromGeminiConfig(serverId) {
   }
 }
 
+// ============================================================================
+// OMP 配置同步
+// ============================================================================
+
+function validateOmpServerName(serverId) {
+  if (!OMP_SERVER_NAME_PATTERN.test(serverId)) {
+    throw new Error(`OMP MCP 服务器 ID "${serverId}" 无效。OMP 仅支持 1-100 个字母、数字、下划线、点或连字符。`);
+  }
+}
+
+function readOmpMcpConfig() {
+  const config = readJsonFile(PI_MCP_CONFIG_PATH, { mcpServers: {} });
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    return { mcpServers: {} };
+  }
+  if (!config.mcpServers || typeof config.mcpServers !== 'object' || Array.isArray(config.mcpServers)) {
+    config.mcpServers = {};
+  }
+  return config;
+}
+
+function copyCommonMcpFields(source, target) {
+  for (const key of ['timeout', 'auth', 'oauth']) {
+    if (source[key] !== undefined) {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+
+function convertToOmpMcpFormat(spec = {}) {
+  const sourceType = spec.type || 'stdio';
+  let result;
+
+  if (sourceType === 'stdio') {
+    result = {
+      type: 'stdio',
+      command: spec.command || ''
+    };
+    if (Array.isArray(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 (sourceType === STREAMABLE_HTTP_TYPE) {
+    result = {
+      type: 'http',
+      url: spec.url || ''
+    };
+    if (spec.headers && Object.keys(spec.headers).length > 0) {
+      result.headers = spec.headers;
+    }
+  } else if (sourceType === 'sse') {
+    result = {
+      type: 'sse',
+      url: spec.url || ''
+    };
+    if (spec.headers && Object.keys(spec.headers).length > 0) {
+      result.headers = spec.headers;
+    }
+  } else {
+    result = extractServerSpec(spec);
+  }
+
+  return copyCommonMcpFields(spec, result);
+}
+
+function convertFromOmpMcpFormat(spec = {}) {
+  const sourceType = spec.type || 'stdio';
+  let result;
+
+  if (sourceType === 'stdio') {
+    result = {
+      type: 'stdio',
+      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 (sourceType === 'http') {
+    result = {
+      type: STREAMABLE_HTTP_TYPE,
+      url: spec.url || ''
+    };
+    if (spec.headers) {
+      result.headers = spec.headers;
+    }
+  } else if (sourceType === 'sse') {
+    result = {
+      type: 'sse',
+      url: spec.url || ''
+    };
+    if (spec.headers) {
+      result.headers = spec.headers;
+    }
+  } else {
+    result = convertFromCodexFormat(spec);
+  }
+
+  return copyCommonMcpFields(spec, result);
+}
+
+function syncToOmpMcpConfig(server) {
+  validateOmpServerName(server.id);
+  const config = readOmpMcpConfig();
+  config.mcpServers[server.id] = convertToOmpMcpFormat(server.server);
+  writeJsonFile(PI_MCP_CONFIG_PATH, config);
+}
+
+function removeFromOmpMcpConfig(serverId) {
+  const config = readOmpMcpConfig();
+  if (config.mcpServers && config.mcpServers[serverId]) {
+    delete config.mcpServers[serverId];
+    writeJsonFile(PI_MCP_CONFIG_PATH, config);
+  }
+}
+
 // ============================================================================
 // OpenCode 配置同步
 // ============================================================================
@@ -1108,6 +1231,9 @@ async function importFromPlatform(platform) {
     case 'opencode':
       importedCount = importFromOpenCode(servers);
       break;
+    case 'pi':
+      importedCount = importFromOmp(servers);
+      break;
     default:
       throw new Error(`无效的平台: ${platform}`);
   }
@@ -1250,6 +1376,39 @@ function importFromOpenCode(servers) {
   return count;
 }
 
+/**
+ * 从 OMP 导入
+ */
+function importFromOmp(servers) {
+  const config = readOmpMcpConfig();
+  const mcpServers = config.mcpServers || {};
+  let count = 0;
+
+  for (const [id, spec] of Object.entries(mcpServers)) {
+    const convertedSpec = convertFromOmpMcpFormat(spec || {});
+
+    if (servers[id]) {
+      servers[id].apps = normalizeServerApps(servers[id].apps);
+      if (!servers[id].apps.pi) {
+        servers[id].apps.pi = true;
+        count++;
+      }
+    } else {
+      servers[id] = {
+        id,
+        name: id,
+        server: convertedSpec,
+        apps: { claude: false, codex: false, gemini: false, opencode: false, pi: true },
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      count++;
+    }
+  }
+
+  return count;
+}
+
 /**
  * 从 Codex 格式转换
  */
@@ -1311,7 +1470,8 @@ function getStats() {
     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
+    opencode: serverList.filter(s => s.apps?.opencode).length,
+    pi: serverList.filter(s => s.apps?.pi).length
   };
 }
 
@@ -1763,7 +1923,7 @@ function updateServerOrder(serverIds) {
 
 /**
  * 导出所有 MCP 配置
- * @param {string} format - 导出格式: 'json' | 'claude' | 'codex' | 'opencode' | 'gemini'
+ * @param {string} format - 导出格式: 'json' | 'claude' | 'codex' | 'opencode' | 'gemini' | 'pi'
  */
 function exportServers(format = 'json') {
   const servers = getAllServers();
@@ -1777,6 +1937,8 @@ function exportServers(format = 'json') {
       return exportForOpenCode(servers);
     case 'gemini':
       return exportForGemini(servers);
+    case 'pi':
+      return exportForOmp(servers);
     case 'json':
     default:
       return exportAsJson(servers);
@@ -1876,6 +2038,26 @@ function exportForGemini(servers) {
   };
 }
 
+/**
+ * 导出为 OMP 格式
+ */
+function exportForOmp(servers) {
+  const mcpServers = {};
+
+  for (const [id, server] of Object.entries(servers)) {
+    if (server.apps?.pi) {
+      validateOmpServerName(id);
+      mcpServers[id] = convertToOmpMcpFormat(server.server);
+    }
+  }
+
+  return {
+    format: 'pi',
+    content: JSON.stringify({ $schema: OMP_MCP_SCHEMA_URL, mcpServers }, null, 2),
+    filename: 'omp-mcp-config.json'
+  };
+}
+
 module.exports = {
   getAllServers,
   getServer,
@@ -1895,6 +2077,8 @@ module.exports = {
   exportServers,
   _test: {
     extractMcpHint,
-    buildMcpFailureResult
+    buildMcpFailureResult,
+    convertToOmpMcpFormat,
+    convertFromOmpMcpFormat
   }
 };

package/src/server/services/pi-auth-providers.js

@@ -0,0 +1,294 @@
+const { spawnSync } = require('child_process');
+const piConfig = require('./pi-config');
+
+const COMMAND_TIMEOUT_MS = 5000;
+const TOKEN_LIST_TIMEOUT_MS = 3000;
+const CACHE_TTL_MS = 15000;
+
+const LOGIN_PROVIDER_IDS = new Set([
+  'openai-codex',
+  'openai-codex-device',
+  'anthropic',
+  'github-copilot',
+  'cursor',
+  'devin',
+  'google-antigravity',
+  'google-gemini-cli',
+  'xai-oauth',
+  'gitlab-duo',
+  'gitlab-duo-agent',
+  'alibaba-coding-plan',
+  'zhipu-coding-plan',
+  'kimi-code',
+  'zai',
+  'qwen-portal',
+  'minimax-code',
+  'minimax-code-cn',
+  'perplexity'
+]);
+
+const ACCOUNT_CHECK_PROVIDER_IDS = new Set([
+  'openai-codex',
+  'openai-codex-device',
+  'anthropic',
+  'google-gemini-cli',
+  'github-copilot'
+]);
+
+const PROVIDER_ALIASES = {
+  codex: 'openai-codex',
+  openai: 'openai-codex',
+  'openai-codex': 'openai-codex',
+  'openai-codex-device': 'openai-codex-device',
+  claude: 'anthropic',
+  anthropic: 'anthropic',
+  gemini: 'google-gemini-cli',
+  'gemini-cli': 'google-gemini-cli',
+  'google-gemini-cli': 'google-gemini-cli',
+  copilot: 'github-copilot',
+  'github-copilot': 'github-copilot'
+};
+
+let snapshotCache = {};
+
+function normalizeProviderId(value = '') {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+function resolveProviderAlias(value = '') {
+  const id = normalizeProviderId(value);
+  return PROVIDER_ALIASES[id] || id;
+}
+
+function normalizeCommandOutput(value) {
+  if (value === undefined || value === null) return '';
+  return Buffer.isBuffer(value) ? value.toString('utf8') : String(value);
+}
+
+function sanitizeIdentity(value = '') {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  return text
+    .replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, (email) => {
+      const [name, domain] = email.split('@');
+      if (!name || !domain) return '***';
+      const visible = name.length <= 2 ? `${name[0] || '*'}***` : `${name.slice(0, 2)}***${name.slice(-1)}`;
+      return `${visible}@${domain}`;
+    })
+    .replace(/sk-[A-Za-z0-9_-]{8,}/g, 'sk-***')
+    .replace(/nvapi-[A-Za-z0-9_-]{8,}/g, 'nvapi-***')
+    .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Bearer ***')
+    .replace(/[A-Za-z0-9_-]{24,}\.[A-Za-z0-9_-]{12,}\.[A-Za-z0-9_-]{12,}/g, 'jwt.***')
+    .replace(/[A-Za-z0-9_=-]{32,}/g, '***');
+}
+
+function runCommand(command, args = [], options = {}) {
+  const runner = options.commandRunner || spawnSync;
+  const result = runner(command, args, {
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      ...(options.env || {})
+    },
+    timeout: options.timeout || COMMAND_TIMEOUT_MS
+  });
+  if (typeof result === 'string' || Buffer.isBuffer(result)) {
+    return { status: 0, stdout: normalizeCommandOutput(result), stderr: '' };
+  }
+  return result || { status: 0, stdout: '', stderr: '' };
+}
+
+function parseJsonCommand(command, args, options = {}) {
+  const result = runCommand(command, args, options);
+  const status = result.status === undefined || result.status === null ? 0 : result.status;
+  const stdout = normalizeCommandOutput(result.stdout).trim();
+  const stderr = normalizeCommandOutput(result.stderr).trim();
+  if (result.error) {
+    return { ok: false, status, error: result.error.message, stderr };
+  }
+  if (!stdout) {
+    return { ok: status === 0, status, value: null, stderr };
+  }
+  try {
+    return { ok: status === 0, status, value: JSON.parse(stdout), stderr };
+  } catch (error) {
+    return { ok: false, status, error: error.message, stderr };
+  }
+}
+
+function parseAccountLine(line = '', index) {
+  const sanitized = sanitizeIdentity(line)
+    .replace(/^\s*[-*]\s*/, '')
+    .replace(/^\s*\[?\d+\]?\s*[:.)-]?\s*/, '')
+    .trim();
+  if (!sanitized || /^no oauth accounts found/i.test(sanitized)) return null;
+  return {
+    index: index + 1,
+    identity: sanitized
+  };
+}
+
+function listProviderAccounts(command, providerId, options = {}) {
+  const result = runCommand(command, ['token', providerId, '--list'], {
+    ...options,
+    timeout: options.tokenListTimeout || TOKEN_LIST_TIMEOUT_MS
+  });
+  const status = result.status === undefined || result.status === null ? 0 : result.status;
+  const stdout = normalizeCommandOutput(result.stdout);
+  const stderr = normalizeCommandOutput(result.stderr);
+  const combined = `${stdout}\n${stderr}`;
+
+  if (result.error) {
+    return { checked: true, loggedIn: false, accountCount: 0, accounts: [], error: result.error.message };
+  }
+
+  const accounts = stdout
+    .split(/\r?\n/)
+    .map((line, index) => parseAccountLine(line, index))
+    .filter(Boolean);
+
+  const noAccounts = /no oauth accounts found/i.test(combined);
+  return {
+    checked: true,
+    loggedIn: accounts.length > 0,
+    accountCount: accounts.length,
+    accounts,
+    error: status !== 0 && !noAccounts && accounts.length === 0
+      ? sanitizeIdentity(stderr || stdout || `exit code ${status}`)
+      : null
+  };
+}
+
+function isLikelyLoginProvider(provider = {}) {
+  const id = normalizeProviderId(provider.id);
+  const name = String(provider.name || '').toLowerCase();
+  return LOGIN_PROVIDER_IDS.has(id)
+    || id.includes('oauth')
+    || id.includes('codex')
+    || id.includes('copilot')
+    || id.includes('gemini-cli')
+    || name.includes('subscription')
+    || name.includes('coding plan')
+    || name.includes('token plan')
+    || name.includes('claude pro')
+    || name.includes('chatgpt plus')
+    || name.includes('chatgpt pro');
+}
+
+function normalizeProvider(provider = {}) {
+  const id = normalizeProviderId(provider.id);
+  return {
+    id,
+    name: String(provider.name || provider.id || id),
+    loginCapable: isLikelyLoginProvider(provider)
+  };
+}
+
+function buildEmptySnapshot(runtime, reason) {
+  return {
+    available: false,
+    reason,
+    runtime,
+    brokerStatus: null,
+    gatewayStatus: null,
+    providers: [],
+    supportedProviders: [],
+    aliases: { ...PROVIDER_ALIASES },
+    checkedAt: new Date().toISOString()
+  };
+}
+
+function getOmpAuthProviderSnapshot(options = {}) {
+  const now = Date.now();
+  const cacheKey = options.accountCheck === false
+    ? (options.includeStatus === false ? 'metadata' : 'metadata-status')
+    : 'full';
+  const cached = snapshotCache[cacheKey];
+  if (!options.forceRefresh && cached && now - cached.loadedAt < CACHE_TTL_MS) {
+    return cached.value;
+  }
+
+  const env = options.env || process.env;
+  const runtime = options.runtime || piConfig.resolvePiRuntime(env, options.runtimeOptions || {});
+  if (!runtime || runtime.runtime !== 'omp' || !runtime.installed) {
+    const value = buildEmptySnapshot(runtime || null, 'omp-not-available');
+    snapshotCache[cacheKey] = { loadedAt: now, value };
+    return value;
+  }
+
+  const command = runtime.command;
+  const listResult = parseJsonCommand(command, ['auth-broker', 'list', '--json'], options);
+  if (!listResult.ok || !Array.isArray(listResult.value)) {
+    const value = buildEmptySnapshot(runtime, listResult.error || listResult.stderr || 'auth-provider-list-failed');
+    snapshotCache[cacheKey] = { loadedAt: now, value };
+    return value;
+  }
+
+  const supportedProviders = listResult.value
+    .map(normalizeProvider)
+    .filter(provider => provider.id);
+  const loginProviders = supportedProviders
+    .filter(provider => provider.loginCapable)
+    .map(provider => {
+      if (options.accountCheck === false || !ACCOUNT_CHECK_PROVIDER_IDS.has(provider.id)) {
+        return {
+          ...provider,
+          checked: false,
+          loggedIn: null,
+          accountCount: null,
+          accounts: [],
+          error: null
+        };
+      }
+      return {
+        ...provider,
+        ...listProviderAccounts(command, provider.id, options)
+      };
+    });
+
+  const brokerStatus = options.includeStatus === false
+    ? { value: null }
+    : parseJsonCommand(command, ['auth-broker', 'status', '--json'], options);
+  const gatewayStatus = options.includeStatus === false
+    ? { value: null }
+    : parseJsonCommand(command, ['auth-gateway', 'status', '--json'], options);
+
+  const value = {
+    available: true,
+    runtime,
+    brokerStatus: brokerStatus.value || null,
+    gatewayStatus: gatewayStatus.value || null,
+    providers: loginProviders,
+    supportedProviders,
+    aliases: { ...PROVIDER_ALIASES },
+    checkedAt: new Date().toISOString()
+  };
+  snapshotCache[cacheKey] = { loadedAt: now, value };
+  return value;
+}
+
+function findAuthProviderForKey(providerKey, snapshot) {
+  const resolved = resolveProviderAlias(providerKey);
+  const providers = Array.isArray(snapshot?.providers) ? snapshot.providers : [];
+  return providers.find(provider => provider.id === resolved) || null;
+}
+
+function clearOmpAuthProviderCache() {
+  snapshotCache = {};
+}
+
+module.exports = {
+  LOGIN_PROVIDER_IDS,
+  ACCOUNT_CHECK_PROVIDER_IDS,
+  clearOmpAuthProviderCache,
+  findAuthProviderForKey,
+  getOmpAuthProviderSnapshot,
+  normalizeProviderId,
+  resolveProviderAlias,
+  sanitizeIdentity
+};