MCP 集成

// connectToServer: 根据配置选择传输协议并连接
async function connectToServer(
  config: McpServerConfig
): Promise<McpClient> {
  let transport: Transport;

  switch (config.transport) {
    case 'stdio':
      transport = new StdioClientTransport({
        command: config.command,
        args: config.args || [],
        env: config.env
      });
      break;
    case 'sse':
      transport = new SSEClientTransport(
        new URL(config.url),
        { headers: config.headers }
      );
      break;
    case 'streamable-http':
      transport = new StreamableHTTPClientTransport(
        new URL(config.url)
      );
      break;
    case 'websocket':
      transport = new WebSocketTransport(config.url);
      break;
    default:
      throw new Error(
        'Unsupported transport: ' + config.transport
      );
  }

  const client = new McpClient();
  await client.connect(transport);
  return client;
}

// fetchToolsForClient: MCP 工具转换为内部格式
async function fetchToolsForClient(
  client: McpClient,
  serverName: string
): Promise<Tool[]> {
  const mcpTools = await client.listTools();
  return mcpTools.map(tool => ({
    name: serverName + ':' + tool.name,
    description: tool.description,
    inputSchema: tool.inputSchema,
    // MCPTool 包装器处理实际调用
    execute: async (input) => {
      return client.callTool(tool.name, input);
    }
  }));
}

// parseMcpConfig: 解析单个 MCP 配置
function parseMcpConfig(
  raw: Record<string, unknown>
): McpServerConfig {
  return {
    name: String(raw.name),
    transport: raw.transport as TransportType || 'stdio',
    command: raw.command as string,
    args: (raw.args as string[]) || [],
    env: raw.env as Record<string, string>,
    url: raw.url as string,
    headers: raw.headers as Record<string, string>,
    authType: raw.authType as string
  };
}

// getClaudeCodeMcpConfigs: 聚合所有来源的配置
async function getClaudeCodeMcpConfigs(): Promise<
  McpServerConfig[]
> {
  const configs: McpServerConfig[] = [];

  // 1. 项目级 .mcp.json
  const projectConfig = await loadJsonFile(
    '.mcp.json'
  );
  if (projectConfig?.mcpServers) {
    for (const [name, cfg] of
      Object.entries(projectConfig.mcpServers)
    ) {
      configs.push(parseMcpConfig({ name, ...cfg }));
    }
  }

  // 2. 用户全局配置
  const userConfig = await loadUserMcpConfig();
  configs.push(...userConfig);

  // 3. 企业管理员配置
  const enterpriseConfig = await loadEnterpriseMcpConfig();
  configs.push(...enterpriseConfig);

  // 4. 策略过滤
  return filterMcpServersByPolicy(configs);
}

// filterMcpServersByPolicy: 企业策略过滤
function filterMcpServersByPolicy(
  configs: McpServerConfig[]
): McpServerConfig[] {
  const policy = getOrganizationPolicy();
  if (!policy?.mcpAllowlist) return configs;

  return configs.filter(c =>
    policy.mcpAllowlist.includes(c.name) ||
    policy.mcpAllowlist.includes('*')
  );
}

// OAuth 认证流程
async function handleMcpAuth(
  serverConfig: McpServerConfig
): Promise<string> {
  if (serverConfig.authType !== 'oauth') {
    return '';
  }

  // 检查缓存的 token
  const cached = await getTokenCache(serverConfig.name);
  if (cached && !isTokenExpired(cached)) {
    return cached.accessToken;
  }

  // 发起 OAuth 流程
  const authUrl = buildAuthUrl({
    clientId: serverConfig.oauth?.clientId,
    redirectUri: 'http://localhost:' + getRandomPort(),
    scope: serverConfig.oauth?.scope || 'read'
  });

  // 启动本地服务器接收回调
  const code = await waitForAuthCallback(authUrl);

  // 交换 access token
  const token = await exchangeCodeForToken(
    code, serverConfig
  );
  await setTokenCache(serverConfig.name, token);
  return token.accessToken;
}

// 自定义错误层次结构
class McpAuthError extends Error {
  constructor(serverName: string, detail: string) {
    super('MCP Auth Error [' + serverName + ']: ' + detail);
    this.name = 'McpAuthError';
  }
}

class McpSessionExpiredError extends Error {
  constructor(serverName: string) {
    super('MCP session expired: ' + serverName);
    this.name = 'McpSessionExpiredError';
  }
}

class McpToolCallError extends Error {
  public readonly toolName: string;
  public readonly retryable: boolean;

  constructor(
    toolName: string,
    message: string,
    retryable: boolean = false
  ) {
    super('MCP tool call failed [' + toolName + ']: '
      + message);
    this.name = 'McpToolCallError';
    this.toolName = toolName;
    this.retryable = retryable;
  }
}