@ai-setting/roy-agent-core 1.0.0

package/src/env/mcp/loader.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { McpLoader } from "./loader";
+import type { DiscoveredMcpServer, McpServerConfig } from "./types";
+
+/**
+ * TDD RED: 测试 McpLoader
+ */
+
+describe("McpLoader", () => {
+  let loader: McpLoader;
+
+  beforeEach(() => {
+    loader = new McpLoader(30000);
+  });
+
+  describe("buildDefaultConfig", () => {
+    it("should build local config with bun run command", () => {
+      const server: DiscoveredMcpServer = {
+        name: "test-mcp",
+        entryPath: "/path/to/server.ts",
+      };
+
+      const config = loader.buildDefaultConfig(server);
+
+      expect(config.type).toBe("local");
+      expect((config as any).command).toEqual(["bun", "run", "/path/to/server.ts"]);
+    });
+
+    it("should use directoryConfig command if present", () => {
+      const server: DiscoveredMcpServer = {
+        name: "test-mcp",
+        entryPath: "/path/to/server.ts",
+        directoryConfig: {
+          command: ["node", "/path/to/server.js"],
+        },
+        // Scanner解析后的命令（包含绝对路径）
+        defaultCommand: ["node", "/path/to/server.js"],
+      };
+
+      const config = loader.buildDefaultConfig(server);
+
+      expect(config.type).toBe("local");
+      expect((config as any).command).toEqual(["node", "/path/to/server.js"]);
+    });
+
+    it("should build remote config from directoryConfig", () => {
+      const server: DiscoveredMcpServer = {
+        name: "remote-mcp",
+        directoryConfig: {
+          type: "remote",
+          url: "https://mcp.example.com",
+          enabled: true,
+        },
+      };
+
+      const config = loader.buildDefaultConfig(server);
+
+      expect(config.type).toBe("remote");
+      expect((config as any).url).toBe("https://mcp.example.com");
+    });
+
+    it("should set enabled by default", () => {
+      const server: DiscoveredMcpServer = {
+        name: "test-mcp",
+      };
+
+      const config = loader.buildDefaultConfig(server);
+
+      expect(config.enabled).toBe(true);
+    });
+
+    it("should use directoryConfig timeout if present", () => {
+      const server: DiscoveredMcpServer = {
+        name: "test-mcp",
+        directoryConfig: {
+          timeout: 60000,
+        },
+      };
+
+      const config = loader.buildDefaultConfig(server);
+
+      expect((config as any).timeout).toBe(60000);
+    });
+  });
+
+  describe("mergeConfig", () => {
+    it("should merge explicit config over default", () => {
+      const defaultConfig: McpServerConfig = {
+        type: "local",
+        command: ["bun", "run", "server.ts"],
+        enabled: true,
+      };
+
+      const merged = loader.mergeConfig(defaultConfig, {
+        timeout: 60000,
+      });
+
+      expect((merged as any).command).toEqual(["bun", "run", "server.ts"]);
+      expect((merged as any).timeout).toBe(60000);
+    });
+
+    it("should disable when explicit enabled is false", () => {
+      const defaultConfig: McpServerConfig = {
+        type: "local",
+        command: ["bun", "run", "server.ts"],
+        enabled: true,
+      };
+
+      const merged = loader.mergeConfig(defaultConfig, {
+        enabled: false,
+      });
+
+      expect(merged.enabled).toBe(false);
+    });
+
+    it("should return default when no explicit config", () => {
+      const defaultConfig: McpServerConfig = {
+        type: "local",
+        command: ["bun", "run", "server.ts"],
+      };
+
+      const merged = loader.mergeConfig(defaultConfig, undefined);
+
+      expect(merged).toBe(defaultConfig);
+    });
+
+    it("should merge local config correctly", () => {
+      const defaultConfig: McpServerConfig = {
+        type: "local",
+        command: ["bun", "run", "server.ts"],
+        environment: { NODE_ENV: "development" },
+      };
+
+      const merged = loader.mergeConfig(defaultConfig, {
+        environment: { NODE_ENV: "production" },
+      });
+
+      expect((merged as any).environment).toEqual({ NODE_ENV: "production" });
+    });
+  });
+
+  describe("getClient", () => {
+    it("should return undefined for non-existent client", () => {
+      const client = loader.getClient("non-existent");
+      expect(client).toBeUndefined();
+    });
+  });
+
+  describe("getAllClients", () => {
+    it("should return empty map initially", () => {
+      const clients = loader.getAllClients();
+      expect(clients.size).toBe(0);
+    });
+  });
+
+  describe("isConnected", () => {
+    it("should return false for non-connected server", () => {
+      expect(loader.isConnected("test")).toBe(false);
+    });
+  });
+});

package/src/env/mcp/loader.ts

@@ -0,0 +1,209 @@
+/**
+ * @fileoverview MCP 服务器加载器
+ * 
+ * 负责连接和管理 MCP 客户端
+ */
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { createLogger } from "../log-trace/logger";
+import type {
+  McpServerConfig,
+  McpServerLocalConfig,
+  McpServerRemoteConfig,
+  DiscoveredMcpServer,
+} from "./types";
+
+const logger = createLogger("mcp-loader");
+
+/**
+ * MCP 客户端条目
+ */
+export interface McpClientEntry {
+  name: string;
+  client: Client;
+  transport: StdioClientTransport | StreamableHTTPClientTransport;
+  config: McpServerConfig;
+}
+
+/**
+ * MCP 服务器加载器
+ * 
+ * 负责：
+ * 1. 构建默认配置
+ * 2. 合并显式配置
+ * 3. 连接/断开 MCP 服务器
+ */
+export class McpLoader {
+  private clients: Map<string, McpClientEntry> = new Map();
+  private defaultTimeout: number;
+
+  constructor(defaultTimeout: number = 30000) {
+    this.defaultTimeout = defaultTimeout;
+  }
+
+  /**
+   * 构建默认配置（从扫描结果）
+   * 
+   * @param server - 扫描发现的 MCP 服务器信息
+   * @returns MCP 服务器配置
+   */
+  buildDefaultConfig(server: DiscoveredMcpServer): McpServerConfig {
+    // 检查是否是远程配置
+    if (server.directoryConfig?.type === "remote") {
+      const remoteConfig: McpServerRemoteConfig = {
+        type: "remote",
+        url: server.directoryConfig.url as string,
+        enabled: (server.directoryConfig.enabled as boolean) ?? true,
+        headers: server.directoryConfig.headers as Record<string, string>,
+        timeout: (server.directoryConfig.timeout as number) ?? this.defaultTimeout,
+      };
+      return remoteConfig;
+    }
+
+    // 构建本地配置 - 优先使用 scanner 解析的 defaultCommand
+    const command = server.defaultCommand
+      ?? (server.entryPath
+        ? ["bun", "run", server.entryPath]
+        : ["bun", "run", server.name]);
+
+    const localConfig: McpServerLocalConfig = {
+      type: "local",
+      command,
+      environment: server.directoryConfig?.environment as Record<string, string>,
+      enabled: (server.directoryConfig?.enabled as boolean) ?? true,
+      timeout: (server.directoryConfig?.timeout as number) ?? this.defaultTimeout,
+    };
+
+    return localConfig;
+  }
+
+  /**
+   * 合并配置（显式配置覆盖默认配置）
+   */
+  mergeConfig(
+    defaultConfig: McpServerConfig,
+    explicitConfig?: Partial<McpServerConfig>
+  ): McpServerConfig {
+    if (!explicitConfig) {
+      return defaultConfig;
+    }
+
+    // 如果明确禁用
+    if (explicitConfig.enabled === false) {
+      return { ...defaultConfig, enabled: false };
+    }
+
+    // 合并配置
+    if (defaultConfig.type === "local" && (!explicitConfig.type || explicitConfig.type === "local")) {
+      return {
+        ...defaultConfig,
+        ...explicitConfig,
+        type: "local",
+      };
+    }
+
+    if (defaultConfig.type === "remote" && (!explicitConfig.type || explicitConfig.type === "remote")) {
+      return {
+        ...defaultConfig,
+        ...explicitConfig,
+        type: "remote",
+      };
+    }
+
+    return explicitConfig as McpServerConfig;
+  }
+
+  /**
+   * 连接到 MCP 服务器
+   */
+  async connect(
+    name: string,
+    config: McpServerConfig
+  ): Promise<McpClientEntry> {
+    if (config.enabled === false) {
+      throw new Error(`MCP server ${name} is disabled`);
+    }
+
+    logger.info(`[McpLoader] Connecting to ${name}...`);
+
+    let client: Client;
+    let transport: StdioClientTransport | StreamableHTTPClientTransport;
+
+    if (config.type === "local") {
+      const localConfig = config as McpServerLocalConfig;
+      transport = new StdioClientTransport({
+        command: localConfig.command[0],
+        args: localConfig.command.slice(1),
+        env: localConfig.environment,
+      });
+      client = new Client({ name, version: "1.0.0" });
+      await client.connect(transport);
+    } else {
+      const remoteConfig = config as McpServerRemoteConfig;
+      transport = new StreamableHTTPClientTransport(
+        new URL(remoteConfig.url),
+        {
+          requestInit: remoteConfig.headers
+            ? { headers: remoteConfig.headers }
+            : undefined,
+        }
+      );
+      client = new Client({ name, version: "1.0.0" });
+      await client.connect(transport);
+    }
+
+    const entry: McpClientEntry = { name, client, transport, config };
+    this.clients.set(name, entry);
+
+    logger.info(`[McpLoader] Connected to ${name}`);
+    return entry;
+  }
+
+  /**
+   * 断开连接
+   */
+  async disconnect(name: string): Promise<void> {
+    const entry = this.clients.get(name);
+    if (!entry) return;
+
+    try {
+      await entry.client.close();
+      this.clients.delete(name);
+      logger.info(`[McpLoader] Disconnected from ${name}`);
+    } catch (error) {
+      logger.warn(`[McpLoader] Error disconnecting from ${name}`, { error });
+    }
+  }
+
+  /**
+   * 断开所有连接
+   */
+  async disconnectAll(): Promise<void> {
+    for (const name of this.clients.keys()) {
+      await this.disconnect(name);
+    }
+  }
+
+  /**
+   * 获取客户端
+   */
+  getClient(name: string): McpClientEntry | undefined {
+    return this.clients.get(name);
+  }
+
+  /**
+   * 获取所有客户端
+   */
+  getAllClients(): Map<string, McpClientEntry> {
+    return this.clients;
+  }
+
+  /**
+   * 检查是否已连接
+   */
+  isConnected(name: string): boolean {
+    return this.clients.has(name);
+  }
+}

package/src/env/mcp/mcp-component.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { McpComponent } from "./mcp-component";
+import { BaseComponent } from "../component";
+
+/**
+ * TDD RED: 测试 McpComponent
+ * 
+ * 注意：不要 mock BaseComponent，因为它会影响其他测试文件。
+ * 如果需要 mock 行为，应该使用 vi.spyOn 或创建测试专用的子类。
+ */
+
+describe("McpComponent", () => {
+  let component: McpComponent;
+
+  beforeEach(() => {
+    component = new McpComponent();
+  });
+
+  describe("constructor", () => {
+    it("should have correct name", () => {
+      expect(component.name).toBe("mcp");
+    });
+
+    it("should have correct version", () => {
+      expect(component.version).toBe("1.0.0");
+    });
+  });
+
+  describe("init", () => {
+    it("should require configComponent", async () => {
+      await expect(
+        component.init({
+          options: {},
+        })
+      ).rejects.toThrow("ConfigComponent is required");
+    });
+
+    it("should initialize with valid config", async () => {
+      const mockConfigComponent = {
+        get: vi.fn().mockReturnValue(undefined),
+        set: vi.fn().mockResolvedValue(undefined),
+        registerSource: vi.fn(),
+        registerComponent: vi.fn(),
+        load: vi.fn().mockResolvedValue(undefined),
+      };
+
+      await component.init({
+        options: {
+          configComponent: mockConfigComponent as any,
+          config: {
+            enabled: false,
+            mcpPaths: [],
+          },
+        },
+      });
+
+      expect(component.getStatus()).toBeDefined();
+    });
+  });
+
+  describe("getServerStatus", () => {
+    it("should return undefined for non-existent server", () => {
+      // Before init, should not throw
+      expect(() => component.getServerStatus("test")).not.toThrow();
+    });
+  });
+
+  describe("listServers", () => {
+    it("should return empty array initially", () => {
+      expect(Array.isArray(component.listServers())).toBe(true);
+    });
+  });
+
+  describe("listTools", () => {
+    it("should return empty array initially", () => {
+      expect(Array.isArray(component.listTools())).toBe(true);
+    });
+  });
+});
+
+describe("McpComponent integration scenarios", () => {
+  let component: McpComponent;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    component = new McpComponent();
+  });
+
+  it("should handle disabled configuration", async () => {
+    const mockConfigComponent = {
+      get: vi.fn().mockReturnValue(undefined),
+      set: vi.fn().mockResolvedValue(undefined),
+      registerSource: vi.fn(),
+      registerComponent: vi.fn(),
+      load: vi.fn().mockResolvedValue(undefined),
+    };
+
+    await component.init({
+      options: {
+        configComponent: mockConfigComponent as any,
+        config: {
+          enabled: false,
+          mcpPaths: [],
+        },
+      },
+    });
+
+    // With disabled config and no paths, should handle gracefully
+    expect(component.getStatus()).toBeDefined();
+  });
+});