@ai-setting/roy-agent-core 1.5.14-test → 1.5.15-test

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

@@ -1,587 +0,0 @@
-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 };