@agentdevjs/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1254 @@
+// src/types.ts
+var MCPConnectionState = /* @__PURE__ */ ((MCPConnectionState2) => {
+  MCPConnectionState2["Disconnected"] = "disconnected";
+  MCPConnectionState2["Connecting"] = "connecting";
+  MCPConnectionState2["Connected"] = "connected";
+  MCPConnectionState2["Error"] = "error";
+  return MCPConnectionState2;
+})(MCPConnectionState || {});
+
+// src/connection-manager.ts
+import {
+  Client,
+  SSEClientTransport,
+  StreamableHTTPClientTransport
+} from "@modelcontextprotocol/client";
+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
+import { createLogger } from "@agentdevjs/core";
+var MCPConnectionManager = class {
+  connections = /* @__PURE__ */ new Map();
+  reconnectTimers = /* @__PURE__ */ new Map();
+  logger = createLogger("mcp.connection");
+  /**
+   * 连接到 MCP 服务器
+   */
+  async connectServer(name, config) {
+    const existing = this.connections.get(name);
+    if (existing?.server && existing.state === "connected" /* Connected */) {
+      return existing.server;
+    }
+    const connection = {
+      name,
+      config,
+      state: "connecting" /* Connecting */,
+      reconnectAttempts: 0,
+      responseBuffer: "",
+      nextRequestId: 1,
+      toolCount: 0,
+      allowReconnect: true,
+      pendingRequests: /* @__PURE__ */ new Map()
+    };
+    this.connections.set(name, connection);
+    try {
+      if (config.transport === "stdio") {
+        return await this.connectStdio(name, config, connection);
+      } else if (config.transport === "sse") {
+        return await this.connectSSE(name, config, connection);
+      } else {
+        return await this.connectHTTP(name, config, connection);
+      }
+    } catch (error) {
+      connection.state = "error" /* Error */;
+      connection.lastError = error instanceof Error ? error.message : String(error);
+      throw error;
+    }
+  }
+  /**
+   * 连接到 stdio MCP 服务器
+   */
+  async connectStdio(name, config, connection) {
+    const client = new Client({
+      name: `agentdev-${name}`,
+      version: "0.1.0"
+    });
+    const transport = new StdioClientTransport({
+      command: config.command,
+      args: config.args,
+      env: config.env,
+      cwd: config.cwd,
+      stderr: "pipe"
+    });
+    await client.connect(transport);
+    client.onerror = (error) => {
+      connection.state = "error" /* Error */;
+      connection.lastError = error.message;
+      this.log("error", `MCP server ${name} client error: ${error.message}`);
+    };
+    transport.onclose = () => {
+      this.log(
+        connection.allowReconnect ? "warn" : "info",
+        `MCP server ${name} stdio transport closed`
+      );
+      connection.state = "disconnected" /* Disconnected */;
+      this.rejectAllPendingRequests(connection, new Error(`MCP server ${name} disconnected`));
+      if (connection.allowReconnect) {
+        this.scheduleReconnect(name);
+      }
+    };
+    connection.transport = transport;
+    connection.server = client;
+    connection.state = "connected" /* Connected */;
+    connection.connectedAt = Date.now();
+    connection.lastError = void 0;
+    connection.reconnectAttempts = 0;
+    this.log("info", `Connected to MCP server ${name} (stdio)`);
+    return client;
+  }
+  /**
+   * 连接到 HTTP MCP 服务器
+   */
+  async connectSSE(name, config, connection) {
+    const client = new Client({
+      name: `agentdev-${name}`,
+      version: "0.1.0"
+    });
+    const transport = config.headers ? new SSEClientTransport(new URL(config.url), {
+      eventSourceInit: { headers: config.headers },
+      requestInit: { headers: config.headers }
+    }) : new SSEClientTransport(new URL(config.url));
+    await client.connect(transport);
+    client.onerror = (error) => {
+      connection.state = "error" /* Error */;
+      connection.lastError = error.message;
+      this.log("error", `MCP server ${name} client error: ${error.message}`);
+    };
+    transport.onerror = (error) => {
+      connection.state = "error" /* Error */;
+      connection.lastError = error.message;
+      this.log("error", `MCP server ${name} SSE transport error: ${error.message}`);
+    };
+    transport.onclose = () => {
+      this.log(
+        connection.allowReconnect ? "warn" : "info",
+        `MCP server ${name} SSE transport closed`
+      );
+      connection.state = "disconnected" /* Disconnected */;
+      this.rejectAllPendingRequests(connection, new Error(`MCP server ${name} disconnected`));
+      if (connection.allowReconnect) {
+        this.scheduleReconnect(name);
+      }
+    };
+    connection.transport = transport;
+    connection.server = client;
+    connection.state = "connected" /* Connected */;
+    connection.connectedAt = Date.now();
+    connection.lastError = void 0;
+    connection.reconnectAttempts = 0;
+    this.log("info", `Connected to MCP server ${name} (sse)`);
+    return client;
+  }
+  /**
+   * 连接到 HTTP MCP 服务器
+   */
+  async connectHTTP(name, config, connection) {
+    const client = new Client({
+      name: `agentdev-${name}`,
+      version: "0.1.0"
+    });
+    const transport = new StreamableHTTPClientTransport(new URL(config.url), {
+      ...config.headers ? { requestInit: { headers: config.headers } } : {},
+      reconnectionOptions: {
+        maxRetries: config.retryCount ?? 3,
+        initialReconnectionDelay: 1e3,
+        maxReconnectionDelay: 3e4,
+        reconnectionDelayGrowFactor: 1.5
+      }
+    });
+    await client.connect(transport);
+    client.onerror = (error) => {
+      connection.state = "error" /* Error */;
+      connection.lastError = error.message;
+      this.log("error", `MCP server ${name} client error: ${error.message}`);
+    };
+    transport.onerror = (error) => {
+      connection.state = "error" /* Error */;
+      connection.lastError = error.message;
+      this.log("error", `MCP server ${name} HTTP transport error: ${error.message}`);
+    };
+    transport.onclose = () => {
+      this.log(
+        connection.allowReconnect ? "warn" : "info",
+        `MCP server ${name} HTTP transport closed`
+      );
+      connection.state = "disconnected" /* Disconnected */;
+      this.rejectAllPendingRequests(connection, new Error(`MCP server ${name} disconnected`));
+      if (connection.allowReconnect) {
+        this.scheduleReconnect(name);
+      }
+    };
+    connection.transport = transport;
+    connection.server = client;
+    connection.state = "connected" /* Connected */;
+    connection.connectedAt = Date.now();
+    connection.lastError = void 0;
+    connection.reconnectAttempts = 0;
+    this.log("info", `Connected to MCP server ${name} (http)`);
+    return client;
+  }
+  /**
+   * 断开服务器连接
+   */
+  async disconnectServer(name) {
+    const connection = this.connections.get(name);
+    if (!connection) return;
+    connection.allowReconnect = false;
+    const timer = this.reconnectTimers.get(name);
+    if (timer) {
+      clearTimeout(timer);
+      this.reconnectTimers.delete(name);
+    }
+    if (connection.transport?.close) {
+      try {
+        await connection.transport.close();
+      } catch (error) {
+        this.log("warn", `Error closing MCP transport ${name}: ${error}`);
+      }
+    }
+    if (connection.process) {
+      await this.stopProcess(connection.process);
+    }
+    this.rejectAllPendingRequests(connection, new Error(`MCP server ${name} disconnected`));
+    this.connections.delete(name);
+    this.log("info", `Disconnected MCP server ${name}`);
+  }
+  /**
+   * 断开所有连接
+   */
+  async disconnectAll() {
+    const names = Array.from(this.connections.keys());
+    await Promise.all(names.map((name) => this.disconnectServer(name)));
+  }
+  /**
+   * 列出服务器的所有工具
+   */
+  async listTools(name) {
+    const connection = this.connections.get(name);
+    if (!connection || connection.state !== "connected" /* Connected */) {
+      this.log("warn", `[MCP] Cannot list tools: ${name} not connected`);
+      return [];
+    }
+    try {
+      const isDirectProcess = connection.process && connection.server && !connection.server.request;
+      if (isDirectProcess) {
+        this.log("info", `[MCP] Using direct process communication for ${name}`);
+        const response2 = await this.sendDirectRequest(connection, "tools/list", {}, 3e5);
+        const tools2 = response2.result?.tools || [];
+        connection.toolCount = tools2.length;
+        this.log("info", `[MCP] Received ${tools2.length} tools`);
+        return tools2;
+      }
+      const response = await connection.server.listTools(
+        void 0,
+        { timeout: 3e5 }
+      );
+      const tools = response.tools || [];
+      connection.toolCount = tools.length;
+      return tools;
+    } catch (error) {
+      this.log("error", `[MCP] Failed to list tools from ${name}: ${error}`);
+      return [];
+    }
+  }
+  async callTool(name, serverName, args) {
+    this.log("info", `[MCP] callTool: ${serverName}:${name}`);
+    this.log("debug", `[MCP] args: ${JSON.stringify(args)}`);
+    const connection = this.connections.get(serverName);
+    if (!connection || connection.state !== "connected" /* Connected */) {
+      throw new Error(`MCP server ${serverName} not connected`);
+    }
+    try {
+      const isDirectProcess = connection.process && connection.server && !connection.server.request;
+      if (isDirectProcess) {
+        this.log("info", `[MCP] Using direct process communication for tool call`);
+        const response2 = await this.sendDirectRequest(connection, "tools/call", {
+          name,
+          arguments: args
+        }, 3e5);
+        const result = this.normalizeToolCallResponse(response2);
+        this.log("info", `[MCP] Tool ${name} returned: ${result.isError ? "ERROR" : "OK"}`);
+        return result;
+      }
+      const response = await connection.server.callTool(
+        { name, arguments: args },
+        { timeout: 3e5 }
+      );
+      return this.normalizeToolCallResponse(response);
+    } catch (error) {
+      this.log("error", `[MCP] Failed to call tool ${name}: ${error}`);
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }],
+        isError: true
+      };
+    }
+  }
+  getConnectionInfo(name) {
+    const connection = this.connections.get(name);
+    if (!connection) return void 0;
+    return {
+      name: connection.name,
+      state: connection.state,
+      connectedAt: connection.connectedAt,
+      lastError: connection.lastError,
+      toolCount: connection.toolCount
+    };
+  }
+  /**
+   * 获取所有连接信息
+   */
+  getAllConnections() {
+    return Array.from(this.connections.keys()).map((name) => this.getConnectionInfo(name)).filter((info) => info !== void 0);
+  }
+  /**
+   * 检查连接状态
+   */
+  isConnected(name) {
+    const connection = this.connections.get(name);
+    return connection?.state === "connected" /* Connected */;
+  }
+  /**
+   * 获取服务器实例
+   */
+  getServer(name) {
+    return this.connections.get(name)?.server;
+  }
+  /**
+   * 安排重连
+   */
+  scheduleReconnect(name) {
+    const existingTimer = this.reconnectTimers.get(name);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    const timer = setTimeout(async () => {
+      const connection = this.connections.get(name);
+      if (!connection) return;
+      if (connection.reconnectAttempts >= 3) {
+        this.log("error", `Max reconnect attempts reached for MCP server ${name}`);
+        return;
+      }
+      connection.reconnectAttempts++;
+      this.log("info", `Reconnecting to MCP server ${name} (attempt ${connection.reconnectAttempts})`);
+      try {
+        await this.connectServer(name, connection.config);
+      } catch (error) {
+        this.log("error", `Failed to reconnect to MCP server ${name}: ${error}`);
+      }
+    }, 5e3);
+    this.reconnectTimers.set(name, timer);
+  }
+  /**
+   * 日志输出
+   */
+  log(level, message) {
+    this.logger.child({
+      tags: ["mcp-connection"]
+    })[level](message);
+  }
+  handleProcessOutput(connection, chunk) {
+    connection.responseBuffer += chunk;
+    const lines = connection.responseBuffer.split(/\r?\n/);
+    connection.responseBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const response = JSON.parse(trimmed);
+        this.handleDirectResponse(connection, response);
+      } catch {
+        connection.responseBuffer = `${trimmed}
+${connection.responseBuffer}`;
+        return;
+      }
+    }
+  }
+  handleDirectResponse(connection, response) {
+    if (typeof response?.id !== "number") {
+      this.log("debug", `[MCP] Ignoring non-response message from ${connection.name}: ${JSON.stringify(response)}`);
+      return;
+    }
+    const pending = connection.pendingRequests.get(response.id);
+    if (!pending) {
+      this.log("debug", `[MCP] No pending request for response id ${response.id} from ${connection.name}`);
+      return;
+    }
+    clearTimeout(pending.timeout);
+    connection.pendingRequests.delete(response.id);
+    pending.resolve(response);
+  }
+  async sendDirectRequest(connection, method, params, timeoutMs) {
+    if (!connection.process?.stdin) {
+      throw new Error(`MCP server ${connection.name} has no stdin`);
+    }
+    const requestId = connection.nextRequestId++;
+    const request = {
+      jsonrpc: "2.0",
+      id: requestId,
+      method,
+      params
+    };
+    this.log("debug", `[MCP] Sending direct request: ${JSON.stringify(request)}`);
+    return await new Promise((resolve2, reject) => {
+      const timeout = setTimeout(() => {
+        connection.pendingRequests.delete(requestId);
+        reject(new Error(`Timeout waiting for ${method} from ${connection.name}`));
+      }, timeoutMs);
+      connection.pendingRequests.set(requestId, { resolve: resolve2, reject, timeout });
+      try {
+        connection.process.stdin.write(JSON.stringify(request) + "\n");
+      } catch (error) {
+        clearTimeout(timeout);
+        connection.pendingRequests.delete(requestId);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  normalizeToolCallResponse(response) {
+    if (response.error) {
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${response.error.message || "Unknown error"}`
+        }],
+        isError: true
+      };
+    }
+    if (response.result) {
+      return response.result;
+    }
+    if (response.content || response.structuredContent || response.toolResult) {
+      return response;
+    }
+    return { content: [] };
+  }
+  rejectAllPendingRequests(connection, error) {
+    for (const [requestId, pending] of connection.pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(error);
+      connection.pendingRequests.delete(requestId);
+    }
+  }
+  async stopProcess(process2) {
+    try {
+      process2.stdin?.end();
+    } catch {
+    }
+    try {
+      process2.stdout?.destroy();
+    } catch {
+    }
+    if (process2.exitCode !== null || process2.signalCode !== null) {
+      return;
+    }
+    await new Promise((resolve2) => {
+      const timeout = setTimeout(resolve2, 1500);
+      process2.once("exit", () => {
+        clearTimeout(timeout);
+        resolve2();
+      });
+      try {
+        process2.kill();
+      } catch {
+        clearTimeout(timeout);
+        resolve2();
+      }
+    });
+  }
+  async dispose() {
+    await this.disconnectAll();
+    for (const timer of this.reconnectTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.reconnectTimers.clear();
+  }
+};
+
+// src/gateway-client.ts
+async function discoverGatewayServers(origin, timeoutMs = 3e3) {
+  const gatewayOrigin = origin || process.env.PROTOCLAW_SERVER_ORIGIN;
+  if (!gatewayOrigin) {
+    return { origin: "", servers: [] };
+  }
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const res = await fetch(`${gatewayOrigin}/protoclaw/mcp-gateway/servers`, {
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!res.ok) {
+      return { origin: gatewayOrigin, servers: [] };
+    }
+    const data = await res.json();
+    const servers = Array.isArray(data.servers) ? data.servers : [];
+    return {
+      origin: gatewayOrigin,
+      servers: servers.filter((s) => s.toolCount > 0)
+    };
+  } catch {
+    return { origin: gatewayOrigin || "", servers: [] };
+  }
+}
+function gatewayServersToConfig(discovery, excludeServers) {
+  const servers = {};
+  for (const server of discovery.servers) {
+    if (excludeServers?.includes(server.id)) {
+      continue;
+    }
+    servers[server.id] = {
+      transport: "http",
+      url: server.url
+    };
+  }
+  return servers;
+}
+
+// src/mcp-adapter.ts
+var MCPToolAdapter = class {
+  constructor(registeredTool, config) {
+    this.registeredTool = registeredTool;
+    this.config = config;
+    this.name = registeredTool.name;
+    this.description = registeredTool.description || `MCP tool: ${registeredTool.name}`;
+    this.parameters = this.extractParameters(registeredTool);
+    this.render = {
+      call: config.render?.call || "mcp-tool",
+      result: config.render?.result || "mcp-result"
+    };
+  }
+  registeredTool;
+  config;
+  name;
+  description;
+  parameters;
+  render;
+  /**
+   * 执行 MCP 工具
+   */
+  async execute(args, context) {
+    const startTime = Date.now();
+    try {
+      const handler = this.registeredTool.handler;
+      const result = await handler?.(args, context);
+      const duration = Date.now() - startTime;
+      return this.formatResult(result, duration);
+    } catch (error) {
+      return this.formatError(error, Date.now() - startTime);
+    }
+  }
+  /**
+   * 格式化 MCP 工具结果
+   */
+  formatResult(result, duration) {
+    if (result && result.isError) {
+      return {
+        success: false,
+        error: (result.content || []).map((c) => c.text || "").join("\n"),
+        server: this.config.serverName,
+        duration
+      };
+    }
+    const textContent = result.content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
+    const formatted = {
+      content: textContent,
+      server: this.config.serverName,
+      duration
+    };
+    if (result.structuredContent) {
+      formatted.structuredContent = result.structuredContent;
+    }
+    const images = result.content.filter((c) => c.type === "image");
+    if (images.length > 0) {
+      formatted.images = images.map((c) => ({
+        data: c.data,
+        mimeType: c.mimeType
+      }));
+    }
+    const resources = result.content.filter((c) => c.type === "resource");
+    if (resources.length > 0) {
+      formatted.resources = resources.map((c) => ({
+        uri: c.uri,
+        mimeType: c.mimeType,
+        text: c.text
+      }));
+    }
+    return formatted;
+  }
+  /**
+   * 格式化错误
+   */
+  formatError(error, duration) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `[MCP Error] ${errorMessage}`,
+      server: this.config.serverName,
+      duration
+    };
+  }
+  /**
+   * 从 RegisteredToolLike 提取参数定义
+   *
+   * MCP 工具的 inputSchema 已经是 JSON Schema 格式
+   * 直接返回，不需要转换
+   */
+  extractParameters(tool) {
+    if (!tool.inputSchema) return void 0;
+    try {
+      const schema = tool.inputSchema;
+      if (typeof schema === "object" && schema.type === "object") {
+        return schema;
+      }
+      console.warn(`[MCPToolAdapter] Unexpected inputSchema format for ${tool.name}:`, typeof schema);
+      return void 0;
+    } catch (error) {
+      console.warn(`[MCPToolAdapter] Failed to extract parameters for ${tool.name}:`, error);
+      return void 0;
+    }
+  }
+};
+function createMCPToolAdapters(registeredTools, serverName, config) {
+  return registeredTools.map(
+    (tool) => new MCPToolAdapter(tool, {
+      serverName,
+      ...config
+    })
+  );
+}
+
+// src/client.ts
+function createDefaultMCPToolName(serverId, toolName) {
+  return `mcp_${serverId}_${toolName}`.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+var MCPClient = class {
+  constructor(serverId, config, manager) {
+    this.serverId = serverId;
+    this.config = config;
+    this.manager = manager ?? new MCPConnectionManager();
+  }
+  serverId;
+  config;
+  manager;
+  connected = false;
+  async connect() {
+    if (this.connected && this.manager.isConnected(this.serverId)) {
+      return;
+    }
+    await this.manager.connectServer(this.serverId, this.config);
+    this.connected = true;
+  }
+  async listTools() {
+    await this.connect();
+    return await this.manager.listTools(this.serverId);
+  }
+  async callTool(name, args) {
+    await this.connect();
+    return await this.manager.callTool(name, this.serverId, args);
+  }
+  getConnectionManager() {
+    return this.manager;
+  }
+  async dispose() {
+    this.connected = false;
+    await this.manager.disconnectServer(this.serverId);
+  }
+};
+function createMCPTool(client, tool, options = {}) {
+  return new MCPToolAdapter(
+    {
+      name: options.name ?? createDefaultMCPToolName(client.serverId, tool.name),
+      description: options.description ?? (tool.description || `MCP tool: ${tool.name}`),
+      inputSchema: tool.inputSchema,
+      enabled: true,
+      handler: async (args, context) => {
+        const finalArgs = options.transformArgs ? options.transformArgs(args, context) : args;
+        return await client.callTool(tool.name, finalArgs);
+      }
+    },
+    {
+      serverName: client.serverId,
+      render: options.render
+    }
+  );
+}
+async function createMCPToolsFromClient(client, options = {}) {
+  const tools = await client.listTools();
+  return tools.filter((tool) => options.filter ? options.filter(tool) : true).map((tool) => createMCPTool(client, tool, {
+    name: options.mapName?.(tool),
+    description: tool.description,
+    render: options.render,
+    transformArgs: options.transformArgs
+  }));
+}
+async function discoverMCPTools(serverId, config, options = {}, manager) {
+  const client = new MCPClient(serverId, config, manager);
+  const tools = await createMCPToolsFromClient(client, options);
+  return { client, tools };
+}
+
+// src/config.ts
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { basename } from "path";
+import { cwd } from "process";
+import { isAbsolute, join, resolve } from "path";
+function readConfigFile(configPath) {
+  try {
+    if (!existsSync(configPath)) {
+      return void 0;
+    }
+    const content = readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.warn(`[MCP] Failed to load config "${configPath}": ${errorMsg}`);
+    return void 0;
+  }
+}
+function normalizeServerConfig(server) {
+  if (!server.transport && typeof server.type === "string") {
+    return { ...server, transport: server.type };
+  }
+  return server;
+}
+function isMCPServerConfig(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const config = normalizeServerConfig(value);
+  if (config.transport === "stdio") {
+    return typeof config.command === "string" && Array.isArray(config.args);
+  }
+  if (config.transport === "http") {
+    return typeof config.url === "string";
+  }
+  if (config.transport === "sse") {
+    return typeof config.url === "string";
+  }
+  return false;
+}
+function isMCPConfig(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const config = value;
+  return !!config.servers && typeof config.servers === "object" || !!config.mcpServers && typeof config.mcpServers === "object";
+}
+function normalizeToMCPConfig(value, fallbackServerId) {
+  if (isMCPConfig(value)) {
+    const config = value;
+    const rawServers = config.servers ?? config.mcpServers;
+    if (!rawServers) {
+      return void 0;
+    }
+    const servers = {};
+    for (const [id, server] of Object.entries(rawServers)) {
+      if (server && typeof server === "object") {
+        servers[id] = normalizeServerConfig(server);
+      }
+    }
+    return { servers };
+  }
+  if (isMCPServerConfig(value)) {
+    return {
+      servers: {
+        [fallbackServerId]: value
+      }
+    };
+  }
+  return void 0;
+}
+function resolveMCPConfigInput(input, rootDir = cwd()) {
+  let configPath;
+  let fallbackServerId;
+  if (isAbsolute(input)) {
+    configPath = input;
+    fallbackServerId = basename(configPath, ".json");
+  } else if (input.includes("/") || input.includes("\\")) {
+    configPath = resolve(rootDir, input);
+    fallbackServerId = basename(configPath, ".json");
+  } else {
+    configPath = join(getDefaultMCPConfigDir(rootDir), `${input}.json`);
+    fallbackServerId = input;
+  }
+  return { configPath, fallbackServerId };
+}
+function loadMCPConfigFile(configPath, fallbackServerId) {
+  const config = readConfigFile(configPath);
+  if (!config) {
+    return void 0;
+  }
+  const normalized = normalizeToMCPConfig(config, fallbackServerId);
+  if (!normalized || Object.keys(normalized.servers).length === 0) {
+    console.warn(`[MCP] Ignoring invalid config file: ${configPath}`);
+    return void 0;
+  }
+  return normalized;
+}
+function getDedupedServerId(serverId, existingServerIds) {
+  if (!existingServerIds.has(serverId)) {
+    return serverId;
+  }
+  let suffix = 1;
+  let nextServerId = `${serverId} (${suffix})`;
+  while (existingServerIds.has(nextServerId)) {
+    suffix += 1;
+    nextServerId = `${serverId} (${suffix})`;
+  }
+  return nextServerId;
+}
+function mergeMCPConfig(merged, config, excludedServers) {
+  const existingServerIds = new Set(Object.keys(merged.servers));
+  for (const [serverId, serverConfig] of Object.entries(config.servers)) {
+    if (excludedServers.has(serverId)) {
+      continue;
+    }
+    const dedupedServerId = getDedupedServerId(serverId, existingServerIds);
+    merged.servers[dedupedServerId] = serverConfig;
+    existingServerIds.add(dedupedServerId);
+  }
+}
+function getDefaultMCPConfigDir(rootDir = cwd()) {
+  return join(rootDir, ".agentdev", "mcps");
+}
+function loadMCPConfigFromInput(input, rootDir = cwd()) {
+  const { configPath, fallbackServerId } = resolveMCPConfigInput(input, rootDir);
+  if (!existsSync(configPath)) {
+    console.warn(`[MCP] Config file does not exist: ${configPath}`);
+    return void 0;
+  }
+  return loadMCPConfigFile(configPath, fallbackServerId);
+}
+function loadAllMCPConfigs(rootDir = cwd(), options = {}) {
+  const shouldLoadDefaultDir = options.loadDefaultDir ?? true;
+  const extraConfigFiles = Array.isArray(options.extraConfigFiles) ? options.extraConfigFiles.filter(Boolean) : [];
+  const excludedServers = new Set(options.excludeServers ?? []);
+  const merged = { servers: {} };
+  if (shouldLoadDefaultDir) {
+    const configDir = getDefaultMCPConfigDir(rootDir);
+    if (existsSync(configDir)) {
+      const entries = readdirSync(configDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".json")) {
+          continue;
+        }
+        const configPath = join(configDir, entry.name);
+        const config = loadMCPConfigFile(configPath, basename(entry.name, ".json"));
+        if (!config) {
+          continue;
+        }
+        mergeMCPConfig(merged, config, excludedServers);
+      }
+    }
+  }
+  for (const configFile of extraConfigFiles) {
+    const config = loadMCPConfigFromInput(configFile, rootDir);
+    if (!config) {
+      continue;
+    }
+    mergeMCPConfig(merged, config, excludedServers);
+  }
+  return Object.keys(merged.servers).length > 0 ? merged : void 0;
+}
+
+// src/mount.ts
+function applyStaticPatch(tool, client, options) {
+  return {
+    enabled: !options.disable?.includes(tool.name),
+    name: options.rename?.[tool.name] ?? options.mapName?.(tool, client),
+    description: options.describe?.[tool.name],
+    render: options.toolRender?.[tool.name] ?? options.render,
+    transformArgs: options.transformArgs
+  };
+}
+function shouldIncludeTool(tool, options) {
+  if (options.include && !options.include.includes(tool.name)) {
+    return false;
+  }
+  if (options.exclude?.includes(tool.name)) {
+    return false;
+  }
+  return true;
+}
+function mergeToolPatch(base, override) {
+  if (override === false) {
+    return false;
+  }
+  if (!override) {
+    return base;
+  }
+  return {
+    ...base,
+    ...override,
+    render: override.render ?? base.render,
+    transformArgs: override.transformArgs ?? base.transformArgs
+  };
+}
+async function createManagedMCPToolsFromClient(client, options = {}) {
+  const tools = await client.listTools();
+  return tools.flatMap((tool) => {
+    if (!shouldIncludeTool(tool, options)) {
+      return [];
+    }
+    const staticPatch = applyStaticPatch(tool, client, options);
+    const finalPatch = mergeToolPatch(staticPatch, options.transform?.(tool, client));
+    if (finalPatch === false || finalPatch.enabled === false) {
+      return [];
+    }
+    return createMCPTool(
+      client,
+      {
+        ...tool,
+        description: finalPatch.description ?? tool.description
+      },
+      {
+        name: finalPatch.name ?? createDefaultMCPToolName(client.serverId, tool.name),
+        description: finalPatch.description,
+        render: finalPatch.render,
+        transformArgs: finalPatch.transformArgs
+      }
+    );
+  });
+}
+async function discoverManagedMCPTools(serverId, config, options = {}, manager) {
+  const client = new MCPClient(serverId, config, manager);
+  const tools = await createManagedMCPToolsFromClient(client, options);
+  return { client, tools };
+}
+async function mountMCPToolsFromConfig(config, options = {}) {
+  const clients = options.clients ?? /* @__PURE__ */ new Map();
+  const tools = [];
+  for (const [serverId, serverConfig] of Object.entries(config.servers)) {
+    try {
+      const client = clients.get(serverId) ?? new MCPClient(serverId, serverConfig, options.manager);
+      clients.set(serverId, client);
+      const serverOptions = options.getServerOptions?.(serverId, serverConfig) ?? {};
+      tools.push(...await createManagedMCPToolsFromClient(client, serverOptions));
+    } catch (error) {
+      options.onError?.(serverId, error);
+    }
+  }
+  return { tools, clients };
+}
+
+// src/render.ts
+function escapeHtml(text) {
+  const str = String(text);
+  const map = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return str.replace(/[&<>"']/g, (m) => map[m]);
+}
+var MCP_RENDER_TEMPLATES = {
+  /**
+   * MCP 工具调用显示
+   */
+  "mcp-tool": {
+    call: (args) => {
+      const server = args._server || "unknown";
+      const name = args._name || "unknown";
+      return `
+        <div class="bash-command" style="
+          border-left: 3px solid #ff6b6b;
+          padding-left: 8px;
+          margin: 4px 0;
+        ">
+          <span style="
+            color: #ff6b6b;
+            font-weight: bold;
+            font-size: 11px;
+            text-transform: uppercase;
+          ">MCP</span>
+          <span class="file-path" style="color: #c068ff;">${escapeHtml(server)}</span>
+          <span style="color: #888;">::</span>
+          <span style="color: #fff;">${escapeHtml(name)}</span>
+        </div>
+      `.trim();
+    },
+    result: (data, success = true) => {
+      if (!success || data.error) {
+        return `
+          <div class="bash-output" style="
+            border-left: 3px solid #ff4444;
+            padding-left: 8px;
+            color: #ff6b6b;
+          ">
+            <div style="font-weight: bold; margin-bottom: 4px;">MCP Error</div>
+            <pre style="margin: 0; white-space: pre-wrap;">${escapeHtml(data.error || "Unknown error")}</pre>
+          </div>
+        `.trim();
+      }
+      let content = "";
+      if (data.content) {
+        content += `<pre class="bash-output" style="max-height: 400px; overflow: auto;">${escapeHtml(data.content)}</pre>`;
+      }
+      if (data.structuredContent) {
+        content += `<details style="margin-top: 8px;">
+          <summary style="cursor: pointer; color: var(--accent-color);">Structured Data</summary>
+          <pre style="margin: 4px 0; padding: 8px; background: var(--bg-secondary);">${escapeHtml(JSON.stringify(data.structuredContent, null, 2))}</pre>
+        </details>`;
+      }
+      if (data.images && data.images.length > 0) {
+        content += `<div style="margin-top: 8px;">`;
+        data.images.forEach((img) => {
+          content += `<img src="data:${img.mimeType};base64,${img.data}" style="max-width: 100%; border-radius: 4px;" />`;
+        });
+        content += `</div>`;
+      }
+      if (data.resources && data.resources.length > 0) {
+        content += `<div style="margin-top: 8px;">
+          <div style="font-weight: bold; margin-bottom: 4px;">Resources:</div>`;
+        data.resources.forEach((res) => {
+          content += `<div style="padding: 4px; background: var(--bg-secondary); margin: 4px 0;">
+            <div style="font-size: 11px; color: var(--text-secondary);">${escapeHtml(res.uri)}</div>
+            ${res.text ? `<pre style="margin: 4px 0 0 0;">${escapeHtml(res.text)}</pre>` : ""}
+          </div>`;
+        });
+        content += `</div>`;
+      }
+      const meta = `
+        <div style="
+          font-size: 11px;
+          opacity: 0.6;
+          margin-top: 8px;
+          display: flex;
+          gap: 12px;
+        ">
+          <span>Server: ${escapeHtml(data.server)}</span>
+          <span>Duration: ${data.duration}ms</span>
+        </div>
+      `;
+      return content + meta;
+    }
+  },
+  /**
+   * MCP 结果 (简化版)
+   */
+  "mcp-result": {
+    call: () => '<div class="bash-command">MCP Tool Call</div>',
+    result: (data, success = true) => {
+      return MCP_RENDER_TEMPLATES["mcp-tool"].result(data, success);
+    }
+  }
+};
+function getMCPRenderTemplate(toolName) {
+  return "mcp-tool";
+}
+function renderMCPToolCall(serverName, toolName, args) {
+  const template = MCP_RENDER_TEMPLATES["mcp-tool"].call;
+  if (typeof template === "function") {
+    return template({ _server: serverName, _name: toolName, ...args });
+  }
+  return template;
+}
+function renderMCPToolResult(result, success = true) {
+  const template = MCP_RENDER_TEMPLATES["mcp-tool"].result;
+  if (typeof template === "function") {
+    return template(result, success);
+  }
+  return template;
+}
+
+// src/feature/index.ts
+import { fileURLToPath } from "url";
+import { getPackageInfoFromSource } from "@agentdevjs/core";
+var __filename = fileURLToPath(import.meta.url);
+var MCPFeature = class {
+  name = "mcp";
+  source = __filename.replace(/\\/g, "/");
+  description = "\u8FDE\u63A5 MCP \u670D\u52A1\u5668\u5E76\u628A\u53D1\u73B0\u5230\u7684\u8FDC\u7A0B\u80FD\u529B\u6302\u8F7D\u6210\u6807\u51C6\u5DE5\u5177\u3002";
+  manager = new MCPConnectionManager();
+  clients = /* @__PURE__ */ new Map();
+  input;
+  options;
+  config;
+  mcpContext;
+  /**
+   * 缓存包信息
+   */
+  _packageInfo = null;
+  /**
+   * 获取包信息（统一打包方案）
+   */
+  getPackageInfo() {
+    if (!this._packageInfo) {
+      this._packageInfo = getPackageInfoFromSource(this.source);
+    }
+    return this._packageInfo;
+  }
+  /**
+   * 获取模板名称列表（统一打包方案）
+   */
+  getTemplateNames() {
+    return ["mcp-tool"];
+  }
+  constructor(input, options = {}) {
+    this.input = input;
+    this.options = options;
+    if (input && typeof input !== "string") {
+      this.config = input;
+    }
+  }
+  getFeatureManifest() {
+    return {
+      schemaVersion: 1,
+      settings: {
+        properties: {
+          scanAgentdevDir: {
+            type: "boolean",
+            title: "\u52A0\u8F7D .agentdev/mcps",
+            description: "\u662F\u5426\u4ECE\u5DE5\u4F5C\u76EE\u5F55\u7684 .agentdev/mcps/ \u52A0\u8F7D\u7CFB\u7EDF MCP \u914D\u7F6E\u6587\u4EF6\u3002",
+            default: true
+          },
+          extraConfigFiles: {
+            type: "file",
+            title: "\u989D\u5916 MCP \u914D\u7F6E\u6587\u4EF6",
+            description: "\u989D\u5916\u52A0\u8F7D\u591A\u4E2A MCP \u914D\u7F6E\u6587\u4EF6\uFF08\u81F3\u591A 5 \u4E2A\uFF09\uFF0C\u91CD\u540D server/tool \u4F1A\u81EA\u52A8\u52A0\u540E\u7F00\u533A\u5206\u3002",
+            default: [],
+            accept: ".json",
+            maxItems: 5
+          },
+          enableGateway: {
+            type: "boolean",
+            title: "\u542F\u7528 Claw MCP \u7F51\u5173",
+            description: "\u81EA\u52A8\u8FDE\u63A5 Claw \u4E3B\u8FDB\u7A0B\u6258\u7BA1\u7684\u5171\u4EAB MCP \u670D\u52A1\u5668\u3002\u542F\u7528\u540E\uFF0C\u6240\u6709\u4F1A\u8BDD\u5171\u4EAB\u540C\u4E00\u4EFD MCP server \u8FDE\u63A5\uFF0C\u65E0\u9700\u5404\u81EA\u542F\u52A8\u3002",
+            default: true
+          }
+        }
+      }
+    };
+  }
+  resolveFeatureConfig(featureConfig) {
+    if (!featureConfig || typeof featureConfig !== "object") {
+      return {
+        scanAgentdevDir: true,
+        extraConfigFiles: [],
+        enableGateway: true
+      };
+    }
+    const config = featureConfig;
+    return {
+      scanAgentdevDir: config.scanAgentdevDir === void 0 ? true : config.scanAgentdevDir !== false,
+      extraConfigFiles: Array.isArray(config.extraConfigFiles) ? config.extraConfigFiles.filter((value) => typeof value === "string" && value.length > 0) : [],
+      enableGateway: config.enableGateway === void 0 ? true : config.enableGateway !== false
+    };
+  }
+  resolveRuntimeConfig(ctx) {
+    if (this.config) {
+      return this.config;
+    }
+    const rootDir = ctx.config?.workspaceDir;
+    if (typeof this.input === "string") {
+      this.config = loadMCPConfigFromInput(this.input, rootDir);
+      return this.config;
+    }
+    const featureConfig = this.resolveFeatureConfig(ctx.featureConfig);
+    this.config = loadAllMCPConfigs(rootDir, {
+      loadDefaultDir: featureConfig.scanAgentdevDir,
+      extraConfigFiles: featureConfig.extraConfigFiles,
+      excludeServers: this.options.excludeServers
+    });
+    return this.config;
+  }
+  /**
+   * 获取同步工具（无）
+   */
+  getTools() {
+    return [];
+  }
+  /**
+   * 获取异步工具（需要连接 MCP 服务器）
+   */
+  async getAsyncTools(ctx) {
+    const config = this.resolveRuntimeConfig(ctx);
+    const featureConfig = this.resolveFeatureConfig(ctx.featureConfig);
+    let gatewayServers = {};
+    if (featureConfig.enableGateway && !this.input) {
+      const discovery = await discoverGatewayServers();
+      if (discovery.servers.length > 0) {
+        gatewayServers = gatewayServersToConfig(discovery, this.options.excludeServers);
+      }
+    }
+    const hasServers = config?.servers && Object.keys(config.servers).length > 0 || Object.keys(gatewayServers).length > 0;
+    if (!hasServers) {
+      return [];
+    }
+    const mergedConfig = {
+      enabled: true,
+      servers: {
+        ...config?.servers || {},
+        ...gatewayServers
+      }
+    };
+    const result = await mountMCPToolsFromConfig(mergedConfig, {
+      manager: this.manager,
+      clients: this.clients,
+      onError: (serverId, error) => {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.warn(`[MCPFeature] Failed to load tools from "${serverId}": ${errorMsg}`);
+      }
+    });
+    return result.tools;
+  }
+  /**
+   * 声明上下文注入器
+   * 为所有 MCP 工具注入 _mcpContext
+   */
+  getContextInjectors() {
+    return /* @__PURE__ */ new Map([
+      [/^mcp_/, () => ({ _mcpContext: this.mcpContext })]
+    ]);
+  }
+  /**
+   * 清理钩子
+   */
+  async onDestroy() {
+    for (const client of this.clients.values()) {
+      await client.dispose();
+    }
+    this.clients.clear();
+    await this.manager.dispose();
+  }
+  /**
+   * 设置 MCP 上下文（运行时注入）
+   */
+  setMCPContext(context) {
+    this.mcpContext = context;
+  }
+  /**
+   * 获取连接管理器（供外部使用）
+   */
+  getConnectionManager() {
+    return this.manager;
+  }
+};
+export {
+  MCPClient,
+  MCPConnectionManager,
+  MCPConnectionState,
+  MCPFeature,
+  MCPToolAdapter,
+  MCP_RENDER_TEMPLATES,
+  createDefaultMCPToolName,
+  createMCPTool,
+  createMCPToolAdapters,
+  createMCPToolsFromClient,
+  createManagedMCPToolsFromClient,
+  discoverGatewayServers,
+  discoverMCPTools,
+  discoverManagedMCPTools,
+  gatewayServersToConfig,
+  getDefaultMCPConfigDir,
+  getMCPRenderTemplate,
+  loadAllMCPConfigs,
+  loadMCPConfigFromInput,
+  mountMCPToolsFromConfig,
+  renderMCPToolCall,
+  renderMCPToolResult
+};
+//# sourceMappingURL=index.js.map