@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/core/src/env/mcp/__integration__/mcp-component.integration.test.js

@@ -0,0 +1,322 @@
+import { describe, it, expect, beforeEach, afterEach, afterAll } from "bun:test";
+import { vi } from "vitest";
+import { McpComponent } from "../mcp-component.js";
+/**
+ * MCP 工具注册测试
+ */
+// Mock MCP SDK
+vi.mock("@modelcontextprotocol/sdk/client/index.js", () => ({
+    Client: vi.fn().mockImplementation(() => ({
+        connect: vi.fn().mockResolvedValue(undefined),
+        listTools: vi.fn().mockResolvedValue({
+            tools: [
+                {
+                    name: "web_search",
+                    description: "Search the web",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            query: { type: "string", description: "Search query" },
+                        },
+                        required: ["query"],
+                    },
+                },
+                {
+                    name: "web_fetch",
+                    description: "Fetch webpage content",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            url: { type: "string", description: "URL to fetch" },
+                        },
+                        required: ["url"],
+                    },
+                },
+            ],
+        }),
+        callTool: vi.fn().mockResolvedValue({
+            content: [{ type: "text", text: "mock result" }],
+        }),
+        close: vi.fn().mockResolvedValue(undefined),
+    })),
+}));
+vi.mock("@modelcontextprotocol/sdk/client/streamableHttp.js", () => ({
+    StreamableHTTPClientTransport: vi.fn().mockImplementation(() => ({})),
+}));
+// 不要 mock BaseComponent，因为它会影响其他测试文件
+// Mock Logger
+vi.mock("../../log-trace/logger", () => ({
+    createLogger: () => ({
+        info: vi.fn(),
+        debug: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    }),
+}));
+// Mock Scanner
+vi.mock("../scanner", () => ({
+    McpScanner: vi.fn().mockImplementation(() => ({
+        scan: vi.fn().mockResolvedValue(new Map([
+            [
+                "exa",
+                {
+                    name: "exa",
+                    directoryConfig: {
+                        type: "remote",
+                        url: "https://mcp.exa.ai/mcp?tools=web_search_exa",
+                        enabled: true,
+                        timeout: 30000,
+                    },
+                },
+            ],
+        ])),
+    })),
+}));
+// Mock Loader
+vi.mock("../loader", () => ({
+    McpLoader: vi.fn().mockImplementation(() => ({
+        buildDefaultConfig: vi.fn().mockImplementation((server) => ({
+            type: "remote",
+            url: server.directoryConfig?.url,
+            enabled: true,
+            timeout: 30000,
+        })),
+        mergeConfig: vi.fn().mockImplementation((defaultConfig) => defaultConfig),
+        connect: vi.fn().mockImplementation(async (name, config) => ({
+            name,
+            config,
+            client: {
+                listTools: vi.fn().mockResolvedValue({
+                    tools: [
+                        {
+                            name: "web_search_exa",
+                            description: "Search the web using Exa",
+                            inputSchema: {
+                                type: "object",
+                                properties: {
+                                    query: { type: "string", description: "Search query" },
+                                },
+                                required: ["query"],
+                            },
+                        },
+                    ],
+                }),
+                callTool: vi.fn().mockResolvedValue({
+                    content: [{ type: "text", text: "search result" }],
+                    isError: false,
+                }),
+            },
+        })),
+        disconnect: vi.fn().mockResolvedValue(undefined),
+        disconnectAll: vi.fn().mockResolvedValue(undefined),
+    })),
+}));
+describe("McpComponent 工具注册", () => {
+    let component;
+    let mockToolComponent;
+    let registeredTools;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // 创建 mock ToolComponent
+        registeredTools = new Map();
+        mockToolComponent = {
+            register: vi.fn((tool) => {
+                registeredTools.set(tool.name, tool);
+            }),
+            unregister: vi.fn((name) => {
+                return registeredTools.delete(name);
+            }),
+            getTool: vi.fn((name) => registeredTools.get(name)),
+            listTools: vi.fn(() => Array.from(registeredTools.values())),
+            _tools: registeredTools,
+        };
+        component = new McpComponent();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe("init", () => {
+        it("应该接受有效的配置并初始化", 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,
+                    config: {
+                        enabled: false,
+                        mcpPaths: [],
+                    },
+                },
+            });
+            expect(component.getStatus()).toBeDefined();
+        });
+        it("缺少 configComponent 应该抛出错误", async () => {
+            await expect(component.init({
+                options: {},
+            })).rejects.toThrow("ConfigComponent is required");
+        });
+    });
+    describe("start - MCP 工具注册到 ToolComponent", () => {
+        it("应该将扫描到的 MCP 工具注册到 ToolComponent", 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,
+                    config: {
+                        enabled: true,
+                        mcpPaths: [{ type: "project", path: ".roy/mcp" }],
+                    },
+                },
+            });
+            // 设置 env（包含 getComponent 方法）并注入 mock ToolComponent
+            component.env = {
+                getComponent: vi.fn().mockReturnValue(mockToolComponent),
+            };
+            component.toolComponent = mockToolComponent;
+            // 启动组件
+            await component.start();
+            // 验证：MCP 工具应该被注册到 ToolComponent
+            // Mock Loader 返回的客户端会被 adaptMcpTool 适配
+            expect(mockToolComponent.register).toHaveBeenCalled();
+            // 验证：至少有一个工具被注册
+            const servers = component.listServers();
+            console.log("Server status:", servers);
+        });
+        it("ToolComponent 不存在时应该跳过工具注册", 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,
+                    config: {
+                        enabled: true,
+                        mcpPaths: [{ type: "project", path: ".roy/mcp" }],
+                    },
+                },
+            });
+            // 设置 env（getComponent 返回 undefined）
+            component.env = {
+                getComponent: vi.fn().mockReturnValue(undefined),
+            };
+            component.toolComponent = undefined;
+            // 启动组件 - 不应该抛出错误
+            await component.start();
+            expect(component.getStatus()).toBeDefined();
+        });
+    });
+    describe("工具列表方法", () => {
+        it("listTools 应该返回已注册的 MCP 工具", () => {
+            const tools = component.listTools();
+            expect(Array.isArray(tools)).toBe(true);
+        });
+        it("listServers 应该返回服务器状态列表", () => {
+            const servers = component.listServers();
+            expect(Array.isArray(servers)).toBe(true);
+        });
+    });
+    describe("reload", () => {
+        it("应该能够重新加载服务器并重新注册工具", 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,
+                    config: {
+                        enabled: true,
+                        mcpPaths: [{ type: "project", path: ".roy/mcp" }],
+                    },
+                },
+            });
+            component.env = {
+                getComponent: vi.fn().mockReturnValue(mockToolComponent),
+            };
+            component.toolComponent = mockToolComponent;
+            await component.start();
+            await component.reload();
+            // reload 应该清理旧状态
+            expect(component.listServers()).toBeDefined();
+        });
+    });
+});
+describe("MCP 工具适配器测试", () => {
+    it("应该正确适配 MCP 工具格式", async () => {
+        // 这个测试验证 adaptMcpTool 的输出格式
+        const { adaptMcpTool } = await import("../tool/adapter.js");
+        const mockMcpTool = {
+            name: "web_search",
+            description: "Search the web",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: { type: "string" },
+                },
+                required: ["query"],
+            },
+        };
+        const mockClient = {
+            callTool: vi.fn().mockResolvedValue({
+                content: [{ type: "text", text: "result" }],
+                isError: false,
+            }),
+        };
+        const adaptedTool = adaptMcpTool(mockMcpTool, mockClient, "exa");
+        // 验证适配后的工具格式
+        expect(adaptedTool.name).toBe("mcp_exa_web_search");
+        expect(adaptedTool.description).toContain("MCP tool [exa/web_search]");
+        expect(adaptedTool.metadata?.category).toBe("mcp");
+        expect(adaptedTool.metadata?.tags).toContain("exa");
+    });
+    it("应该正确处理工具执行", async () => {
+        const { adaptMcpTool } = await import("../tool/adapter.js");
+        const mockMcpTool = {
+            name: "test_tool",
+            description: "Test tool",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        };
+        const mockResult = {
+            content: [{ type: "text", text: "test result" }],
+            isError: false,
+        };
+        const mockClient = {
+            callTool: vi.fn().mockResolvedValue(mockResult),
+        };
+        const adaptedTool = adaptMcpTool(mockMcpTool, mockClient, "test");
+        // 执行工具
+        const result = await adaptedTool.execute({});
+        expect(result.success).toBe(true);
+        expect(result.output).toBe("test result");
+        expect(mockClient.callTool).toHaveBeenCalledWith({
+            name: "test_tool",
+            arguments: {},
+        });
+    });
+});
+// 清理 mock，避免污染其他测试
+afterAll(() => {
+    vi.restoreAllMocks();
+});
+//# sourceMappingURL=mcp-component.integration.test.js.map

package/dist/core/src/env/mcp/config.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @fileoverview MCP Component 配置
+ */
+import { z } from "zod";
+import type { ConfigComponent } from "../../config/config-component";
+/**
+ * MCP 路径配置
+ */
+export interface McpPath {
+    /** 来源类型 */
+    type: "user" | "project" | "custom";
+    /** 路径 */
+    path: string;
+}
+/**
+ * McpPath Schema
+ */
+export declare const McpPathSchema: z.ZodObject<{
+    type: z.ZodEnum<["user", "project", "custom"]>;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path?: string;
+    type?: "custom" | "user" | "project";
+}, {
+    path?: string;
+    type?: "custom" | "user" | "project";
+}>;
+/**
+ * McpComponent 配置
+ */
+export interface McpComponentConfig {
+    /** 扫描路径列表 */
+    mcpPaths: McpPath[];
+    /** 显式配置的服务器 */
+    servers?: Record<string, z.infer<typeof import("./types.js").McpServerConfigSchema>>;
+    /** 默认超时（毫秒） */
+    timeout?: number;
+    /** 是否启用 */
+    enabled?: boolean;
+}
+/**
+ * McpComponent 配置 Schema
+ */
+export declare const McpComponentConfigSchema: z.ZodObject<{
+    mcpPaths: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["user", "project", "custom"]>;
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path?: string;
+        type?: "custom" | "user" | "project";
+    }, {
+        path?: string;
+        type?: "custom" | "user" | "project";
+    }>, "many">;
+    servers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    enabled?: boolean;
+    timeout?: number;
+    mcpPaths?: {
+        path?: string;
+        type?: "custom" | "user" | "project";
+    }[];
+    servers?: Record<string, any>;
+}, {
+    enabled?: boolean;
+    timeout?: number;
+    mcpPaths?: {
+        path?: string;
+        type?: "custom" | "user" | "project";
+    }[];
+    servers?: Record<string, any>;
+}>;
+/**
+ * McpComponentOptions（通过 options 传递）
+ */
+export interface McpComponentOptions {
+    /** ConfigComponent 实例（必填） */
+    configComponent: ConfigComponent;
+    /** 配置文件相对路径 */
+    configPath?: string;
+    /** 环境变量前缀 */
+    envPrefix?: string;
+    /** 直接传入的配置对象（最高优先级） */
+    config?: Partial<McpComponentConfig>;
+}
+/**
+ * 默认 MCP 配置
+ */
+export declare const DEFAULT_MCP_CONFIG: McpComponentConfig;
+/**
+ * 配置 Key 列表（用于 ConfigComponent 注册）
+ */
+export declare const MCP_CONFIG_KEYS: readonly ["mcp.enabled", "mcp.timeout", "mcp.mcpPaths", "mcp.servers"];
+/**
+ * 路径类型优先级
+ */
+export declare const MCP_PATH_PRIORITY: Record<string, number>;
+/**
+ * 获取路径优先级
+ */
+export declare function getMcpPathPriority(type: string): number;
+//# sourceMappingURL=config.d.ts.map

package/dist/core/src/env/mcp/config.js

@@ -0,0 +1,65 @@
+/**
+ * @fileoverview MCP Component 配置
+ */
+import path from "path";
+import os from "os";
+import { z } from "zod";
+/**
+ * McpPath Schema
+ */
+export const McpPathSchema = z.object({
+    type: z.enum(["user", "project", "custom"]),
+    path: z.string(),
+});
+/**
+ * McpComponent 配置 Schema
+ */
+export const McpComponentConfigSchema = z.object({
+    mcpPaths: z.array(McpPathSchema),
+    servers: z.record(z.string(), z.any()).optional(),
+    timeout: z.number().int().positive().optional(),
+    enabled: z.boolean().optional(),
+});
+// ========== 默认配置 ==========
+/**
+ * 默认 MCP 配置
+ */
+export const DEFAULT_MCP_CONFIG = {
+    mcpPaths: [
+        {
+            type: "user",
+            path: path.join(os.homedir(), ".config", "roy-agent", "mcp"),
+        },
+        {
+            type: "project",
+            path: ".roy/mcp",
+        },
+    ],
+    timeout: 30000,
+    enabled: true,
+};
+// ========== 配置 Keys ==========
+/**
+ * 配置 Key 列表（用于 ConfigComponent 注册）
+ */
+export const MCP_CONFIG_KEYS = [
+    "mcp.enabled",
+    "mcp.timeout",
+    "mcp.mcpPaths",
+    "mcp.servers",
+];
+/**
+ * 路径类型优先级
+ */
+export const MCP_PATH_PRIORITY = {
+    user: 1,
+    project: 2,
+    custom: 3,
+};
+/**
+ * 获取路径优先级
+ */
+export function getMcpPathPriority(type) {
+    return MCP_PATH_PRIORITY[type] ?? 0;
+}
+//# sourceMappingURL=config.js.map

package/dist/core/src/env/mcp/config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.test.d.ts.map

package/dist/core/src/env/mcp/config.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import { DEFAULT_MCP_CONFIG, MCP_CONFIG_KEYS, getMcpPathPriority, } from "./config.js";
+/**
+ * TDD: 验证 MCP 配置
+ */
+describe("DEFAULT_MCP_CONFIG", () => {
+    it("should have default mcpPaths with user type", () => {
+        const userPath = DEFAULT_MCP_CONFIG.mcpPaths.find(p => p.type === "user");
+        expect(userPath).toBeDefined();
+        expect(userPath?.type).toBe("user");
+        expect(userPath?.path).toContain(".config");
+        expect(userPath?.path).toContain("roy-agent");
+        expect(userPath?.path).toContain("mcp");
+    });
+    it("should have default mcpPaths with project type", () => {
+        const projectPath = DEFAULT_MCP_CONFIG.mcpPaths.find(p => p.type === "project");
+        expect(projectPath).toBeDefined();
+        expect(projectPath?.type).toBe("project");
+        expect(projectPath?.path).toBe(".roy/mcp");
+    });
+    it("should have default timeout of 30000", () => {
+        expect(DEFAULT_MCP_CONFIG.timeout).toBe(30000);
+    });
+    it("should be enabled by default", () => {
+        expect(DEFAULT_MCP_CONFIG.enabled).toBe(true);
+    });
+});
+describe("MCP_CONFIG_KEYS", () => {
+    it("should include mcp.enabled key", () => {
+        expect(MCP_CONFIG_KEYS).toContain("mcp.enabled");
+    });
+    it("should include mcp.timeout key", () => {
+        expect(MCP_CONFIG_KEYS).toContain("mcp.timeout");
+    });
+    it("should include mcp.mcpPaths key", () => {
+        expect(MCP_CONFIG_KEYS).toContain("mcp.mcpPaths");
+    });
+    it("should include mcp.servers key", () => {
+        expect(MCP_CONFIG_KEYS).toContain("mcp.servers");
+    });
+});
+describe("getMcpPathPriority", () => {
+    it("should return correct priority for user", () => {
+        expect(getMcpPathPriority("user")).toBe(1);
+    });
+    it("should return correct priority for project", () => {
+        expect(getMcpPathPriority("project")).toBe(2);
+    });
+    it("should return correct priority for custom", () => {
+        expect(getMcpPathPriority("custom")).toBe(3);
+    });
+    it("should return 0 for unknown type", () => {
+        expect(getMcpPathPriority("unknown")).toBe(0);
+    });
+});
+//# sourceMappingURL=config.test.js.map

package/dist/core/src/env/mcp/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview MCP Component 导出
+ */
+export type { McpServerConfig, McpServerLocalConfig, McpServerRemoteConfig, DiscoveredMcpServer, McpServerStatus, } from "./types";
+export { McpServerConfigSchema, McpServerLocalConfigSchema, McpServerRemoteConfigSchema, } from "./types";
+export { DEFAULT_MCP_CONFIG, MCP_CONFIG_KEYS, getMcpPathPriority, } from "./config";
+export type { McpComponentConfig, McpComponentOptions, McpPath, } from "./config";
+export { McpComponent } from "./mcp-component";
+export { McpScanner } from "./scanner";
+export { McpLoader, type McpClientEntry } from "./loader";
+export { adaptMcpTool, createMcpToolsDescription, convertInputSchemaToZod } from "./tool/adapter";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/mcp/index.js

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview MCP Component 导出
+ */
+export { McpServerConfigSchema, McpServerLocalConfigSchema, McpServerRemoteConfigSchema, } from "./types.js";
+// 配置
+export { DEFAULT_MCP_CONFIG, MCP_CONFIG_KEYS, getMcpPathPriority, } from "./config.js";
+// 组件
+export { McpComponent } from "./mcp-component.js";
+// Scanner & Loader
+export { McpScanner } from "./scanner.js";
+export { McpLoader } from "./loader.js";
+// Tool Adapter
+export { adaptMcpTool, createMcpToolsDescription, convertInputSchemaToZod } from "./tool/adapter.js";
+//# sourceMappingURL=index.js.map

package/dist/core/src/env/mcp/loader.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @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 type { McpServerConfig, DiscoveredMcpServer } from "./types";
+/**
+ * MCP 客户端条目
+ */
+export interface McpClientEntry {
+    name: string;
+    client: Client;
+    transport: StdioClientTransport | StreamableHTTPClientTransport;
+    config: McpServerConfig;
+}
+/**
+ * MCP 服务器加载器
+ *
+ * 负责：
+ * 1. 构建默认配置
+ * 2. 合并显式配置
+ * 3. 连接/断开 MCP 服务器
+ */
+export declare class McpLoader {
+    private clients;
+    private defaultTimeout;
+    constructor(defaultTimeout?: number);
+    /**
+     * 构建默认配置（从扫描结果）
+     *
+     * @param server - 扫描发现的 MCP 服务器信息
+     * @returns MCP 服务器配置
+     */
+    buildDefaultConfig(server: DiscoveredMcpServer): McpServerConfig;
+    /**
+     * 合并配置（显式配置覆盖默认配置）
+     */
+    mergeConfig(defaultConfig: McpServerConfig, explicitConfig?: Partial<McpServerConfig>): McpServerConfig;
+    /**
+     * 连接到 MCP 服务器
+     */
+    connect(name: string, config: McpServerConfig): Promise<McpClientEntry>;
+    /**
+     * 断开连接
+     */
+    disconnect(name: string): Promise<void>;
+    /**
+     * 断开所有连接
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * 获取客户端
+     */
+    getClient(name: string): McpClientEntry | undefined;
+    /**
+     * 获取所有客户端
+     */
+    getAllClients(): Map<string, McpClientEntry>;
+    /**
+     * 检查是否已连接
+     */
+    isConnected(name: string): boolean;
+}
+//# sourceMappingURL=loader.d.ts.map