dynmcp 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -23,13 +23,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
-var import_node_process12 = __toESM(require("process"), 1);
+var import_node_process14 = __toESM(require("process"), 1);
 var import_commander = require("commander");
 
 // package.json
 var package_default = {
   name: "dynmcp",
-  version: "0.5.0",
+  version: "0.6.0",
   description: "Dynamic MCP context management tool for AI MCP-enabled agents and clients.",
   author: "Brandon Burrus <brandon@burrus.io>",
   license: "MIT",
@@ -487,14 +487,14 @@ var sseTransport = import_zod.z.object({
   headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
   auth: authConfig
 }).strict();
-var transportConfig = import_zod.z.discriminatedUnion("transport", [
+var transportConfigSchema = import_zod.z.discriminatedUnion("transport", [
   stdioTransport,
   streamableHttpTransport,
   sseTransport
 ]);
 var mcpConfigSchema = import_zod.z.object({
   env: envModeSchema.optional(),
-  mcp: import_zod.z.record(mcpName, transportConfig).refine((obj) => Object.keys(obj).length > 0, { message: "At least one MCP must be configured" })
+  mcp: import_zod.z.record(mcpName, transportConfigSchema).refine((obj) => Object.keys(obj).length > 0, { message: "At least one MCP must be configured" })
 });
 
 // src/config/loader.ts
@@ -726,7 +726,7 @@ var import_node_child_process = require("child_process");
 var import_node_process3 = __toESM(require("process"), 1);
 async function openUrl(url) {
   const { command, args } = openerForPlatform(url);
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const child = (0, import_node_child_process.spawn)(command, args, {
       stdio: "ignore",
       detached: true
@@ -734,7 +734,7 @@ async function openUrl(url) {
     child.once("error", reject);
     child.once("spawn", () => {
       child.unref();
-      resolve3();
+      resolve4();
     });
   });
 }
@@ -809,14 +809,14 @@ var CallbackServer = class _CallbackServer {
       throw new Error("CallbackServer is already started.");
     }
     const server = (0, import_node_http.createServer)((req, res) => this.handleRequest(req, res));
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       const onError = (err) => {
         server.removeListener("listening", onListening);
         reject(err);
       };
       const onListening = () => {
         server.removeListener("error", onError);
-        resolve3();
+        resolve4();
       };
       server.once("error", onError);
       server.once("listening", onListening);
@@ -854,12 +854,12 @@ var CallbackServer = class _CallbackServer {
     if (this.pending !== null) {
       return Promise.reject(new Error("awaitCallback already in progress."));
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const timer = setTimeout(() => {
         this.pending = null;
         reject(new CallbackTimeoutError(timeoutMs));
       }, timeoutMs);
-      this.pending = { resolve: resolve3, reject, timer };
+      this.pending = { resolve: resolve4, reject, timer };
     });
   }
   /** Closes the listening socket. Safe to call multiple times. */
@@ -869,8 +869,8 @@ var CallbackServer = class _CallbackServer {
       this.pending = null;
     }
     if (this.server === null) return;
-    await new Promise((resolve3) => {
-      this.server.close(() => resolve3());
+    await new Promise((resolve4) => {
+      this.server.close(() => resolve4());
     });
     this.server = null;
     this.boundPort = null;
@@ -914,10 +914,10 @@ var CallbackServer = class _CallbackServer {
     }
     res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
     res.end(SUCCESS_HTML);
-    const { resolve: resolve3, timer } = this.pending;
+    const { resolve: resolve4, timer } = this.pending;
     clearTimeout(timer);
     this.pending = null;
-    resolve3({ code, state });
+    resolve4({ code, state });
   }
   respondError(res, errorCode, description2) {
     res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
@@ -3309,6 +3309,215 @@ async function runProxy(orchestrator) {
   }
 }
 
+// src/scaffold/init.ts
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
+var import_node_process12 = __toESM(require("process"), 1);
+
+// src/scaffold/format.ts
+var import_node_path3 = require("path");
+function detectFormat(filePath) {
+  const ext = (0, import_node_path3.extname)(filePath).toLowerCase();
+  return ext === ".yml" || ext === ".yaml" ? "yaml" : "json";
+}
+var SCHEMA_URL = "https://dynamicmcp.tools/config.json";
+
+// src/scaffold/init.ts
+function init(options = {}) {
+  const cwd = options.cwd ?? import_node_process12.default.cwd();
+  const stdout = options.write ?? ((chunk) => void import_node_process12.default.stdout.write(chunk));
+  const fileWriter = options.fileWriter ?? ((p, c) => (0, import_node_fs3.writeFileSync)(p, c, "utf-8"));
+  const fileExists = options.fileExists ?? ((p) => (0, import_node_fs3.existsSync)(p));
+  const targetPath = resolveInitPath({ cwd, path: options.path, yaml: options.yaml === true });
+  const format = detectFormat(targetPath);
+  if (fileExists(targetPath) && options.force !== true) {
+    throw new Error(`File already exists: ${targetPath}
+Use --force to overwrite.`);
+  }
+  const contents = format === "yaml" ? renderYamlSkeleton() : renderJsonSkeleton();
+  fileWriter(targetPath, contents);
+  stdout(`Wrote ${targetPath}
+`);
+  stdout("\nThis config has no MCPs yet. Add one with:\n");
+  stdout("  dynmcp add <name> --command <cmd>                          (stdio upstream)\n");
+  stdout("  dynmcp add <name> --transport streamable-http --url <url>  (remote HTTP upstream)\n");
+  stdout("\nSee https://dynamicmcp.tools for full documentation.\n");
+}
+function resolveInitPath(opts) {
+  if (opts.path !== void 0) {
+    return (0, import_node_path4.resolve)(opts.cwd, opts.path);
+  }
+  return (0, import_node_path4.resolve)(opts.cwd, opts.yaml ? "mcp.yaml" : "mcp.json");
+}
+function renderJsonSkeleton() {
+  const body = JSON.stringify({ $schema: SCHEMA_URL, mcp: {} }, null, 2);
+  return `${body}
+`;
+}
+function renderYamlSkeleton() {
+  return `# yaml-language-server: $schema=${SCHEMA_URL}
+
+mcp: {}
+`;
+}
+
+// src/scaffold/add.ts
+var import_node_fs4 = require("fs");
+var import_node_process13 = __toESM(require("process"), 1);
+var import_yaml2 = require("yaml");
+function add(options) {
+  validateName(options.name);
+  const stdout = options.write ?? ((chunk) => void import_node_process13.default.stdout.write(chunk));
+  const fileReader = options.fileReader ?? ((p) => (0, import_node_fs4.readFileSync)(p, "utf-8"));
+  const fileWriter = options.fileWriter ?? ((p, c) => (0, import_node_fs4.writeFileSync)(p, c, "utf-8"));
+  const resolvePath = options.resolvePath ?? resolveConfigPath;
+  let targetPath;
+  try {
+    targetPath = resolvePath(options.configPath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${message}
+Hint: run 'dynmcp init' to create a starter config file.`);
+  }
+  const raw = fileReader(targetPath);
+  const format = detectFormat(targetPath);
+  const entry = buildEntry(options);
+  const parsed = transportConfigSchema.safeParse(entry);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".") || "<root>"}: ${i.message}`).join("\n");
+    throw new Error(`Invalid MCP entry:
+${issues}`);
+  }
+  const next = format === "yaml" ? writeYaml(raw, options.name, parsed.data, options.force === true) : writeJson(raw, options.name, parsed.data, options.force === true);
+  fileWriter(targetPath, next);
+  stdout(`Added '${options.name}' (${options.transport}) to ${targetPath}
+`);
+}
+function validateName(name) {
+  if (!MCP_NAME_PATTERN.test(name)) {
+    throw new Error(
+      `Invalid MCP name '${name}'. Names must match ${MCP_NAME_PATTERN.source} (lowercase letters, digits, and dashes; starting with a letter or digit).`
+    );
+  }
+}
+function buildEntry(options) {
+  if (options.transport === "stdio") {
+    if (options.command === void 0 || options.command.length === 0) {
+      throw new Error("--command is required for stdio transport");
+    }
+    const entry2 = {
+      transport: "stdio",
+      command: options.command
+    };
+    if (options.description !== void 0) entry2.description = options.description;
+    if (options.args !== void 0 && options.args.length > 0) {
+      entry2.args = options.args;
+    }
+    if (options.envVars !== void 0 && options.envVars.length > 0) {
+      entry2.env = parseKeyValuePairs(options.envVars, "--env");
+    }
+    return entry2;
+  }
+  if (options.url === void 0 || options.url.length === 0) {
+    throw new Error(`--url is required for ${options.transport} transport`);
+  }
+  const entry = {
+    transport: options.transport,
+    url: options.url
+  };
+  if (options.description !== void 0) entry.description = options.description;
+  if (options.headers !== void 0 && options.headers.length > 0) {
+    entry.headers = parseHeaderPairs(options.headers);
+  }
+  const auth2 = buildAuthBlock(options);
+  if (auth2 !== void 0) entry.auth = auth2;
+  return entry;
+}
+function buildAuthBlock(options) {
+  const hasAny = options.clientId !== void 0 || options.clientSecret !== void 0 || options.scope !== void 0;
+  if (!hasAny) return void 0;
+  if (options.clientId === void 0) {
+    throw new Error("--client-id is required when --client-secret or --scope is provided");
+  }
+  const auth2 = { client_id: options.clientId };
+  if (options.clientSecret !== void 0) auth2.client_secret = options.clientSecret;
+  if (options.scope !== void 0) auth2.scope = options.scope;
+  return auth2;
+}
+function parseKeyValuePairs(pairs, flag) {
+  const out = {};
+  for (const pair of pairs) {
+    const eq = pair.indexOf("=");
+    if (eq <= 0) {
+      throw new Error(`${flag} expects KEY=VALUE (got: ${JSON.stringify(pair)})`);
+    }
+    const key = pair.slice(0, eq);
+    out[key] = pair.slice(eq + 1);
+  }
+  return out;
+}
+function parseHeaderPairs(pairs) {
+  const out = {};
+  for (const pair of pairs) {
+    const colon = pair.indexOf(":");
+    if (colon <= 0) {
+      throw new Error(`--header expects "Name: Value" (got: ${JSON.stringify(pair)})`);
+    }
+    const key = pair.slice(0, colon).trim();
+    const value = pair.slice(colon + 1).trim();
+    if (key.length === 0) {
+      throw new Error(`--header name cannot be empty (got: ${JSON.stringify(pair)})`);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function writeJson(raw, name, entry, force) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse config as JSON: ${message}`);
+  }
+  if (!isPlainObject(parsed)) {
+    throw new Error("Top-level config must be a JSON object.");
+  }
+  let mcp = parsed.mcp;
+  if (mcp === void 0) {
+    mcp = {};
+    parsed.mcp = mcp;
+  } else if (!isPlainObject(mcp)) {
+    throw new Error("Config field 'mcp' must be an object.");
+  }
+  const mcpRecord = mcp;
+  if (mcpRecord[name] !== void 0 && !force) {
+    throw new Error(`Entry '${name}' already exists. Use --force to overwrite.`);
+  }
+  mcpRecord[name] = entry;
+  return `${JSON.stringify(parsed, null, 2)}
+`;
+}
+function writeYaml(raw, name, entry, force) {
+  const doc = (0, import_yaml2.parseDocument)(raw);
+  if (doc.errors.length > 0) {
+    const first = doc.errors[0]?.message ?? "unknown error";
+    throw new Error(`Failed to parse config as YAML: ${first}`);
+  }
+  if (!doc.has("mcp")) {
+    doc.set("mcp", {});
+  }
+  const path = ["mcp", name];
+  if (doc.hasIn(path) && !force) {
+    throw new Error(`Entry '${name}' already exists. Use --force to overwrite.`);
+  }
+  doc.setIn(path, entry);
+  return doc.toString();
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/cli.ts
 var cliBanner = import_chalk.default.bold.magentaBright(
   import_figlet.default.textSync("DYNAMIC MCP", {
@@ -3319,36 +3528,100 @@ var cliBanner = import_chalk.default.bold.magentaBright(
 );
 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  dynmcp ls\n  dynmcp test github\n  dynmcp login github\n  dynmcp logout github\n"
+  "\nExamples:\n  dynmcp -- npx -y chrome-devtools-mcp@latest\n  dynmcp --config ./mcp.json\n  dynmcp init\n  dynmcp add filesystem --command npx --arg -y --arg @modelcontextprotocol/server-filesystem --arg /tmp\n  dynmcp add github --transport streamable-http --url https://api.githubcopilot.com/mcp\n  dynmcp ls\n  dynmcp test github\n  dynmcp login github\n  dynmcp logout github\n"
 ).option("-c, --config <path>", "Path to config file (JSON or YAML)").option("-e, --env <path>", "Path to a .env file for environment variable interpolation").allowExcessArguments(true).passThroughOptions(true).action(async (_options, cmd) => {
-  const separatorIndex = import_node_process12.default.argv.indexOf("--");
+  const separatorIndex = import_node_process14.default.argv.indexOf("--");
   const configPath = cmd.opts().config;
   const envFilePath = cmd.opts().env;
   if (separatorIndex !== -1) {
-    const [command, ...args] = import_node_process12.default.argv.slice(separatorIndex + 1);
+    const [command, ...args] = import_node_process14.default.argv.slice(separatorIndex + 1);
     if (command === void 0) {
-      import_node_process12.default.stderr.write(
+      import_node_process14.default.stderr.write(
         "dynmcp: no upstream command provided after --.\nUsage: dynmcp -- <command> [args...]\n"
       );
-      import_node_process12.default.exit(1);
+      import_node_process14.default.exit(1);
     }
     try {
       await startProxy(command, args);
     } catch (error) {
-      import_node_process12.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+      import_node_process14.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
 `);
-      import_node_process12.default.exit(1);
+      import_node_process14.default.exit(1);
     }
     return;
   }
   try {
     await startProxyFromConfig({ configPath, envFilePath });
   } catch (error) {
-    import_node_process12.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+    import_node_process14.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
 `);
-    import_node_process12.default.exit(1);
+    import_node_process14.default.exit(1);
   }
 });
+cli.command("init").description("Write a starter config file (mcp.json by default) in the current directory.").option("--path <path>", "Explicit target path (extension determines format).").option("--yaml", "Write mcp.yaml instead of mcp.json (ignored if --path is set).").option("--force", "Overwrite an existing file.").action((options) => {
+  try {
+    init({
+      ...options.path !== void 0 ? { path: options.path } : {},
+      ...options.yaml === true ? { yaml: true } : {},
+      ...options.force === true ? { force: true } : {}
+    });
+  } catch (error) {
+    import_node_process14.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+`);
+    import_node_process14.default.exit(1);
+  }
+});
+var collectRepeatable = (value, previous) => [...previous, value];
+cli.command("add <name>").description("Insert a new MCP entry into the resolved config file.").option(
+  "-t, --transport <transport>",
+  "Transport: stdio | streamable-http | sse (default: stdio).",
+  "stdio"
+).option("-c, --config <path>", "Path to config file (otherwise auto-discovered).").option("--description <text>", "Per-entry description; presence makes the entry lazy.").option("--command <cmd>", "(stdio) Command to spawn for the upstream MCP.").option(
+  "--arg <arg>",
+  "(stdio) Repeatable positional argument passed after --command.",
+  collectRepeatable,
+  []
+).option(
+  "--env <KEY=VAL>",
+  "(stdio) Repeatable env var for the spawned process.",
+  collectRepeatable,
+  []
+).option("--url <url>", "(http/sse) Endpoint URL.").option(
+  "--header <header>",
+  '(http/sse) Repeatable "Name: Value" header.',
+  collectRepeatable,
+  []
+).option("--client-id <id>", "(http/sse) Pre-registered OAuth client_id (skips DCR).").option("--client-secret <secret>", "(http/sse) Pre-registered OAuth client_secret.").option("--scope <scope>", "(http/sse) OAuth scope to request.").option("--force", "Overwrite an existing entry with the same name.").action(
+  (name, options) => {
+    try {
+      const transport = options.transport;
+      if (transport !== "stdio" && transport !== "streamable-http" && transport !== "sse") {
+        throw new Error(
+          `Invalid --transport '${options.transport}'. Must be one of: stdio, streamable-http, sse.`
+        );
+      }
+      add({
+        name,
+        transport,
+        ...options.config !== void 0 ? { configPath: options.config } : {},
+        ...options.force === true ? { force: true } : {},
+        ...options.description !== void 0 ? { description: options.description } : {},
+        ...options.command !== void 0 ? { command: options.command } : {},
+        ...options.arg.length > 0 ? { args: options.arg } : {},
+        ...options.env.length > 0 ? { envVars: options.env } : {},
+        ...options.url !== void 0 ? { url: options.url } : {},
+        ...options.header.length > 0 ? { headers: options.header } : {},
+        ...options.clientId !== void 0 ? { clientId: options.clientId } : {},
+        ...options.clientSecret !== void 0 ? { clientSecret: options.clientSecret } : {},
+        ...options.scope !== void 0 ? { scope: options.scope } : {}
+      });
+    } catch (error) {
+      import_node_process14.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+`);
+      import_node_process14.default.exit(1);
+    }
+  }
+);
 cli.command("login <name>").description("Run the OAuth authorization-code flow for an upstream MCP and store tokens.").option("-c, --config <path>", "Path to config file (JSON or YAML)").option("-e, --env <path>", "Path to a .env file for environment variable interpolation").action(async (name, options) => {
   try {
     await login({
@@ -3357,9 +3630,9 @@ cli.command("login <name>").description("Run the OAuth authorization-code flow f
       ...options.env !== void 0 ? { envFilePath: options.env } : {}
     });
   } catch (error) {
-    import_node_process12.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+    import_node_process14.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
 `);
-    import_node_process12.default.exit(1);
+    import_node_process14.default.exit(1);
   }
 });
 cli.command("logout <name>").description("Delete the OAuth keychain entry for an upstream MCP.").option("-c, --config <path>", "Path to config file (JSON or YAML)").option("-e, --env <path>", "Path to a .env file for environment variable interpolation").action(async (name, options) => {
@@ -3370,9 +3643,9 @@ cli.command("logout <name>").description("Delete the OAuth keychain entry for an
       ...options.env !== void 0 ? { envFilePath: options.env } : {}
     });
   } catch (error) {
-    import_node_process12.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+    import_node_process14.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
 `);
-    import_node_process12.default.exit(1);
+    import_node_process14.default.exit(1);
   }
 });
 cli.command("ls").description("List configured upstream MCPs with transport, mode, endpoint, and auth status.").option("-c, --config <path>", "Path to config file (JSON or YAML)").option("-e, --env <path>", "Path to a .env file for environment variable interpolation").option("--json", "Emit JSON instead of the aligned text table").action(async (options) => {
@@ -3383,9 +3656,9 @@ cli.command("ls").description("List configured upstream MCPs with transport, mod
       ...options.json === true ? { json: true } : {}
     });
   } catch (error) {
-    import_node_process12.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+    import_node_process14.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
 `);
-    import_node_process12.default.exit(1);
+    import_node_process14.default.exit(1);
   }
 });
 cli.command("test [name]").description("Probe one or all configured upstream MCPs and print their discovered catalogs.").option("-c, --config <path>", "Path to config file (JSON or YAML)").option("-e, --env <path>", "Path to a .env file for environment variable interpolation").option("--json", "Emit JSON instead of the formatted text output").option("--timeout <ms>", "Per-MCP timeout in milliseconds (default: 15000)", (v) => Number(v)).action(
@@ -3398,19 +3671,19 @@ cli.command("test [name]").description("Probe one or all configured upstream MCP
         ...options.json === true ? { json: true } : {},
         ...options.timeout !== void 0 && !Number.isNaN(options.timeout) ? { timeoutMs: options.timeout } : {}
       });
-      if (exitCode !== 0) import_node_process12.default.exit(exitCode);
+      if (exitCode !== 0) import_node_process14.default.exit(exitCode);
     } catch (error) {
-      import_node_process12.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+      import_node_process14.default.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
 `);
-      import_node_process12.default.exit(1);
+      import_node_process14.default.exit(1);
     }
   }
 );
 
 // src/index.ts
-var import_node_process13 = __toESM(require("process"), 1);
+var import_node_process15 = __toESM(require("process"), 1);
 async function main() {
-  cli.parse(import_node_process13.default.argv);
+  cli.parse(import_node_process15.default.argv);
 }
 main();
 //# sourceMappingURL=index.cjs.map