@ai-setting/roy-agent-core 1.5.15-test → 1.5.17-beta.1

package/dist/shared/@ai-setting/roy-agent-core-pjr12nnd.js

@@ -0,0 +1,587 @@
+import {
+  ComponentError,
+  ErrorCodes
+} from "./roy-agent-core-ctdhjv68.js";
+import {
+  adaptMcpTool
+} from "./roy-agent-core-1akcqxj9.js";
+import {
+  toEnvKey
+} from "./roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-kkbwepqb.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-44hnfb02.js";
+
+// src/env/mcp/types.ts
+import { z } from "zod";
+var McpServerLocalConfigSchema = z.object({
+  type: z.literal("local"),
+  command: z.array(z.string()).min(1),
+  environment: z.record(z.string(), z.string()).optional(),
+  enabled: z.boolean().optional().default(true),
+  timeout: z.number().int().positive().optional()
+});
+var McpServerRemoteConfigSchema = z.object({
+  type: z.literal("remote"),
+  url: z.string().url(),
+  enabled: z.boolean().optional().default(true),
+  headers: z.record(z.string(), z.string()).optional(),
+  timeout: z.number().int().positive().optional()
+});
+var McpServerConfigSchema = z.discriminatedUnion("type", [
+  McpServerLocalConfigSchema,
+  McpServerRemoteConfigSchema
+]);
+// src/env/mcp/config.ts
+import path from "path";
+import os from "os";
+import { z as z2 } from "zod";
+var McpPathSchema = z2.object({
+  type: z2.enum(["user", "project", "custom"]),
+  path: z2.string()
+});
+var McpComponentConfigSchema = z2.object({
+  mcpPaths: z2.array(McpPathSchema),
+  servers: z2.record(z2.string(), z2.any()).optional(),
+  timeout: z2.number().int().positive().optional(),
+  enabled: z2.boolean().optional()
+});
+var DEFAULT_MCP_CONFIG = {
+  mcpPaths: [
+    {
+      type: "user",
+      path: path.join(os.homedir(), ".config", "roy-agent", "mcp")
+    },
+    {
+      type: "project",
+      path: ".roy/mcp"
+    }
+  ],
+  timeout: 30000,
+  enabled: true
+};
+var MCP_CONFIG_KEYS = [
+  "mcp.enabled",
+  "mcp.timeout",
+  "mcp.mcpPaths",
+  "mcp.servers"
+];
+var MCP_PATH_PRIORITY = {
+  user: 1,
+  project: 2,
+  custom: 3
+};
+function getMcpPathPriority(type) {
+  return MCP_PATH_PRIORITY[type] ?? 0;
+}
+// src/env/mcp/mcp-component.ts
+import { z as z3 } from "zod";
+init_logger();
+
+// src/env/mcp/scanner.ts
+init_logger();
+import fs from "fs/promises";
+import path2 from "path";
+var logger = createLogger("mcp-scanner");
+var 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 path2.join(home, inputPath.slice(2));
+  }
+  return path2.resolve(inputPath);
+}
+async function pathExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+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;
+  }
+}
+function buildDefaultCommand(entryPath, directoryConfig, serverDir) {
+  if (directoryConfig?.command) {
+    const cmd = directoryConfig.command;
+    const cmdPath = cmd[cmd.length - 1];
+    if (cmdPath?.startsWith("/")) {
+      return cmd;
+    }
+    if (cmdPath && entryPath) {
+      const resolvedConfigPath = path2.resolve(serverDir, cmdPath);
+      if (resolvedConfigPath === entryPath || cmdPath === "src/index.ts" || cmdPath === "src/index.js") {
+        return ["bun", "run", entryPath];
+      }
+    }
+    if (entryPath) {
+      return ["bun", "run", entryPath];
+    }
+    return cmd;
+  }
+  return entryPath ? ["bun", "run", entryPath] : undefined;
+}
+
+class McpScanner {
+  mcpPaths;
+  serversMap;
+  constructor(mcpPaths) {
+    this.mcpPaths = mcpPaths;
+    this.serversMap = new Map;
+  }
+  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) {
+        const fullPath = path2.join(expandedPath, entry.name);
+        const stat = await fs.stat(fullPath);
+        if (!stat.isDirectory())
+          continue;
+        await this.discoverServer(entry.name, fullPath, mcpPath.type);
+      }
+    } catch (error) {
+      logger.warn(`[McpScanner] Failed to scan path: ${expandedPath}`, { error });
+    }
+  }
+  async discoverServer(name, serverDir, sourceType) {
+    const entryPath = await this.findEntryScript(serverDir);
+    const configPath = path2.join(serverDir, "config.jsonc");
+    const packagePath = path2.join(serverDir, "package.json");
+    let directoryConfig;
+    if (await pathExists(configPath)) {
+      directoryConfig = await parseConfigJsonc(configPath);
+    }
+    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 = path2.join(serverDir, candidate);
+      if (await pathExists(entryPath)) {
+        return entryPath;
+      }
+    }
+    return null;
+  }
+  getServers() {
+    return this.serversMap;
+  }
+}
+
+// src/env/mcp/loader.ts
+init_logger();
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var logger2 = createLogger("mcp-loader");
+
+class McpLoader {
+  clients = new Map;
+  defaultTimeout;
+  constructor(defaultTimeout = 30000) {
+    this.defaultTimeout = defaultTimeout;
+  }
+  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;
+    }
+    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;
+  }
+  async connect(name, config) {
+    if (config.enabled === false) {
+      throw new Error(`MCP server ${name} is disabled`);
+    }
+    logger2.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);
+    logger2.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);
+      logger2.info(`[McpLoader] Disconnected from ${name}`);
+    } catch (error) {
+      logger2.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);
+  }
+}
+
+// src/env/mcp/mcp-config-registration.ts
+import path3 from "path";
+import os2 from "os";
+var MCP_DEFAULTS = {
+  "mcp.enabled": true,
+  "mcp.timeout": 30000,
+  "mcp.mcpPaths": [
+    {
+      type: "user",
+      path: path3.join(os2.homedir(), ".config", "roy-agent", "mcp")
+    },
+    {
+      type: "project",
+      path: ".roy/mcp"
+    }
+  ]
+};
+var 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"] }
+  ]
+};
+
+// src/env/mcp/mcp-component.ts
+var logger3 = createLogger("mcp");
+
+class McpComponent extends BaseComponent {
+  name = "mcp";
+  version = "1.0.0";
+  config;
+  toolComponent;
+  configComponent;
+  scanner;
+  loader;
+  serverStatus = new Map;
+  registeredTools = new Map;
+  constructor() {
+    super();
+  }
+  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);
+    logger3.info("[McpComponent] Initialized");
+  }
+  async start() {
+    await super.start();
+    this.toolComponent = this.env?.getComponent("tool");
+    if (!this.toolComponent) {
+      logger3.warn("[McpComponent] ToolComponent not found, skipping tool registration");
+    }
+    await this.loadServers();
+    this.setStatus("running");
+    logger3.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();
+    logger3.info("[McpComponent] Stopped");
+  }
+  async registerConfig(options) {
+    const configComponent = this.configComponent;
+    if (!configComponent)
+      return;
+    const { envPrefix, config } = options;
+    configComponent.registerComponent(MCP_CONFIG_REGISTRATION);
+    await configComponent.load("mcp");
+    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);
+        }
+      }
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    for (const [key, value] of Object.entries(MCP_DEFAULTS)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    const configData = {};
+    for (const key of MCP_CONFIG_KEYS) {
+      const value = configComponent.get(key);
+      if (value !== undefined) {
+        configData[key.replace(/^mcp\./, "")] = value;
+      }
+    }
+    if (config) {
+      Object.assign(configData, config);
+    }
+    const parsed = z3.object({
+      mcpPaths: z3.array(z3.object({
+        type: z3.enum(["user", "project", "custom"]),
+        path: z3.string()
+      })),
+      servers: z3.record(z3.string(), z3.any()).optional(),
+      timeout: z3.number().optional(),
+      enabled: z3.boolean().optional()
+    }).safeParse(configData);
+    if (parsed.success) {
+      this.config = {
+        ...DEFAULT_MCP_CONFIG,
+        ...parsed.data
+      };
+    } else {
+      logger3.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;
+  }
+  async loadServers() {
+    if (!this.config.enabled) {
+      logger3.info("[McpComponent] MCP is disabled");
+      return;
+    }
+    if (!this.config.mcpPaths || this.config.mcpPaths.length === 0) {
+      logger3.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)
+        });
+        logger3.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);
+      }
+      logger3.info(`[McpComponent] Registered ${tools.length} tools from ${entry.name}`);
+    } catch (error) {
+      logger3.warn(`[McpComponent] Failed to list tools for ${entry.name}`, { error });
+    }
+    return tools;
+  }
+  getServerStatus(name) {
+    return this.serverStatus.get(name);
+  }
+  listServers() {
+    return Array.from(this.serverStatus.values());
+  }
+  listTools() {
+    return Array.from(this.registeredTools.values());
+  }
+  async reload() {
+    logger3.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();
+  }
+}
+export { McpServerLocalConfigSchema, McpServerRemoteConfigSchema, McpServerConfigSchema, DEFAULT_MCP_CONFIG, MCP_CONFIG_KEYS, getMcpPathPriority, McpScanner, McpLoader, McpComponent };