@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

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

@@ -1,92 +0,0 @@
-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

@@ -1,20 +0,0 @@
-/**
- * @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

@@ -1,45 +0,0 @@
-/**
- * @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

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

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

@@ -1,258 +0,0 @@
-/**
- * @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

@@ -1,39 +0,0 @@
-/**
- * @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

@@ -1,206 +0,0 @@
-/**
- * @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

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