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

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

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { McpComponent } from "./mcp-component.js";
+/**
+ * TDD RED: 测试 McpComponent
+ *
+ * 注意：不要 mock BaseComponent，因为它会影响其他测试文件。
+ * 如果需要 mock 行为，应该使用 vi.spyOn 或创建测试专用的子类。
+ */
+describe("McpComponent", () => {
+    let component;
+    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,
+                    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;
+    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,
+                config: {
+                    enabled: false,
+                    mcpPaths: [],
+                },
+            },
+        });
+        // With disabled config and no paths, should handle gracefully
+        expect(component.getStatus()).toBeDefined();
+    });
+});
+//# sourceMappingURL=mcp-component.test.js.map

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

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview MCP Component 配置注册
+ *
+ * 使用 ConfigComponent.registerComponent() 机制统一管理配置
+ */
+import type { ComponentRegistration } from "../../config/config-component";
+/**
+ * MCP Component 默认配置值
+ *
+ * 注意：这些默认值需要在 McpComponent.registerConfig() 中
+ * 通过 configComponent.set() 设置到 ConfigComponent
+ */
+export declare const MCP_DEFAULTS: Record<string, unknown>;
+/**
+ * MCP Component 配置注册常量
+ *
+ * 定义了所有 MCP 相关的配置项和来源
+ */
+export declare const MCP_CONFIG_REGISTRATION: ComponentRegistration;
+//# sourceMappingURL=mcp-config-registration.d.ts.map

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

@@ -0,0 +1,45 @@
+/**
+ * @fileoverview MCP Component 配置注册
+ *
+ * 使用 ConfigComponent.registerComponent() 机制统一管理配置
+ */
+import path from "path";
+import os from "os";
+/**
+ * MCP Component 默认配置值
+ *
+ * 注意：这些默认值需要在 McpComponent.registerConfig() 中
+ * 通过 configComponent.set() 设置到 ConfigComponent
+ */
+export const MCP_DEFAULTS = {
+    "mcp.enabled": true,
+    "mcp.timeout": 30000,
+    "mcp.mcpPaths": [
+        {
+            type: "user",
+            path: path.join(os.homedir(), ".config", "roy-agent", "mcp"),
+        },
+        {
+            type: "project",
+            path: ".roy/mcp",
+        },
+    ],
+};
+/**
+ * MCP Component 配置注册常量
+ *
+ * 定义了所有 MCP 相关的配置项和来源
+ */
+export const MCP_CONFIG_REGISTRATION = {
+    name: "mcp",
+    sources: [
+        { type: "env", envPrefix: "MCP", priority: 20, watch: false },
+    ],
+    keys: [
+        { key: "mcp.enabled", sources: ["memory", "env", "file"] },
+        { key: "mcp.timeout", sources: ["memory", "env", "file"] },
+        { key: "mcp.mcpPaths", sources: ["memory", "env", "file"] },
+        { key: "mcp.servers", sources: ["memory", "env", "file"] },
+    ],
+};
+//# sourceMappingURL=mcp-config-registration.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview MCP Component 配置注册测试
+ *
+ * TDD: 先写测试，验证配置注册机制
+ */
+export {};
+//# sourceMappingURL=mcp-config-registration.test.d.ts.map

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

@@ -0,0 +1,258 @@
+/**
+ * @fileoverview MCP Component 配置注册测试
+ *
+ * TDD: 先写测试，验证配置注册机制
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { ConfigComponent } from "../../config/config-component.js";
+import { McpComponent } from "./mcp-component.js";
+import { MCP_CONFIG_REGISTRATION, MCP_DEFAULTS } from "./mcp-config-registration.js";
+describe("MCP Config Registration", () => {
+    let configComponent;
+    let component;
+    beforeEach(() => {
+        configComponent = new ConfigComponent();
+    });
+    describe("MCP_CONFIG_REGISTRATION", () => {
+        it("应该包含正确的 name", () => {
+            expect(MCP_CONFIG_REGISTRATION.name).toBe("mcp");
+        });
+        it("应该包含 env source 配置", () => {
+            const envSource = MCP_CONFIG_REGISTRATION.sources.find((s) => s.type === "env");
+            expect(envSource).toBeDefined();
+            expect(envSource?.envPrefix).toBe("MCP");
+            expect(envSource?.priority).toBe(20);
+        });
+        it("应该包含所有配置 keys", () => {
+            const keys = MCP_CONFIG_REGISTRATION.keys;
+            expect(keys).toContainEqual(expect.objectContaining({ key: "mcp.enabled" }));
+            expect(keys).toContainEqual(expect.objectContaining({ key: "mcp.timeout" }));
+            expect(keys).toContainEqual(expect.objectContaining({ key: "mcp.mcpPaths" }));
+            expect(keys).toContainEqual(expect.objectContaining({ key: "mcp.servers" }));
+        });
+    });
+    describe("MCP_DEFAULTS", () => {
+        it("应该包含 enabled 默认值（完整格式）", () => {
+            expect(MCP_DEFAULTS["mcp.enabled"]).toBe(true);
+        });
+        it("应该包含 timeout 默认值（完整格式）", () => {
+            expect(MCP_DEFAULTS["mcp.timeout"]).toBe(30000);
+        });
+        it("应该包含 mcpPaths 默认值（完整格式）", () => {
+            expect(MCP_DEFAULTS["mcp.mcpPaths"]).toBeDefined();
+            expect(Array.isArray(MCP_DEFAULTS["mcp.mcpPaths"])).toBe(true);
+        });
+    });
+    describe("配置注册到 ConfigComponent", () => {
+        it("应该能够注册 MCP_CONFIG_REGISTRATION", () => {
+            configComponent.registerComponent(MCP_CONFIG_REGISTRATION);
+            expect(() => configComponent.registerComponent(MCP_CONFIG_REGISTRATION)).not.toThrow();
+        });
+    });
+    describe("环境变量覆盖", () => {
+        it("应该能够通过环境变量覆盖配置", async () => {
+            // 设置环境变量
+            const originalValue = process.env.MCP_MCP_ENABLED;
+            process.env.MCP_MCP_ENABLED = "false";
+            try {
+                // 创建组件实例（使用模拟 env）
+                const mockEnv = {
+                    name: "mock-env",
+                    version: "1.0.0",
+                    getConfig: () => ({ name: "mock-env", version: "1.0.0", enabled: true }),
+                    registerComponent: () => { },
+                    unregisterComponent: () => { },
+                    getComponent: () => undefined,
+                    hasComponent: () => false,
+                    listComponents: () => [],
+                    handle_query: async () => "",
+                    handle_action: async () => ({ success: true, output: "" }),
+                    subscribe: () => () => { },
+                    subscribeTo: () => () => { },
+                    subscribeAll: () => () => { },
+                    pushEnvEvent: () => { },
+                    logger: () => { },
+                    trace: () => { },
+                };
+                component = new McpComponent();
+                await component.init({
+                    name: "mcp",
+                    version: "1.0.0",
+                    enabled: true,
+                    env: mockEnv,
+                    options: {
+                        configComponent,
+                    },
+                });
+                expect(component.name).toBe("mcp");
+            }
+            finally {
+                // 恢复环境变量
+                if (originalValue !== undefined) {
+                    process.env.MCP_MCP_ENABLED = originalValue;
+                }
+                else {
+                    delete process.env.MCP_MCP_ENABLED;
+                }
+                // 清理组件
+                if (component) {
+                    await component.stop();
+                }
+            }
+        });
+    });
+    describe("核心验收标准 - registerConfig 应使用 ConfigComponent 模式", () => {
+        let configComponent;
+        beforeEach(() => {
+            configComponent = new ConfigComponent();
+        });
+        it("应使用 registerComponent(MCP_CONFIG_REGISTRATION) 注册配置", async () => {
+            // 设置环境变量以测试环境变量加载
+            const originalEnabled = process.env.MCP_MCP_ENABLED;
+            process.env.MCP_MCP_ENABLED = "false";
+            try {
+                const mockEnv = createMockEnv();
+                component = new McpComponent();
+                await component.init({
+                    name: "mcp",
+                    version: "1.0.0",
+                    enabled: true,
+                    env: mockEnv,
+                    options: {
+                        configComponent,
+                    },
+                });
+                // 验证 MCP_DEFAULTS 已通过 registerComponent 注册到 ConfigComponent
+                // 检查默认值是否存在于内存中
+                const defaultEnabled = configComponent.get("mcp.enabled");
+                const defaultTimeout = configComponent.get("mcp.timeout");
+                // 由于环境变量 MCP_MCP_ENABLED=false 设置了，enabled 应该被覆盖
+                const enabled = configComponent.get("mcp.enabled");
+                expect(enabled).toBe(false);
+                // 但 timeout 应该仍然是默认值
+                expect(defaultTimeout).toBe(30000);
+            }
+            finally {
+                if (originalEnabled !== undefined) {
+                    process.env.MCP_MCP_ENABLED = originalEnabled;
+                }
+                else {
+                    delete process.env.MCP_MCP_ENABLED;
+                }
+                if (component) {
+                    await component.stop();
+                }
+            }
+        });
+        it("应使用 await configComponent.load('mcp') 加载配置", async () => {
+            const mockEnv = createMockEnv();
+            component = new McpComponent();
+            await component.init({
+                name: "mcp",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                },
+            });
+            // 验证默认值被正确加载
+            const timeout = configComponent.get("mcp.timeout");
+            expect(timeout).toBe(30000);
+        });
+        it("应设置默认值 MCP_DEFAULTS", async () => {
+            const mockEnv = createMockEnv();
+            component = new McpComponent();
+            await component.init({
+                name: "mcp",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                },
+            });
+            // 验证默认配置值
+            const enabled = configComponent.get("mcp.enabled");
+            const timeout = configComponent.get("mcp.timeout");
+            const mcpPaths = configComponent.get("mcp.mcpPaths");
+            expect(enabled).toBe(true);
+            expect(timeout).toBe(30000);
+            expect(mcpPaths).toBeDefined();
+            expect(Array.isArray(mcpPaths)).toBe(true);
+        });
+        it("应处理 config 对象作为最高优先级", async () => {
+            const mockEnv = createMockEnv();
+            component = new McpComponent();
+            const customConfig = {
+                mcpPaths: [
+                    { type: "custom", path: "/custom/path" }
+                ],
+                timeout: 60000,
+                enabled: true,
+            };
+            await component.init({
+                name: "mcp",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    config: customConfig,
+                },
+            });
+            // 验证 config 对象被正确处理（不被覆盖）
+            const timeout = configComponent.get("mcp.timeout");
+            expect(timeout).toBe(60000);
+        });
+        it("应处理环境变量后备方案", async () => {
+            // 清除可能的环境变量
+            delete process.env.MCP_MCP_ENABLED;
+            delete process.env.MCP_MCP_TIMEOUT;
+            delete process.env.MCP_MCP_MCP_PATHS;
+            const mockEnv = createMockEnv();
+            component = new McpComponent();
+            await component.init({
+                name: "mcp",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                },
+            });
+            // 在没有环境变量的情况下，应使用默认值
+            const enabled = configComponent.get("mcp.enabled");
+            const timeout = configComponent.get("mcp.timeout");
+            expect(enabled).toBe(true);
+            expect(timeout).toBe(30000);
+            if (component) {
+                await component.stop();
+            }
+        });
+    });
+    /**
+     * 创建模拟 Env 对象
+     */
+    function createMockEnv() {
+        return {
+            name: "mock-env",
+            version: "1.0.0",
+            getConfig: () => ({ name: "mock-env", version: "1.0.0", enabled: true }),
+            registerComponent: () => { },
+            unregisterComponent: () => { },
+            getComponent: () => undefined,
+            hasComponent: () => false,
+            listComponents: () => [],
+            handle_query: async () => "",
+            handle_action: async () => ({ success: true, output: "" }),
+            subscribe: () => () => { },
+            subscribeTo: () => () => { },
+            subscribeAll: () => () => { },
+            pushEnvEvent: () => { },
+            logger: () => { },
+            trace: () => { },
+        };
+    }
+});
+//# sourceMappingURL=mcp-config-registration.test.js.map

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

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview MCP 服务器路径扫描器
+ *
+ * 扫描 mcpPaths 目录，发现所有 MCP 服务器
+ * 每个子目录视为一个 MCP 服务器
+ */
+import type { McpPath } from "./config";
+import type { DiscoveredMcpServer } from "./types";
+/**
+ * MCP 服务器扫描器
+ *
+ * 扫描多个路径下的 MCP 服务器子目录
+ */
+export declare class McpScanner {
+    private mcpPaths;
+    private serversMap;
+    constructor(mcpPaths: McpPath[]);
+    /**
+     * 扫描所有 mcpPaths
+     */
+    scan(): Promise<Map<string, DiscoveredMcpServer>>;
+    /**
+     * 扫描单个路径
+     */
+    private scanPath;
+    /**
+     * 发现单个 MCP 服务器
+     */
+    private discoverServer;
+    /**
+     * 查找入口脚本
+     */
+    private findEntryScript;
+    /**
+     * 获取扫描结果
+     */
+    getServers(): Map<string, DiscoveredMcpServer>;
+}
+//# sourceMappingURL=scanner.d.ts.map

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

@@ -0,0 +1,206 @@
+/**
+ * @fileoverview MCP 服务器路径扫描器
+ *
+ * 扫描 mcpPaths 目录，发现所有 MCP 服务器
+ * 每个子目录视为一个 MCP 服务器
+ */
+import fs from "fs/promises";
+import path from "path";
+import { createLogger } from "../log-trace/logger.js";
+const logger = createLogger("mcp-scanner");
+/**
+ * 入口脚本候选文件名
+ */
+const ENTRY_SCRIPT_CANDIDATES = [
+    "server.mjs",
+    "server.ts",
+    "server.js",
+    "index.mjs",
+    "index.ts",
+    "index.js",
+    "src/server.mjs",
+    "src/server.ts",
+    "src/server.js",
+    "src/index.mjs",
+    "src/index.ts",
+    "src/index.js",
+];
+/**
+ * 展开路径（支持 ~ 展开）
+ */
+function expandPath(inputPath) {
+    if (inputPath.startsWith("~/")) {
+        const home = process.env.HOME || process.env.USERPROFILE || "";
+        return path.join(home, inputPath.slice(2));
+    }
+    return path.resolve(inputPath);
+}
+/**
+ * 检查路径是否存在
+ */
+async function pathExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 解析 config.jsonc 文件内容
+ */
+async function parseConfigJsonc(configPath) {
+    try {
+        const configContent = await fs.readFile(configPath, "utf-8");
+        const cleaned = configContent
+            .replace(/\/\*[\s\S]*?\*\//g, "") // 移除多行注释
+            .replace(/^\s*\/\/.*$/gm, ""); // 移除单行注释
+        return JSON.parse(cleaned);
+    }
+    catch (error) {
+        logger.warn(`[McpScanner] Failed to parse config: ${configPath}`, { error });
+        return undefined;
+    }
+}
+/**
+ * 构建入口脚本的默认命令
+ *
+ * 如果 config.jsonc 中有 command，检查其路径是否兼容
+ * 否则使用 entryPath
+ *
+ * 路径兼容性规则：
+ * - 绝对路径：直接使用
+ * - 相对路径且存在对应文件：使用 entryPath
+ * - 相对路径但不存在：使用 entryPath
+ */
+function buildDefaultCommand(entryPath, directoryConfig, serverDir) {
+    // 如果 config 中有 command
+    if (directoryConfig?.command) {
+        const cmd = directoryConfig.command;
+        const cmdPath = cmd[cmd.length - 1];
+        // 检查是否是绝对路径
+        if (cmdPath?.startsWith("/")) {
+            // 绝对路径，直接使用
+            return cmd;
+        }
+        // 相对路径：检查是否与 entryPath 匹配
+        if (cmdPath && entryPath) {
+            // 解析相对路径
+            const resolvedConfigPath = path.resolve(serverDir, cmdPath);
+            // 如果路径匹配，使用 entryPath
+            if (resolvedConfigPath === entryPath || cmdPath === "src/index.ts" || cmdPath === "src/index.js") {
+                return ["bun", "run", entryPath];
+            }
+        }
+        // 其他情况：如果有 entryPath，使用它
+        if (entryPath) {
+            return ["bun", "run", entryPath];
+        }
+        // 没有 entryPath，使用原始命令
+        return cmd;
+    }
+    // 使用 entryPath
+    return entryPath ? ["bun", "run", entryPath] : undefined;
+}
+/**
+ * MCP 服务器扫描器
+ *
+ * 扫描多个路径下的 MCP 服务器子目录
+ */
+export class McpScanner {
+    mcpPaths;
+    serversMap;
+    constructor(mcpPaths) {
+        this.mcpPaths = mcpPaths;
+        this.serversMap = new Map();
+    }
+    /**
+     * 扫描所有 mcpPaths
+     */
+    async scan() {
+        this.serversMap.clear();
+        for (const mcpPath of this.mcpPaths) {
+            await this.scanPath(mcpPath);
+        }
+        logger.info(`[McpScanner] Scanned ${this.serversMap.size} MCP servers`);
+        return this.serversMap;
+    }
+    /**
+     * 扫描单个路径
+     */
+    async scanPath(mcpPath) {
+        const expandedPath = expandPath(mcpPath.path);
+        if (!(await pathExists(expandedPath))) {
+            logger.info(`[McpScanner] Path not found, skipping: ${expandedPath}`);
+            return;
+        }
+        logger.info(`[McpScanner] Scanning: ${expandedPath}`);
+        try {
+            const entries = await fs.readdir(expandedPath, { withFileTypes: true });
+            for (const entry of entries) {
+                // Handle symlinks - check if the target is a directory
+                const fullPath = path.join(expandedPath, entry.name);
+                const stat = await fs.stat(fullPath);
+                // Skip non-directories (but allow symlinked directories)
+                if (!stat.isDirectory())
+                    continue;
+                await this.discoverServer(entry.name, fullPath, mcpPath.type);
+            }
+        }
+        catch (error) {
+            logger.warn(`[McpScanner] Failed to scan path: ${expandedPath}`, { error });
+        }
+    }
+    /**
+     * 发现单个 MCP 服务器
+     */
+    async discoverServer(name, serverDir, sourceType) {
+        // 查找入口脚本
+        const entryPath = await this.findEntryScript(serverDir);
+        // 查找配置文件
+        const configPath = path.join(serverDir, "config.jsonc");
+        const packagePath = path.join(serverDir, "package.json");
+        // 加载目录配置
+        let directoryConfig;
+        if (await pathExists(configPath)) {
+            directoryConfig = await parseConfigJsonc(configPath);
+        }
+        // 构建默认命令（如果 config 中的路径不兼容）
+        const defaultCommand = buildDefaultCommand(entryPath, directoryConfig, serverDir);
+        const server = {
+            name,
+            entryPath: entryPath || undefined,
+            configPath: await pathExists(configPath) ? configPath : undefined,
+            packagePath: await pathExists(packagePath) ? packagePath : undefined,
+            directoryConfig,
+            defaultCommand,
+        };
+        // 检测路径冲突
+        if (this.serversMap.has(name)) {
+            logger.warn(`[McpScanner] Server "${name}" already discovered, skipping duplicate from ${sourceType}`);
+            return;
+        }
+        this.serversMap.set(name, server);
+        logger.debug(`[McpScanner] Discovered server: ${name} from ${sourceType}`);
+    }
+    /**
+     * 查找入口脚本
+     */
+    async findEntryScript(serverDir) {
+        for (const candidate of ENTRY_SCRIPT_CANDIDATES) {
+            const entryPath = path.join(serverDir, candidate);
+            if (await pathExists(entryPath)) {
+                return entryPath;
+            }
+        }
+        return null;
+    }
+    /**
+     * 获取扫描结果
+     */
+    getServers() {
+        return this.serversMap;
+    }
+}
+//# sourceMappingURL=scanner.js.map

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

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