dynmcp 0.0.1 → 0.1.0

package/README.md

@@ -1,4 +1,4 @@
-# dynmcp
+# Dynamic Discovery MCP
 
 A proxy MCP that exposes meta-tools so agents can discover and call upstream MCP tools on demand, without loading every tool schema into the context window.
 
@@ -8,27 +8,124 @@ Large MCPs routinely expose tens to hundreds of tools. When several are active a
 
 ## How It Works
 
-`dynmcp` sits in front of an upstream MCP and exposes exactly two tools:
+`dynmcp` sits in front of one or more upstream MCPs and exposes exactly two tools:
 
 - **`discover_tool`** — its description contains a compact catalog of every upstream tool (name and one-line summary). Call it with a tool name to get that tool's full schema: description, parameters, types, and required fields.
 - **`use_tool`** — executes a tool by name, proxying the call to the upstream MCP and returning its output unchanged.
 
 The agent workflow: scan the catalog in `discover_tool`'s description to find relevant tools, call `discover_tool` to load the full schema of the one it needs, then call `use_tool` to execute it. Full schemas of tools the agent never needs never enter the context window.
 
-`dynmcp` runs locally, communicating with both the agent host and the upstream MCP over stdio.
-
 ## Usage
 
 Requires Node.js >= 20.
 
+### Single MCP (quick start)
+
 Prefix any MCP invocation with `dynmcp --`:
 
 ```bash
-# Before
+# Before — tool schemas go straight into context
 npx -y chrome-devtools-mcp@latest
 
-# With dynmcp
+# With dynmcp — only discover_tool and use_tool are exposed
 npx dynmcp@latest -- npx -y chrome-devtools-mcp@latest
 ```
 
-Everything after `--` is the command used to launch the upstream MCP.
+Everything after `--` is the command used to launch the upstream MCP. Tool names are exposed as-is (no namespace prefix).
+
+### Multiple MCPs (config file)
+
+To proxy several MCPs at once, create a config file:
+
+```bash
+# Auto-discover mcp.json or .mcp.json in cwd
+npx dynmcp@latest
+
+# Or specify explicitly
+npx dynmcp@latest --config ./my-config.json
+```
+
+When using a config file, tool names are namespaced as `<mcp-name>/<tool-name>` to avoid collisions.
+
+## Config File
+
+The config file declares upstream MCPs under a top-level `mcp` key. Three transport types are supported:
+
+```json
+{
+  "$schema": "https://unpkg.com/dynmcp/schema/mcp-config.json",
+  "mcp": {
+    "chrome-devtools": {
+      "transport": "stdio",
+      "command": "npx",
+      "args": ["-y", "chrome-devtools-mcp@latest"]
+    },
+    "filesystem": {
+      "transport": "stdio",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
+    },
+    "aws-knowledge": {
+      "transport": "streamable-http",
+      "url": "https://knowledge-mcp.global.api.aws"
+    },
+    "remote-sse": {
+      "transport": "sse",
+      "url": "https://example.com/sse",
+      "headers": {
+        "Authorization": "Bearer my-token"
+      }
+    }
+  }
+}
+```
+
+YAML is also supported (use `.yml` or `.yaml` extension).
+
+### Transport Types
+
+| Transport | Fields | Description |
+|---|---|---|
+| `stdio` | `command`, `args?`, `env?` | Spawns the MCP as a child process |
+| `streamable-http` | `url`, `headers?` | Connects to a remote MCP over HTTP |
+| `sse` | `url`, `headers?` | Connects to a remote MCP over Server-Sent Events |
+
+### Config Discovery
+
+When no `--` command is provided, `dynmcp` looks for a config file in this order:
+
+1. Path from `-c` / `--config` flag
+2. `mcp.json` in the current directory
+3. `.mcp.json` in the current directory
+
+### Naming Rules
+
+MCP names (the keys in the config) must match `^[a-z0-9][a-z0-9-]*$`.
+
+## CLI Reference
+
+```
+dynmcp [options] [-- <upstream-command> [upstream-args...]]
+```
+
+| Flag | Short | Description |
+|---|---|---|
+| `--version` | `-v` | Print the package version and exit |
+| `--help` | `-h` | Print usage information and exit |
+| `--config <path>` | `-c` | Path to config file (JSON or YAML) |
+| `--` | | Everything after is the upstream MCP command (single-MCP mode) |
+
+### Mode Resolution
+
+1. If `--` is present, single-MCP mode is used (config file is ignored).
+2. Otherwise, config file mode is used.
+
+## Development
+
+```bash
+npm install
+npm run build       # Compile to dist/
+npm run typecheck   # Type-check without emitting
+npm run check       # Biome lint + format
+npm test            # Run tests
+```

package/dist/index.cjs

@@ -29,7 +29,7 @@ var import_commander = require("commander");
 // package.json
 var package_default = {
   name: "dynmcp",
-  version: "0.0.1",
+  version: "0.1.0",
   description: "Dynamic MCP context management tool for AI MCP-enabled agents and clients.",
   author: "Brandon Burrus <brandon@burrus.io>",
   license: "MIT",
@@ -97,6 +97,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: {
@@ -118,21 +119,143 @@ var import_chalk = __toESM(require("chalk"), 1);
 
 // src/proxy/index.ts
 var import_node_process3 = __toESM(require("process"), 1);
+var import_stdio2 = require("@modelcontextprotocol/sdk/client/stdio.js");
+
+// src/config/schema.ts
+var import_zod = require("zod");
+var MCP_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+var mcpName = import_zod.z.string().regex(MCP_NAME_PATTERN);
+var stdioTransport = import_zod.z.object({
+  transport: import_zod.z.literal("stdio"),
+  command: import_zod.z.string(),
+  args: import_zod.z.array(import_zod.z.string()).optional(),
+  env: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
+}).strict();
+var httpUrl = import_zod.z.string().url().refine((u) => u.startsWith("http://") || u.startsWith("https://"), {
+  message: "URL must use http:// or https:// scheme"
+});
+var streamableHttpTransport = import_zod.z.object({
+  transport: import_zod.z.literal("streamable-http"),
+  url: httpUrl,
+  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
+}).strict();
+var sseTransport = import_zod.z.object({
+  transport: import_zod.z.literal("sse"),
+  url: httpUrl,
+  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
+}).strict();
+var transportConfig = import_zod.z.discriminatedUnion("transport", [
+  stdioTransport,
+  streamableHttpTransport,
+  sseTransport
+]);
+var mcpConfigSchema = import_zod.z.object({
+  mcp: import_zod.z.record(mcpName, transportConfig).refine((obj) => Object.keys(obj).length > 0, { message: "At least one MCP must be configured" })
+});
+
+// src/config/loader.ts
+var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
+var import_node_path = require("path");
+var import_yaml = require("yaml");
+var AUTO_DISCOVER_NAMES = ["mcp.json", ".mcp.json"];
+function resolveConfigPath(explicitPath) {
+  if (explicitPath) {
+    const resolved = (0, import_node_path.resolve)(explicitPath);
+    if (!(0, import_node_fs2.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 = (0, import_node_path.resolve)(cwd, name);
+    if ((0, import_node_fs2.existsSync)(candidate)) {
+      return candidate;
+    }
+  }
+  const searched = AUTO_DISCOVER_NAMES.map((n) => (0, import_node_path.resolve)(cwd, n)).join(", ");
+  throw new Error(`No config file found. Searched: ${searched}`);
+}
+function loadConfig(explicitPath) {
+  const configPath = resolveConfigPath(explicitPath);
+  const raw = (0, import_node_fs.readFileSync)(configPath, "utf-8");
+  let content;
+  try {
+    content = isYamlFile(configPath) ? (0, import_yaml.parse)(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/proxy/transport-factory.ts
+var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
+function createTransport(config) {
+  switch (config.transport) {
+    case "stdio":
+      return new import_stdio.StdioClientTransport({
+        command: config.command,
+        args: config.args,
+        env: config.env
+      });
+    case "streamable-http":
+      return new import_streamableHttp.StreamableHTTPClientTransport(
+        new URL(config.url),
+        config.headers ? { requestInit: { headers: config.headers } } : void 0
+      );
+    case "sse":
+      return new import_sse.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);
@@ -140,10 +263,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}
@@ -152,9 +275,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:",
@@ -193,73 +331,21 @@ function buildAnnotationLines(tool) {
   return lines;
 }
 
-// src/proxy/server.ts
-var import_node_process = __toESM(require("process"), 1);
-var import_fastmcp = require("fastmcp");
-var import_zod = require("zod");
-var ProxyServer = class {
-  catalog;
-  upstreamClient;
-  constructor({ catalog, upstreamClient }) {
-    this.catalog = catalog;
-    this.upstreamClient = upstreamClient;
-  }
-  async start() {
-    const server = new import_fastmcp.FastMCP({
-      name: "dynamic-discovery-mcp",
-      version: package_default.version
-    });
-    server.addTool({
-      name: "discover_tool",
-      description: this.catalog.discoverToolDescription,
-      parameters: import_zod.z.object({ tool_name: import_zod.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: import_zod.z.object({
-        tool_name: import_zod.z.string(),
-        tool_input: import_zod.z.record(import_zod.z.string(), import_zod.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;
-      }
-    });
-    import_node_process.default.stderr.write("Starting dynamic-discovery-mcp server over stdio\n");
-    await server.start({ transportType: "stdio" });
-  }
-};
-
 // src/proxy/upstream-client.ts
-var import_node_process2 = __toESM(require("process"), 1);
+var import_node_process = __toESM(require("process"), 1);
 var import_client = require("@modelcontextprotocol/sdk/client/index.js");
-var import_stdio = require("@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) => {
-      import_node_process2.default.stderr.write(`Upstream MCP transport error: ${error.message}
+      import_node_process.default.stderr.write(`[${name}] Upstream MCP transport error: ${error.message}
 `);
     });
   }
   async connect() {
-    this.transport = new import_stdio.StdioClientTransport({
-      command: this.command,
-      args: this.args
-    });
     this.transport.onerror = this.onTransportError;
     this.client = new import_client.Client({ name: "dynamic-discovery-mcp", version: "1.0.0" });
     await this.client.connect(this.transport);
@@ -294,10 +380,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) {
@@ -305,13 +389,126 @@ 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
+var import_node_process2 = __toESM(require("process"), 1);
+var import_fastmcp = require("fastmcp");
+var import_zod2 = require("zod");
+var ProxyServer = class {
+  catalog;
+  callTool;
+  constructor({ catalog, callTool }) {
+    this.catalog = catalog;
+    this.callTool = callTool;
+  }
+  async start() {
+    const server = new import_fastmcp.FastMCP({
+      name: "dynamic-discovery-mcp",
+      version: package_default.version
+    });
+    server.addTool({
+      name: "discover_tool",
+      description: this.catalog.discoverToolDescription,
+      parameters: import_zod2.z.object({ tool_name: import_zod2.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: import_zod2.z.object({
+        tool_name: import_zod2.z.string(),
+        tool_input: import_zod2.z.record(import_zod2.z.string(), import_zod2.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.callTool(tool_name, tool_input);
+        return result;
+      }
+    });
+    import_node_process2.default.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 import_stdio2.StdioClientTransport({ command, args });
+  const upstreamClient = new UpstreamClient({
+    name: command,
+    transport,
+    onTransportError: (error) => {
+      import_node_process3.default.stderr.write(`Upstream MCP transport error: ${error.message}
+`);
+      shutdown(1);
+    }
+  });
   const shutdown = (exitCode) => {
     if (isShuttingDown) return;
     isShuttingDown = true;
@@ -322,15 +519,6 @@ async function startProxy(command, args) {
       );
     }).finally(() => import_node_process3.default.exit(exitCode));
   };
-  const upstreamClient = new UpstreamClient({
-    command,
-    args,
-    onTransportError: (error) => {
-      import_node_process3.default.stderr.write(`Upstream MCP transport error: ${error.message}
-`);
-      shutdown(1);
-    }
-  });
   try {
     await upstreamClient.connect();
   } catch (error) {
@@ -346,13 +534,68 @@ async function startProxy(command, args) {
 `);
     import_node_process3.default.exit(1);
   }
-  const catalog = new ToolCatalog(tools);
-  const proxyServer = new ProxyServer({ catalog, upstreamClient });
+  const catalog = ToolCatalog.fromFlat(tools);
+  const proxyServer = new ProxyServer({
+    catalog,
+    callTool: (name, input) => upstreamClient.callTool(name, input)
+  });
+  import_node_process3.default.on("SIGINT", () => shutdown(0));
+  import_node_process3.default.on("SIGTERM", () => shutdown(0));
+  import_node_process3.default.stdin.on("end", () => shutdown(0));
+  import_node_process3.default.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) => {
+      import_node_process3.default.stderr.write(`Upstream MCP "${mcpName2}" transport error: ${error.message}
+`);
+      shutdown(1);
+    }
+  });
+  const shutdown = (exitCode) => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    orchestrator.disconnectAll().catch((error) => {
+      import_node_process3.default.stderr.write(
+        `dynmcp: error during disconnect: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+    }).finally(() => import_node_process3.default.exit(exitCode));
+  };
+  try {
+    await orchestrator.connect();
+  } catch (error) {
+    import_node_process3.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+`);
+    import_node_process3.default.exit(1);
+  }
+  const proxyServer = new ProxyServer({
+    catalog: orchestrator.catalog,
+    callTool: (name, input) => orchestrator.callTool(name, input)
+  });
   import_node_process3.default.on("SIGINT", () => shutdown(0));
   import_node_process3.default.on("SIGTERM", () => shutdown(0));
   import_node_process3.default.stdin.on("end", () => shutdown(0));
   import_node_process3.default.stdin.on("close", () => shutdown(0));
-  await proxyServer.start();
+  try {
+    await proxyServer.start();
+  } catch (error) {
+    shutdown(1);
+    throw error;
+  }
 }
 
 // src/cli.ts
@@ -363,23 +606,31 @@ var cliBanner = import_chalk.default.bold.magentaBright(
     verticalLayout: "fitted"
   })
 );
-var cli = new import_commander.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 () => {
+var cli = new import_commander.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 = import_node_process4.default.argv.indexOf("--");
-  if (separatorIndex === -1) {
-    import_node_process4.default.stderr.write(
-      "dynmcp: no upstream command provided.\nUsage: dynmcp -- <command> [args...]\nExample: dynmcp -- npx -y chrome-devtools-mcp@latest\n"
-    );
-    import_node_process4.default.exit(1);
-  }
-  const [command, ...args] = import_node_process4.default.argv.slice(separatorIndex + 1);
-  if (command === void 0) {
-    import_node_process4.default.stderr.write(
-      "dynmcp: no upstream command provided.\nUsage: dynmcp -- <command> [args...]\nExample: dynmcp -- npx -y chrome-devtools-mcp@latest\n"
-    );
-    import_node_process4.default.exit(1);
+  const configPath = cmd.opts().config;
+  if (separatorIndex !== -1) {
+    const [command, ...args] = import_node_process4.default.argv.slice(separatorIndex + 1);
+    if (command === void 0) {
+      import_node_process4.default.stderr.write(
+        "dynmcp: no upstream command provided after --.\nUsage: dynmcp -- <command> [args...]\n"
+      );
+      import_node_process4.default.exit(1);
+    }
+    try {
+      await startProxy(command, args);
+    } catch (error) {
+      import_node_process4.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+`);
+      import_node_process4.default.exit(1);
+    }
+    return;
   }
   try {
-    await startProxy(command, args);
+    await startProxyFromConfig(configPath);
   } catch (error) {
     import_node_process4.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
 `);