@ai-setting/roy-agent-core 1.0.0

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

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

@@ -0,0 +1,246 @@
+/**
+ * @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;
+  }
+}