@ai-setting/roy-agent-core 1.3.9 → 1.3.11

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

@@ -1,170 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "fs/promises";
-import path from "path";
-import os from "os";
-import { McpScanner } from "./scanner";
-import type { McpPath } from "./config";
-
-/**
- * TDD RED: 测试 McpScanner
- */
-
-describe("McpScanner", () => {
-  const tempDir = path.join(os.tmpdir(), "mcp-scanner-test-" + Date.now());
-
-  beforeEach(async () => {
-    await fs.mkdir(tempDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-
-  describe("scan", () => {
-    it("should return empty map when path does not exist", async () => {
-      const scanner = new McpScanner([
-        { type: "user" as const, path: "/non/existent/path" },
-      ]);
-      const servers = await scanner.scan();
-      expect(servers.size).toBe(0);
-    });
-
-    it("should discover servers from directory", async () => {
-      // 创建测试目录结构
-      await fs.mkdir(path.join(tempDir, "test-mcp"));
-      await fs.writeFile(
-        path.join(tempDir, "test-mcp", "server.ts"),
-        "console.log('hello')"
-      );
-
-      const scanner = new McpScanner([
-        { type: "user" as const, path: tempDir },
-      ]);
-      const servers = await scanner.scan();
-
-      expect(servers.size).toBe(1);
-      expect(servers.has("test-mcp")).toBe(true);
-    });
-
-    it("should find entryPath for discovered server", async () => {
-      await fs.mkdir(path.join(tempDir, "my-server"));
-      await fs.writeFile(
-        path.join(tempDir, "my-server", "server.ts"),
-        "export default {}"
-      );
-
-      const scanner = new McpScanner([
-        { type: "user" as const, path: tempDir },
-      ]);
-      const servers = await scanner.scan();
-
-      const server = servers.get("my-server");
-      expect(server?.entryPath).toContain("server.ts");
-    });
-
-    it("should skip non-directory entries", async () => {
-      await fs.writeFile(path.join(tempDir, "not-a-server.txt"), "content");
-
-      const scanner = new McpScanner([
-        { type: "user" as const, path: tempDir },
-      ]);
-      const servers = await scanner.scan();
-
-      expect(servers.size).toBe(0);
-    });
-
-    it("should find index.ts as entry point", async () => {
-      await fs.mkdir(path.join(tempDir, "index-server"));
-      await fs.writeFile(
-        path.join(tempDir, "index-server", "index.ts"),
-        "export default {}"
-      );
-
-      const scanner = new McpScanner([
-        { type: "user" as const, path: tempDir },
-      ]);
-      const servers = await scanner.scan();
-
-      const server = servers.get("index-server");
-      expect(server?.entryPath).toContain("index.ts");
-    });
-
-    it("should load config.jsonc if exists", async () => {
-      await fs.mkdir(path.join(tempDir, "config-server"));
-      await fs.writeFile(
-        path.join(tempDir, "config-server", "server.ts"),
-        "export default {}"
-      );
-      await fs.writeFile(
-        path.join(tempDir, "config-server", "config.jsonc"),
-        JSON.stringify({ enabled: true, timeout: 60000 })
-      );
-
-      const scanner = new McpScanner([
-        { type: "user" as const, path: tempDir },
-      ]);
-      const servers = await scanner.scan();
-
-      const server = servers.get("config-server");
-      expect(server?.configPath).toContain("config.jsonc");
-      expect(server?.directoryConfig?.enabled).toBe(true);
-    });
-
-    it("should support multiple paths", async () => {
-      const tempDir2 = path.join(os.tmpdir(), "mcp-scanner-test2-" + Date.now());
-      await fs.mkdir(tempDir2, { recursive: true });
-
-      await fs.mkdir(path.join(tempDir, "server1"));
-      await fs.writeFile(
-        path.join(tempDir, "server1", "server.ts"),
-        "export default {}"
-      );
-
-      await fs.mkdir(path.join(tempDir2, "server2"));
-      await fs.writeFile(
-        path.join(tempDir2, "server2", "server.ts"),
-        "export default {}"
-      );
-
-      const scanner = new McpScanner([
-        { type: "user" as const, path: tempDir },
-        { type: "custom" as const, path: tempDir2 },
-      ]);
-      const servers = await scanner.scan();
-
-      expect(servers.size).toBe(2);
-      expect(servers.has("server1")).toBe(true);
-      expect(servers.has("server2")).toBe(true);
-
-      await fs.rm(tempDir2, { recursive: true, force: true });
-    });
-  });
-
-  describe("getServers", () => {
-    it("should return scanned servers", async () => {
-      await fs.mkdir(path.join(tempDir, "cached-server"));
-      await fs.writeFile(
-        path.join(tempDir, "cached-server", "server.ts"),
-        "export default {}"
-      );
-
-      const scanner = new McpScanner([
-        { type: "user" as const, path: tempDir },
-      ]);
-      await scanner.scan();
-
-      const servers = scanner.getServers();
-      expect(servers.size).toBe(1);
-      expect(servers.has("cached-server")).toBe(true);
-    });
-
-    it("should return empty map before scan", () => {
-      const scanner = new McpScanner([
-        { type: "user" as const, path: tempDir },
-      ]);
-
-      const servers = scanner.getServers();
-      expect(servers.size).toBe(0);
-    });
-  });
-});

package/src/env/mcp/scanner.ts

@@ -1,246 +0,0 @@
-/**
- * @fileoverview MCP 服务器路径扫描器
- * 
- * 扫描 mcpPaths 目录，发现所有 MCP 服务器
- * 每个子目录视为一个 MCP 服务器
- */
-
-import fs from "fs/promises";
-import path from "path";
-import { createLogger } from "../log-trace/logger";
-import type { McpPath } from "./config";
-import type { DiscoveredMcpServer } from "./types";
-
-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: string): string {
-  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: string): Promise<boolean> {
-  try {
-    await fs.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * 解析 config.jsonc 文件内容
- */
-async function parseConfigJsonc(configPath: string): Promise<Record<string, unknown> | undefined> {
-  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: string | null,
-  directoryConfig: Record<string, unknown> | undefined,
-  serverDir: string
-): string[] | undefined {
-  // 如果 config 中有 command
-  if (directoryConfig?.command) {
-    const cmd = directoryConfig.command as string[];
-    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 {
-  private mcpPaths: McpPath[];
-  private serversMap: Map<string, DiscoveredMcpServer>;
-
-  constructor(mcpPaths: McpPath[]) {
-    this.mcpPaths = mcpPaths;
-    this.serversMap = new Map();
-  }
-
-  /**
-   * 扫描所有 mcpPaths
-   */
-  async scan(): Promise<Map<string, DiscoveredMcpServer>> {
-    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;
-  }
-
-  /**
-   * 扫描单个路径
-   */
-  private async scanPath(mcpPath: McpPath): Promise<void> {
-    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 服务器
-   */
-  private async discoverServer(
-    name: string,
-    serverDir: string,
-    sourceType: string
-  ): Promise<void> {
-    // 查找入口脚本
-    const entryPath = await this.findEntryScript(serverDir);
-
-    // 查找配置文件
-    const configPath = path.join(serverDir, "config.jsonc");
-    const packagePath = path.join(serverDir, "package.json");
-
-    // 加载目录配置
-    let directoryConfig: Record<string, unknown> | undefined;
-    if (await pathExists(configPath)) {
-      directoryConfig = await parseConfigJsonc(configPath);
-    }
-
-    // 构建默认命令（如果 config 中的路径不兼容）
-    const defaultCommand = buildDefaultCommand(entryPath, directoryConfig, serverDir);
-
-    const server: DiscoveredMcpServer = {
-      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}`);
-  }
-
-  /**
-   * 查找入口脚本
-   */
-  private async findEntryScript(serverDir: string): Promise<string | null> {
-    for (const candidate of ENTRY_SCRIPT_CANDIDATES) {
-      const entryPath = path.join(serverDir, candidate);
-      if (await pathExists(entryPath)) {
-        return entryPath;
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * 获取扫描结果
-   */
-  getServers(): Map<string, DiscoveredMcpServer> {
-    return this.serversMap;
-  }
-}