@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

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

@@ -0,0 +1,163 @@
+/**
+ * @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.js";
+const logger = createLogger("mcp-loader");
+/**
+ * MCP 服务器加载器
+ *
+ * 负责：
+ * 1. 构建默认配置
+ * 2. 合并显式配置
+ * 3. 连接/断开 MCP 服务器
+ */
+export class McpLoader {
+    clients = new Map();
+    defaultTimeout;
+    constructor(defaultTimeout = 30000) {
+        this.defaultTimeout = defaultTimeout;
+    }
+    /**
+     * 构建默认配置（从扫描结果）
+     *
+     * @param server - 扫描发现的 MCP 服务器信息
+     * @returns MCP 服务器配置
+     */
+    buildDefaultConfig(server) {
+        // 检查是否是远程配置
+        if (server.directoryConfig?.type === "remote") {
+            const remoteConfig = {
+                type: "remote",
+                url: server.directoryConfig.url,
+                enabled: server.directoryConfig.enabled ?? true,
+                headers: server.directoryConfig.headers,
+                timeout: server.directoryConfig.timeout ?? this.defaultTimeout,
+            };
+            return remoteConfig;
+        }
+        // 构建本地配置 - 优先使用 scanner 解析的 defaultCommand
+        const command = server.defaultCommand
+            ?? (server.entryPath
+                ? ["bun", "run", server.entryPath]
+                : ["bun", "run", server.name]);
+        const localConfig = {
+            type: "local",
+            command,
+            environment: server.directoryConfig?.environment,
+            enabled: server.directoryConfig?.enabled ?? true,
+            timeout: server.directoryConfig?.timeout ?? this.defaultTimeout,
+        };
+        return localConfig;
+    }
+    /**
+     * 合并配置（显式配置覆盖默认配置）
+     */
+    mergeConfig(defaultConfig, explicitConfig) {
+        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;
+    }
+    /**
+     * 连接到 MCP 服务器
+     */
+    async connect(name, config) {
+        if (config.enabled === false) {
+            throw new Error(`MCP server ${name} is disabled`);
+        }
+        logger.info(`[McpLoader] Connecting to ${name}...`);
+        let client;
+        let transport;
+        if (config.type === "local") {
+            const localConfig = config;
+            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;
+            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 = { name, client, transport, config };
+        this.clients.set(name, entry);
+        logger.info(`[McpLoader] Connected to ${name}`);
+        return entry;
+    }
+    /**
+     * 断开连接
+     */
+    async disconnect(name) {
+        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() {
+        for (const name of this.clients.keys()) {
+            await this.disconnect(name);
+        }
+    }
+    /**
+     * 获取客户端
+     */
+    getClient(name) {
+        return this.clients.get(name);
+    }
+    /**
+     * 获取所有客户端
+     */
+    getAllClients() {
+        return this.clients;
+    }
+    /**
+     * 检查是否已连接
+     */
+    isConnected(name) {
+        return this.clients.has(name);
+    }
+}
+//# sourceMappingURL=loader.js.map

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

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

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

@@ -0,0 +1,128 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { McpLoader } from "./loader.js";
+/**
+ * TDD RED: 测试 McpLoader
+ */
+describe("McpLoader", () => {
+    let loader;
+    beforeEach(() => {
+        loader = new McpLoader(30000);
+    });
+    describe("buildDefaultConfig", () => {
+        it("should build local config with bun run command", () => {
+            const server = {
+                name: "test-mcp",
+                entryPath: "/path/to/server.ts",
+            };
+            const config = loader.buildDefaultConfig(server);
+            expect(config.type).toBe("local");
+            expect(config.command).toEqual(["bun", "run", "/path/to/server.ts"]);
+        });
+        it("should use directoryConfig command if present", () => {
+            const server = {
+                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.command).toEqual(["node", "/path/to/server.js"]);
+        });
+        it("should build remote config from directoryConfig", () => {
+            const server = {
+                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.url).toBe("https://mcp.example.com");
+        });
+        it("should set enabled by default", () => {
+            const server = {
+                name: "test-mcp",
+            };
+            const config = loader.buildDefaultConfig(server);
+            expect(config.enabled).toBe(true);
+        });
+        it("should use directoryConfig timeout if present", () => {
+            const server = {
+                name: "test-mcp",
+                directoryConfig: {
+                    timeout: 60000,
+                },
+            };
+            const config = loader.buildDefaultConfig(server);
+            expect(config.timeout).toBe(60000);
+        });
+    });
+    describe("mergeConfig", () => {
+        it("should merge explicit config over default", () => {
+            const defaultConfig = {
+                type: "local",
+                command: ["bun", "run", "server.ts"],
+                enabled: true,
+            };
+            const merged = loader.mergeConfig(defaultConfig, {
+                timeout: 60000,
+            });
+            expect(merged.command).toEqual(["bun", "run", "server.ts"]);
+            expect(merged.timeout).toBe(60000);
+        });
+        it("should disable when explicit enabled is false", () => {
+            const defaultConfig = {
+                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 = {
+                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 = {
+                type: "local",
+                command: ["bun", "run", "server.ts"],
+                environment: { NODE_ENV: "development" },
+            };
+            const merged = loader.mergeConfig(defaultConfig, {
+                environment: { NODE_ENV: "production" },
+            });
+            expect(merged.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);
+        });
+    });
+});
+//# sourceMappingURL=loader.test.js.map

package/dist/core/src/env/mcp/mcp-component.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview MCP Component 主组件
+ *
+ * MCP 客户端管理组件
+ */
+import { BaseComponent, type ComponentConfig } from "../component";
+import type { McpServerStatus } from "./types";
+import type { ToolInfo } from "../tool/types";
+/**
+ * McpComponent
+ *
+ * MCP 客户端管理组件
+ *
+ * 功能：
+ * 1. 配置管理（支持 file/env/object 三层配置）
+ * 2. 扫描 MCP 服务器
+ * 3. 连接/断开 MCP 服务器
+ * 4. 注册 MCP tools 到 ToolComponent
+ */
+export declare class McpComponent extends BaseComponent {
+    readonly name = "mcp";
+    readonly version = "1.0.0";
+    private config;
+    private toolComponent?;
+    private configComponent?;
+    private scanner?;
+    private loader?;
+    private serverStatus;
+    private registeredTools;
+    constructor();
+    init(config?: ComponentConfig): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private registerConfig;
+    private flattenConfig;
+    private loadServers;
+    private registerServerTools;
+    /**
+     * 获取服务器状态
+     */
+    getServerStatus(name: string): McpServerStatus | undefined;
+    /**
+     * 列出所有服务器
+     */
+    listServers(): McpServerStatus[];
+    /**
+     * 列出所有 MCP 工具
+     */
+    listTools(): ToolInfo[];
+    /**
+     * 重新加载所有服务器
+     */
+    reload(): Promise<void>;
+}
+//# sourceMappingURL=mcp-component.d.ts.map

package/dist/core/src/env/mcp/mcp-component.js

@@ -0,0 +1,296 @@
+/**
+ * @fileoverview MCP Component 主组件
+ *
+ * MCP 客户端管理组件
+ */
+import { z } from "zod";
+import { BaseComponent } from "../component.js";
+import { createLogger } from "../log-trace/logger.js";
+import { McpScanner } from "./scanner.js";
+import { McpLoader } from "./loader.js";
+import { adaptMcpTool } from "./tool/adapter.js";
+import { ComponentError, ErrorCodes } from "../errors.js";
+import { DEFAULT_MCP_CONFIG, MCP_CONFIG_KEYS, } from "./config.js";
+import { MCP_CONFIG_REGISTRATION, MCP_DEFAULTS } from "./mcp-config-registration.js";
+import { toEnvKey } from "../../config/env-key.js";
+const logger = createLogger("mcp");
+/**
+ * McpComponent
+ *
+ * MCP 客户端管理组件
+ *
+ * 功能：
+ * 1. 配置管理（支持 file/env/object 三层配置）
+ * 2. 扫描 MCP 服务器
+ * 3. 连接/断开 MCP 服务器
+ * 4. 注册 MCP tools 到 ToolComponent
+ */
+export class McpComponent extends BaseComponent {
+    name = "mcp";
+    version = "1.0.0";
+    config;
+    toolComponent;
+    configComponent;
+    scanner;
+    loader;
+    serverStatus = new Map();
+    registeredTools = new Map();
+    constructor() {
+        super();
+    }
+    // ========================================================================
+    // Component Lifecycle
+    // ========================================================================
+    async init(config) {
+        await super.init(config);
+        const options = config?.options;
+        if (!options?.configComponent) {
+            throw new ComponentError("ConfigComponent is required for McpComponent initialization", ErrorCodes.MCP_INIT_FAILED);
+        }
+        this.configComponent = options.configComponent;
+        await this.registerConfig(options);
+        logger.info("[McpComponent] Initialized");
+    }
+    async start() {
+        await super.start();
+        // 获取 ToolComponent
+        this.toolComponent = this.env?.getComponent("tool");
+        if (!this.toolComponent) {
+            logger.warn("[McpComponent] ToolComponent not found, skipping tool registration");
+        }
+        // 扫描并连接 MCP 服务器
+        await this.loadServers();
+        this.setStatus("running");
+        logger.info(`[McpComponent] Started with ${this.serverStatus.size} servers`);
+    }
+    async stop() {
+        // 取消注册所有工具
+        for (const toolName of this.registeredTools.keys()) {
+            this.toolComponent?.unregister(toolName);
+        }
+        // 断开所有连接
+        if (this.loader) {
+            await this.loader.disconnectAll();
+        }
+        await super.stop();
+        logger.info("[McpComponent] Stopped");
+    }
+    // ========================================================================
+    // Configuration
+    // ========================================================================
+    async registerConfig(options) {
+        const configComponent = this.configComponent;
+        if (!configComponent)
+            return;
+        const { envPrefix, config } = options;
+        // 1. 使用 registerComponent 注册 MCP_CONFIG_REGISTRATION
+        // 这会自动注册 sources、keys 和 defaults
+        configComponent.registerComponent(MCP_CONFIG_REGISTRATION);
+        // 2. 加载配置（从 env/file 等来源）
+        // 注意：load() 不会覆盖内存中已有的默认值
+        await configComponent.load("mcp");
+        // 3. 处理环境变量覆盖（确保环境变量能覆盖默认值）
+        const prefix = envPrefix !== undefined ? envPrefix : "MCP";
+        for (const key of MCP_CONFIG_KEYS) {
+            const envKey = toEnvKey(key, prefix);
+            const value = process.env[envKey];
+            if (value !== undefined) {
+                try {
+                    await configComponent.set(key, JSON.parse(value));
+                }
+                catch {
+                    await configComponent.set(key, value);
+                }
+            }
+        }
+        // 4. 直接配置对象（最高优先级）
+        if (config) {
+            const flatConfig = this.flattenConfig(config);
+            for (const [key, value] of Object.entries(flatConfig)) {
+                await configComponent.set(key, value);
+            }
+        }
+        // 5. 设置默认值（只有当配置不存在时）
+        for (const [key, value] of Object.entries(MCP_DEFAULTS)) {
+            if (configComponent.get(key) === undefined) {
+                await configComponent.set(key, value);
+            }
+        }
+        // 6. 解析最终配置
+        const configData = {};
+        for (const key of MCP_CONFIG_KEYS) {
+            const value = configComponent.get(key);
+            if (value !== undefined) {
+                configData[key.replace(/^mcp\./, "")] = value;
+            }
+        }
+        // 合并直接传入的 config（最高优先级）
+        if (config) {
+            Object.assign(configData, config);
+        }
+        // 验证配置
+        const parsed = z.object({
+            mcpPaths: z.array(z.object({
+                type: z.enum(["user", "project", "custom"]),
+                path: z.string(),
+            })),
+            servers: z.record(z.string(), z.any()).optional(),
+            timeout: z.number().optional(),
+            enabled: z.boolean().optional(),
+        }).safeParse(configData);
+        if (parsed.success) {
+            this.config = {
+                ...DEFAULT_MCP_CONFIG,
+                ...parsed.data,
+            };
+        }
+        else {
+            logger.warn("[McpComponent] Invalid config, using defaults", {
+                errors: parsed.error.errors,
+            });
+            this.config = DEFAULT_MCP_CONFIG;
+        }
+    }
+    flattenConfig(obj, prefix = "mcp") {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            const configKey = `${prefix}.${key}`;
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                Object.assign(result, this.flattenConfig(value, configKey));
+            }
+            else {
+                result[configKey] = value;
+            }
+        }
+        return result;
+    }
+    // ========================================================================
+    // Server Management
+    // ========================================================================
+    async loadServers() {
+        if (!this.config.enabled) {
+            logger.info("[McpComponent] MCP is disabled");
+            return;
+        }
+        if (!this.config.mcpPaths || this.config.mcpPaths.length === 0) {
+            logger.info("[McpComponent] No MCP paths configured");
+            return;
+        }
+        // 初始化加载器和扫描器
+        this.loader = new McpLoader(this.config.timeout);
+        this.scanner = new McpScanner(this.config.mcpPaths);
+        // 扫描服务器
+        const discoveredServers = await this.scanner.scan();
+        // 连接每个服务器
+        for (const [name, server] of discoveredServers) {
+            const defaultConfig = this.loader.buildDefaultConfig(server);
+            const explicitConfig = this.config.servers?.[name];
+            const finalConfig = this.loader.mergeConfig(defaultConfig, explicitConfig);
+            if (finalConfig.enabled === false) {
+                this.serverStatus.set(name, {
+                    name,
+                    status: "disconnected",
+                    toolsCount: 0,
+                });
+                continue;
+            }
+            try {
+                const entry = await this.loader.connect(name, finalConfig);
+                const tools = await this.registerServerTools(entry);
+                this.serverStatus.set(name, {
+                    name,
+                    status: "connected",
+                    toolsCount: tools.length,
+                });
+            }
+            catch (error) {
+                this.serverStatus.set(name, {
+                    name,
+                    status: "error",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                logger.error(`[McpComponent] Failed to connect to ${name}`, { error });
+            }
+        }
+        // 处理配置中额外定义的服务器
+        for (const [name, serverConfig] of Object.entries(this.config.servers ?? {})) {
+            if (discoveredServers.has(name))
+                continue;
+            try {
+                const entry = await this.loader.connect(name, serverConfig);
+                const tools = await this.registerServerTools(entry);
+                this.serverStatus.set(name, {
+                    name,
+                    status: "connected",
+                    toolsCount: tools.length,
+                });
+            }
+            catch (error) {
+                this.serverStatus.set(name, {
+                    name,
+                    status: "error",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    async registerServerTools(entry) {
+        if (!this.toolComponent)
+            return [];
+        const tools = [];
+        try {
+            const listResult = await entry.client.listTools();
+            for (const mcpTool of listResult.tools) {
+                const tool = adaptMcpTool(mcpTool, entry.client, entry.name);
+                this.toolComponent.register(tool);
+                this.registeredTools.set(tool.name, tool);
+                tools.push(tool);
+            }
+            logger.info(`[McpComponent] Registered ${tools.length} tools from ${entry.name}`);
+        }
+        catch (error) {
+            logger.warn(`[McpComponent] Failed to list tools for ${entry.name}`, { error });
+        }
+        return tools;
+    }
+    // ========================================================================
+    // Public API
+    // ========================================================================
+    /**
+     * 获取服务器状态
+     */
+    getServerStatus(name) {
+        return this.serverStatus.get(name);
+    }
+    /**
+     * 列出所有服务器
+     */
+    listServers() {
+        return Array.from(this.serverStatus.values());
+    }
+    /**
+     * 列出所有 MCP 工具
+     */
+    listTools() {
+        return Array.from(this.registeredTools.values());
+    }
+    /**
+     * 重新加载所有服务器
+     */
+    async reload() {
+        logger.info("[McpComponent] Reloading...");
+        // 断开所有连接
+        if (this.loader) {
+            await this.loader.disconnectAll();
+        }
+        // 取消注册所有工具
+        for (const toolName of this.registeredTools.keys()) {
+            this.toolComponent?.unregister(toolName);
+        }
+        this.registeredTools.clear();
+        this.serverStatus.clear();
+        // 重新加载
+        await this.loadServers();
+    }
+}
+//# sourceMappingURL=mcp-component.js.map

package/dist/core/src/env/mcp/mcp-component.test.d.ts

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