dynmcp 0.0.1 → 0.1.1

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import process4 from "process";
+import process5 from "process";
 import { Command } from "commander";
 
 // package.json
 var package_default = {
   name: "dynmcp",
-  version: "0.0.1",
+  version: "0.1.1",
   description: "Dynamic MCP context management tool for AI MCP-enabled agents and clients.",
   author: "Brandon Burrus <brandon@burrus.io>",
   license: "MIT",
@@ -52,9 +52,12 @@ var package_default = {
     }
   },
   files: [
-    "dist"
+    "dist",
+    "schema"
   ],
   scripts: {
+    "generate:schema": "tsx scripts/generate-schema.ts",
+    prebuild: "tsx scripts/generate-schema.ts",
     build: "tsup",
     dev: "tsx src/index.ts",
     typecheck: "tsc --noEmit",
@@ -75,6 +78,7 @@ var package_default = {
     fastmcp: "^4.0.1",
     figlet: "^1.11.0",
     figures: "^6.1.0",
+    yaml: "^2.9.0",
     zod: "^4.4.3"
   },
   devDependencies: {
@@ -95,22 +99,147 @@ import figlet from "figlet";
 import chalk from "chalk";
 
 // src/proxy/index.ts
-import process3 from "process";
+import process4 from "process";
+import { StdioClientTransport as StdioClientTransport2 } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+// src/config/schema.ts
+import { z } from "zod";
+var MCP_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+var mcpName = z.string().regex(MCP_NAME_PATTERN);
+var stdioTransport = z.object({
+  transport: z.literal("stdio"),
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional()
+}).strict();
+var httpUrl = z.string().url().refine((u) => u.startsWith("http://") || u.startsWith("https://"), {
+  message: "URL must use http:// or https:// scheme"
+});
+var streamableHttpTransport = z.object({
+  transport: z.literal("streamable-http"),
+  url: httpUrl,
+  headers: z.record(z.string(), z.string()).optional()
+}).strict();
+var sseTransport = z.object({
+  transport: z.literal("sse"),
+  url: httpUrl,
+  headers: z.record(z.string(), z.string()).optional()
+}).strict();
+var transportConfig = z.discriminatedUnion("transport", [
+  stdioTransport,
+  streamableHttpTransport,
+  sseTransport
+]);
+var mcpConfigSchema = z.object({
+  mcp: z.record(mcpName, transportConfig).refine((obj) => Object.keys(obj).length > 0, { message: "At least one MCP must be configured" })
+});
+
+// src/config/loader.ts
+import { readFileSync } from "fs";
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { parse as parseYaml } from "yaml";
+var AUTO_DISCOVER_NAMES = ["mcp.json", ".mcp.json"];
+function resolveConfigPath(explicitPath) {
+  if (explicitPath) {
+    const resolved = resolve(explicitPath);
+    if (!existsSync(resolved)) {
+      throw new Error(`Config file not found: ${resolved}`);
+    }
+    return resolved;
+  }
+  const cwd = process.cwd();
+  for (const name of AUTO_DISCOVER_NAMES) {
+    const candidate = resolve(cwd, name);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  const searched = AUTO_DISCOVER_NAMES.map((n) => resolve(cwd, n)).join(", ");
+  throw new Error(`No config file found. Searched: ${searched}`);
+}
+function loadConfig(explicitPath) {
+  const configPath = resolveConfigPath(explicitPath);
+  const raw = readFileSync(configPath, "utf-8");
+  let content;
+  try {
+    content = isYamlFile(configPath) ? parseYaml(raw) : JSON.parse(raw);
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    throw new Error(`Failed to parse config file (${configPath}): ${message}`);
+  }
+  const result = mcpConfigSchema.safeParse(content);
+  if (!result.success) {
+    const formatted = result.error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join("\n");
+    throw new Error(`Invalid config file (${configPath}):
+${formatted}`);
+  }
+  return result.data;
+}
+function isYamlFile(filePath) {
+  return filePath.endsWith(".yml") || filePath.endsWith(".yaml");
+}
+
+// src/config/json-schema.ts
+import { z as z2 } from "zod";
+
+// src/proxy/transport-factory.ts
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+function createTransport(config) {
+  switch (config.transport) {
+    case "stdio":
+      return new StdioClientTransport({
+        command: config.command,
+        args: config.args,
+        env: config.env
+      });
+    case "streamable-http":
+      return new StreamableHTTPClientTransport(
+        new URL(config.url),
+        config.headers ? { requestInit: { headers: config.headers } } : void 0
+      );
+    case "sse":
+      return new SSEClientTransport(
+        new URL(config.url),
+        config.headers ? { requestInit: { headers: config.headers } } : void 0
+      );
+    default: {
+      const _exhaustive = config;
+      return _exhaustive;
+    }
+  }
+}
 
 // src/proxy/tool-catalog.ts
 var DISCOVER_TOOL_PREAMBLE = `Use this tool to look up the full schema of a tool before calling it with use_tool.
 Call discover_tool with a tool name from the list below to get its complete description,
 input parameters, and output schema. Always discover a tool before using it.`;
-var ToolCatalog = class {
+var ToolCatalog = class _ToolCatalog {
   tools;
   discoverToolDescription;
-  constructor(upstreamTools) {
+  constructor(tools, description) {
+    this.tools = tools;
+    this.discoverToolDescription = description;
+  }
+  static fromFlat(upstreamTools) {
     const toolMap = /* @__PURE__ */ new Map();
     for (const tool of upstreamTools) {
       toolMap.set(tool.name, tool);
     }
-    this.tools = toolMap;
-    this.discoverToolDescription = buildDiscoverToolDescription(upstreamTools);
+    const description = buildFlatDescription(upstreamTools);
+    return new _ToolCatalog(toolMap, description);
+  }
+  static fromGrouped(groups) {
+    const toolMap = /* @__PURE__ */ new Map();
+    for (const [mcpName2, tools] of groups) {
+      for (const tool of tools) {
+        toolMap.set(`${mcpName2}/${tool.name}`, tool);
+      }
+    }
+    const description = buildGroupedDescription(groups);
+    return new _ToolCatalog(toolMap, description);
   }
   getToolDetails(toolName) {
     const tool = this.tools.get(toolName);
@@ -118,10 +247,10 @@ var ToolCatalog = class {
       const sortedNames = [...this.tools.keys()].sort().join(", ");
       return `Unknown tool: "${toolName}". Available tools: ${sortedNames}`;
     }
-    return buildToolDetailsString(tool);
+    return buildToolDetailsString(toolName, tool);
   }
 };
-function buildDiscoverToolDescription(tools) {
+function buildFlatDescription(tools) {
   const sortedTools = [...tools].sort((a, b) => a.name.localeCompare(b.name));
   const toolLines = sortedTools.map((tool) => `- ${tool.name}: ${tool.description}`).join("\n");
   return `${DISCOVER_TOOL_PREAMBLE}
@@ -130,9 +259,24 @@ function buildDiscoverToolDescription(tools) {
 ${toolLines}
 </tools>`;
 }
-function buildToolDetailsString(tool) {
+function buildGroupedDescription(groups) {
+  const sortedMcpNames = [...groups.keys()].sort();
+  const sections = sortedMcpNames.map((mcpName2) => {
+    const tools = groups.get(mcpName2);
+    const sortedTools = [...tools].sort((a, b) => a.name.localeCompare(b.name));
+    const toolLines = sortedTools.map((tool) => `- ${mcpName2}/${tool.name}: ${tool.description}`).join("\n");
+    return `${mcpName2}:
+${toolLines}`;
+  });
+  return `${DISCOVER_TOOL_PREAMBLE}
+
+<tools>
+${sections.join("\n\n")}
+</tools>`;
+}
+function buildToolDetailsString(displayName, tool) {
   const lines = [
-    `Tool: ${tool.name}`,
+    `Tool: ${displayName}`,
     `Description: ${tool.description}`,
     "",
     "Input Schema:",
@@ -171,73 +315,21 @@ function buildAnnotationLines(tool) {
   return lines;
 }
 
-// src/proxy/server.ts
-import process from "process";
-import { FastMCP } from "fastmcp";
-import { z } from "zod";
-var ProxyServer = class {
-  catalog;
-  upstreamClient;
-  constructor({ catalog, upstreamClient }) {
-    this.catalog = catalog;
-    this.upstreamClient = upstreamClient;
-  }
-  async start() {
-    const server = new FastMCP({
-      name: "dynamic-discovery-mcp",
-      version: package_default.version
-    });
-    server.addTool({
-      name: "discover_tool",
-      description: this.catalog.discoverToolDescription,
-      parameters: z.object({ tool_name: z.string() }),
-      execute: async ({ tool_name }) => {
-        return this.catalog.getToolDetails(tool_name);
-      }
-    });
-    server.addTool({
-      name: "use_tool",
-      description: "Use a tool that was previously discovered with the discover_tool tool.",
-      parameters: z.object({
-        tool_name: z.string(),
-        tool_input: z.record(z.string(), z.unknown()).default({})
-      }),
-      execute: async ({ tool_name, tool_input }) => {
-        if (!this.catalog.tools.has(tool_name)) {
-          return this.catalog.getToolDetails(tool_name);
-        }
-        const result = await this.upstreamClient.callTool(tool_name, tool_input);
-        return result;
-      }
-    });
-    process.stderr.write("Starting dynamic-discovery-mcp server over stdio\n");
-    await server.start({ transportType: "stdio" });
-  }
-};
-
 // src/proxy/upstream-client.ts
 import process2 from "process";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 var UpstreamClient = class {
-  command;
-  args;
+  transport;
   onTransportError;
   client = null;
-  transport = null;
-  constructor({ command, args, onTransportError }) {
-    this.command = command;
-    this.args = args;
+  constructor({ name, transport, onTransportError }) {
+    this.transport = transport;
     this.onTransportError = onTransportError ?? ((error) => {
-      process2.stderr.write(`Upstream MCP transport error: ${error.message}
+      process2.stderr.write(`[${name}] Upstream MCP transport error: ${error.message}
 `);
     });
   }
   async connect() {
-    this.transport = new StdioClientTransport({
-      command: this.command,
-      args: this.args
-    });
     this.transport.onerror = this.onTransportError;
     this.client = new Client({ name: "dynamic-discovery-mcp", version: "1.0.0" });
     await this.client.connect(this.transport);
@@ -272,10 +364,8 @@ var UpstreamClient = class {
     if (this.client === null) {
       throw new Error("Client is not connected. Call connect() first.");
     }
-    return this.client.callTool({
-      name,
-      arguments: input
-    });
+    const result = await this.client.callTool({ name, arguments: input });
+    return result;
   }
   async disconnect() {
     if (this.client === null) {
@@ -283,54 +373,213 @@ var UpstreamClient = class {
     }
     await this.client.close();
     this.client = null;
-    this.transport = null;
+  }
+};
+
+// src/proxy/orchestrator.ts
+var Orchestrator = class {
+  config;
+  clients = /* @__PURE__ */ new Map();
+  toolCatalog = null;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    const groups = /* @__PURE__ */ new Map();
+    try {
+      for (const [mcpName2, { transport }] of this.config.mcps) {
+        const client = new UpstreamClient({
+          name: mcpName2,
+          transport,
+          onTransportError: (error) => {
+            this.config.onTransportError?.(mcpName2, error);
+          }
+        });
+        await client.connect();
+        const tools = await client.listTools();
+        this.clients.set(mcpName2, client);
+        groups.set(mcpName2, tools);
+      }
+    } catch (error) {
+      await this.disconnectAll();
+      throw error;
+    }
+    this.toolCatalog = ToolCatalog.fromGrouped(groups);
+  }
+  get catalog() {
+    if (this.toolCatalog === null) {
+      throw new Error("Orchestrator is not connected. Call connect() first.");
+    }
+    return this.toolCatalog;
+  }
+  async callTool(namespacedName, input) {
+    const separatorIndex = namespacedName.indexOf("/");
+    if (separatorIndex === -1) {
+      throw new Error(
+        `Invalid namespaced tool name: "${namespacedName}". Expected format: "mcpName/toolName".`
+      );
+    }
+    const mcpName2 = namespacedName.slice(0, separatorIndex);
+    const toolName = namespacedName.slice(separatorIndex + 1);
+    const client = this.clients.get(mcpName2);
+    if (client === void 0) {
+      const available = [...this.clients.keys()].sort().join(", ");
+      throw new Error(`Unknown MCP: "${mcpName2}". Available MCPs: ${available}`);
+    }
+    return client.callTool(toolName, input);
+  }
+  async disconnectAll() {
+    const disconnections = [...this.clients.values()].map((client) => client.disconnect());
+    await Promise.all(disconnections);
+    this.clients.clear();
+    this.toolCatalog = null;
+  }
+};
+
+// src/proxy/server.ts
+import process3 from "process";
+import { FastMCP } from "fastmcp";
+import { z as z3 } from "zod";
+var ProxyServer = class {
+  catalog;
+  callTool;
+  constructor({ catalog, callTool }) {
+    this.catalog = catalog;
+    this.callTool = callTool;
+  }
+  async start() {
+    const server = new FastMCP({
+      name: "dynamic-discovery-mcp",
+      version: package_default.version
+    });
+    server.addTool({
+      name: "discover_tool",
+      description: this.catalog.discoverToolDescription,
+      parameters: z3.object({ tool_name: z3.string() }),
+      execute: async ({ tool_name }) => {
+        return this.catalog.getToolDetails(tool_name);
+      }
+    });
+    server.addTool({
+      name: "use_tool",
+      description: "Use a tool that was previously discovered with the discover_tool tool.",
+      parameters: z3.object({
+        tool_name: z3.string(),
+        tool_input: z3.record(z3.string(), z3.unknown()).default({})
+      }),
+      execute: async ({ tool_name, tool_input }) => {
+        if (!this.catalog.tools.has(tool_name)) {
+          return this.catalog.getToolDetails(tool_name);
+        }
+        const result = await this.callTool(tool_name, tool_input);
+        return result;
+      }
+    });
+    process3.stderr.write("Starting dynamic-discovery-mcp server over stdio\n");
+    await server.start({ transportType: "stdio" });
   }
 };
 
 // src/proxy/index.ts
 async function startProxy(command, args) {
   let isShuttingDown = false;
+  const transport = new StdioClientTransport2({ command, args });
+  const upstreamClient = new UpstreamClient({
+    name: command,
+    transport,
+    onTransportError: (error) => {
+      process4.stderr.write(`Upstream MCP transport error: ${error.message}
+`);
+      shutdown(1);
+    }
+  });
   const shutdown = (exitCode) => {
     if (isShuttingDown) return;
     isShuttingDown = true;
     upstreamClient.disconnect().catch((error) => {
-      process3.stderr.write(
+      process4.stderr.write(
         `dynmcp: error during disconnect: ${error instanceof Error ? error.message : String(error)}
 `
       );
-    }).finally(() => process3.exit(exitCode));
+    }).finally(() => process4.exit(exitCode));
   };
-  const upstreamClient = new UpstreamClient({
-    command,
-    args,
-    onTransportError: (error) => {
-      process3.stderr.write(`Upstream MCP transport error: ${error.message}
-`);
-      shutdown(1);
-    }
-  });
   try {
     await upstreamClient.connect();
   } catch (error) {
-    process3.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+    process4.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
 `);
-    process3.exit(1);
+    process4.exit(1);
   }
   let tools;
   try {
     tools = await upstreamClient.listTools();
   } catch (error) {
-    process3.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+    process4.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+`);
+    process4.exit(1);
+  }
+  const catalog = ToolCatalog.fromFlat(tools);
+  const proxyServer = new ProxyServer({
+    catalog,
+    callTool: (name, input) => upstreamClient.callTool(name, input)
+  });
+  process4.on("SIGINT", () => shutdown(0));
+  process4.on("SIGTERM", () => shutdown(0));
+  process4.stdin.on("end", () => shutdown(0));
+  process4.stdin.on("close", () => shutdown(0));
+  try {
+    await proxyServer.start();
+  } catch (error) {
+    shutdown(1);
+    throw error;
+  }
+}
+async function startProxyFromConfig(configPath) {
+  let isShuttingDown = false;
+  const config = loadConfig(configPath);
+  const mcps = /* @__PURE__ */ new Map();
+  for (const [name, entry] of Object.entries(config.mcp)) {
+    mcps.set(name, { transport: createTransport(entry) });
+  }
+  const orchestrator = new Orchestrator({
+    mcps,
+    onTransportError: (mcpName2, error) => {
+      process4.stderr.write(`Upstream MCP "${mcpName2}" transport error: ${error.message}
+`);
+      shutdown(1);
+    }
+  });
+  const shutdown = (exitCode) => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    orchestrator.disconnectAll().catch((error) => {
+      process4.stderr.write(
+        `dynmcp: error during disconnect: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+    }).finally(() => process4.exit(exitCode));
+  };
+  try {
+    await orchestrator.connect();
+  } catch (error) {
+    process4.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
 `);
-    process3.exit(1);
-  }
-  const catalog = new ToolCatalog(tools);
-  const proxyServer = new ProxyServer({ catalog, upstreamClient });
-  process3.on("SIGINT", () => shutdown(0));
-  process3.on("SIGTERM", () => shutdown(0));
-  process3.stdin.on("end", () => shutdown(0));
-  process3.stdin.on("close", () => shutdown(0));
-  await proxyServer.start();
+    process4.exit(1);
+  }
+  const proxyServer = new ProxyServer({
+    catalog: orchestrator.catalog,
+    callTool: (name, input) => orchestrator.callTool(name, input)
+  });
+  process4.on("SIGINT", () => shutdown(0));
+  process4.on("SIGTERM", () => shutdown(0));
+  process4.stdin.on("end", () => shutdown(0));
+  process4.stdin.on("close", () => shutdown(0));
+  try {
+    await proxyServer.start();
+  } catch (error) {
+    shutdown(1);
+    throw error;
+  }
 }
 
 // src/cli.ts
@@ -341,34 +590,42 @@ var cliBanner = chalk.bold.magentaBright(
     verticalLayout: "fitted"
   })
 );
-var cli = new Command(package_default.name).description(package_default.description).version(package_default.version).addHelpText("beforeAll", cliBanner).addHelpText("after", "\nExample:\n  dynmcp -- npx -y chrome-devtools-mcp@latest\n").allowExcessArguments(true).passThroughOptions(true).action(async () => {
-  const separatorIndex = process4.argv.indexOf("--");
-  if (separatorIndex === -1) {
-    process4.stderr.write(
-      "dynmcp: no upstream command provided.\nUsage: dynmcp -- <command> [args...]\nExample: dynmcp -- npx -y chrome-devtools-mcp@latest\n"
-    );
-    process4.exit(1);
-  }
-  const [command, ...args] = process4.argv.slice(separatorIndex + 1);
-  if (command === void 0) {
-    process4.stderr.write(
-      "dynmcp: no upstream command provided.\nUsage: dynmcp -- <command> [args...]\nExample: dynmcp -- npx -y chrome-devtools-mcp@latest\n"
-    );
-    process4.exit(1);
+var cli = new Command(package_default.name).description(package_default.description).version(package_default.version).addHelpText("beforeAll", cliBanner).addHelpText(
+  "after",
+  "\nExamples:\n  dynmcp -- npx -y chrome-devtools-mcp@latest\n  dynmcp --config ./mcp.json\n"
+).option("-c, --config <path>", "Path to config file (JSON or YAML)").allowExcessArguments(true).passThroughOptions(true).action(async (_options, cmd) => {
+  const separatorIndex = process5.argv.indexOf("--");
+  const configPath = cmd.opts().config;
+  if (separatorIndex !== -1) {
+    const [command, ...args] = process5.argv.slice(separatorIndex + 1);
+    if (command === void 0) {
+      process5.stderr.write(
+        "dynmcp: no upstream command provided after --.\nUsage: dynmcp -- <command> [args...]\n"
+      );
+      process5.exit(1);
+    }
+    try {
+      await startProxy(command, args);
+    } catch (error) {
+      process5.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+`);
+      process5.exit(1);
+    }
+    return;
   }
   try {
-    await startProxy(command, args);
+    await startProxyFromConfig(configPath);
   } catch (error) {
-    process4.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+    process5.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
 `);
-    process4.exit(1);
+    process5.exit(1);
   }
 });
 
 // src/index.ts
-import process5 from "process";
+import process6 from "process";
 async function main() {
-  cli.parse(process5.argv);
+  cli.parse(process6.argv);
 }
 main();
 //# sourceMappingURL=index.js.map