dynmcp 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import process5 from "process";
+import process6 from "process";
 import { Command } from "commander";
 
 // package.json
 var package_default = {
   name: "dynmcp",
-  version: "0.1.1",
+  version: "0.2.0",
   description: "Dynamic MCP context management tool for AI MCP-enabled agents and clients.",
   author: "Brandon Burrus <brandon@burrus.io>",
   license: "MIT",
@@ -74,6 +74,7 @@ var package_default = {
     boxen: "^8.0.1",
     chalk: "^5.6.2",
     commander: "^14.0.3",
+    dotenv: "^17.4.2",
     enquirer: "^2.4.1",
     fastmcp: "^4.0.1",
     figlet: "^1.11.0",
@@ -99,13 +100,16 @@ import figlet from "figlet";
 import chalk from "chalk";
 
 // src/proxy/index.ts
-import process4 from "process";
+import process5 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 envModeSchema = z.enum(["enable", "dotenv", "process", "disable"]).describe(
+  'Controls environment variable interpolation in config values. "enable" (default) merges .env and process.env (.env wins). "dotenv" loads .env only. "process" uses process.env only. "disable" turns interpolation off.'
+);
 var stdioTransport = z.object({
   transport: z.literal("stdio"),
   command: z.string(),
@@ -131,51 +135,227 @@ var transportConfig = z.discriminatedUnion("transport", [
   sseTransport
 ]);
 var mcpConfigSchema = z.object({
+  env: envModeSchema.optional(),
   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 { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import process2 from "process";
 import { parse as parseYaml } from "yaml";
+
+// src/config/env-sources.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import process from "process";
+import dotenv from "dotenv";
+var DEFAULT_DOTENV_FILENAME = ".env";
+function loadEnv(options) {
+  const { mode, envFilePath, cwd = process.cwd(), processEnv = process.env } = options;
+  if (envFilePath !== void 0 && (mode === "disable" || mode === "process")) {
+    throw new Error(
+      `--env flag is incompatible with env mode "${mode}". --env requires env mode "enable" or "dotenv".`
+    );
+  }
+  if (mode === "disable") {
+    return { variables: {}, interpolationEnabled: false };
+  }
+  const dotenvVars = mode === "process" ? {} : readDotenvFile(envFilePath, cwd);
+  const processVars = mode === "dotenv" ? {} : filterDefined(processEnv);
+  const variables = { ...processVars, ...dotenvVars };
+  return { variables, interpolationEnabled: true };
+}
+function readDotenvFile(envFilePath, cwd) {
+  const isExplicit = envFilePath !== void 0;
+  const resolvedPath = isExplicit ? resolve(envFilePath) : resolve(cwd, DEFAULT_DOTENV_FILENAME);
+  if (!existsSync(resolvedPath)) {
+    if (isExplicit) {
+      throw new Error(`.env file not found: ${resolvedPath}`);
+    }
+    return {};
+  }
+  let raw;
+  try {
+    raw = readFileSync(resolvedPath, "utf-8");
+  } catch (readError) {
+    const message = readError instanceof Error ? readError.message : String(readError);
+    throw new Error(`Failed to read .env file (${resolvedPath}): ${message}`);
+  }
+  try {
+    return dotenv.parse(raw);
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    throw new Error(`Failed to parse .env file (${resolvedPath}): ${message}`);
+  }
+}
+function filterDefined(env) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/config/interpolate.ts
+var TOP_LEVEL_PASSTHROUGH_KEYS = /* @__PURE__ */ new Set(["$schema", "env"]);
+var MissingEnvVarsError = class extends Error {
+  constructor(missingVars) {
+    const list = missingVars.join(", ");
+    const plural = missingVars.length === 1 ? "" : "s";
+    super(`Missing required environment variable${plural}: ${list}`);
+    this.missingVars = missingVars;
+    this.name = "MissingEnvVarsError";
+  }
+  missingVars;
+};
+function interpolateConfig(config, env) {
+  if (config === null || typeof config !== "object" || Array.isArray(config)) {
+    return config;
+  }
+  const missing = [];
+  const result = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (TOP_LEVEL_PASSTHROUGH_KEYS.has(key)) {
+      result[key] = value;
+    } else {
+      result[key] = walkNode(value, env, missing);
+    }
+  }
+  if (missing.length > 0) {
+    const unique = Array.from(new Set(missing)).sort();
+    throw new MissingEnvVarsError(unique);
+  }
+  return result;
+}
+function walkNode(node, env, missing) {
+  if (typeof node === "string") {
+    return interpolateString(node, env, missing);
+  }
+  if (Array.isArray(node)) {
+    return node.map((item) => walkNode(item, env, missing));
+  }
+  if (node !== null && typeof node === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(node)) {
+      result[key] = walkNode(value, env, missing);
+    }
+    return result;
+  }
+  return node;
+}
+function interpolateString(value, env, missing) {
+  let result = "";
+  let i = 0;
+  const len = value.length;
+  while (i < len) {
+    const ch = value[i];
+    if (ch === "$" && value[i + 1] === "$" && value[i + 2] === "{") {
+      const close = value.indexOf("}", i + 3);
+      if (close === -1) {
+        result += ch;
+        i += 1;
+        continue;
+      }
+      result += value.substring(i + 1, close + 1);
+      i = close + 1;
+      continue;
+    }
+    if (ch === "$" && value[i + 1] === "{") {
+      const close = value.indexOf("}", i + 2);
+      if (close === -1) {
+        result += value.substring(i);
+        break;
+      }
+      const expr = value.substring(i + 2, close);
+      const { name, defaultValue } = parseExpr(expr);
+      const resolved = env[name];
+      const hasValue = resolved !== void 0 && resolved !== "";
+      if (hasValue) {
+        result += resolved;
+      } else if (defaultValue !== void 0) {
+        result += defaultValue;
+      } else if (resolved !== void 0) {
+        result += "";
+      } else {
+        missing.push(name);
+      }
+      i = close + 1;
+      continue;
+    }
+    result += ch;
+    i += 1;
+  }
+  return result;
+}
+function parseExpr(expr) {
+  const sep = expr.indexOf(":-");
+  if (sep === -1) {
+    return { name: expr, defaultValue: void 0 };
+  }
+  return {
+    name: expr.substring(0, sep),
+    defaultValue: expr.substring(sep + 2)
+  };
+}
+
+// src/config/loader.ts
 var AUTO_DISCOVER_NAMES = ["mcp.json", ".mcp.json"];
+var DEFAULT_ENV_MODE = "enable";
+var VALID_ENV_MODES = ["enable", "dotenv", "process", "disable"];
 function resolveConfigPath(explicitPath) {
   if (explicitPath) {
-    const resolved = resolve(explicitPath);
-    if (!existsSync(resolved)) {
+    const resolved = resolve2(explicitPath);
+    if (!existsSync2(resolved)) {
       throw new Error(`Config file not found: ${resolved}`);
     }
     return resolved;
   }
-  const cwd = process.cwd();
+  const cwd = process2.cwd();
   for (const name of AUTO_DISCOVER_NAMES) {
-    const candidate = resolve(cwd, name);
-    if (existsSync(candidate)) {
+    const candidate = resolve2(cwd, name);
+    if (existsSync2(candidate)) {
       return candidate;
     }
   }
-  const searched = AUTO_DISCOVER_NAMES.map((n) => resolve(cwd, n)).join(", ");
+  const searched = AUTO_DISCOVER_NAMES.map((n) => resolve2(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");
+function loadConfig(options = {}) {
+  const { configPath, envFilePath } = options;
+  const resolvedPath = resolveConfigPath(configPath);
+  const raw = readFileSync2(resolvedPath, "utf-8");
   let content;
   try {
-    content = isYamlFile(configPath) ? parseYaml(raw) : JSON.parse(raw);
+    content = isYamlFile(resolvedPath) ? 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}`);
+    throw new Error(`Failed to parse config file (${resolvedPath}): ${message}`);
   }
-  const result = mcpConfigSchema.safeParse(content);
+  const envMode = readEnvMode(content);
+  const loadedEnv = loadEnv({ mode: envMode, envFilePath });
+  const interpolated = loadedEnv.interpolationEnabled ? interpolateConfig(content, loadedEnv.variables) : content;
+  const result = mcpConfigSchema.safeParse(interpolated);
   if (!result.success) {
     const formatted = result.error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join("\n");
-    throw new Error(`Invalid config file (${configPath}):
+    throw new Error(`Invalid config file (${resolvedPath}):
 ${formatted}`);
   }
   return result.data;
 }
+function readEnvMode(content) {
+  if (content === null || typeof content !== "object" || Array.isArray(content)) {
+    return DEFAULT_ENV_MODE;
+  }
+  const value = content.env;
+  if (value === void 0) return DEFAULT_ENV_MODE;
+  if (typeof value === "string" && VALID_ENV_MODES.includes(value)) {
+    return value;
+  }
+  return DEFAULT_ENV_MODE;
+}
 function isYamlFile(filePath) {
   return filePath.endsWith(".yml") || filePath.endsWith(".yaml");
 }
@@ -316,7 +496,7 @@ function buildAnnotationLines(tool) {
 }
 
 // src/proxy/upstream-client.ts
-import process2 from "process";
+import process3 from "process";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 var UpstreamClient = class {
   transport;
@@ -325,7 +505,7 @@ var UpstreamClient = class {
   constructor({ name, transport, onTransportError }) {
     this.transport = transport;
     this.onTransportError = onTransportError ?? ((error) => {
-      process2.stderr.write(`[${name}] Upstream MCP transport error: ${error.message}
+      process3.stderr.write(`[${name}] Upstream MCP transport error: ${error.message}
 `);
     });
   }
@@ -437,7 +617,7 @@ var Orchestrator = class {
 };
 
 // src/proxy/server.ts
-import process3 from "process";
+import process4 from "process";
 import { FastMCP } from "fastmcp";
 import { z as z3 } from "zod";
 var ProxyServer = class {
@@ -475,7 +655,7 @@ var ProxyServer = class {
         return result;
       }
     });
-    process3.stderr.write("Starting dynamic-discovery-mcp server over stdio\n");
+    process4.stderr.write("Starting dynamic-discovery-mcp server over stdio\n");
     await server.start({ transportType: "stdio" });
   }
 };
@@ -488,7 +668,7 @@ async function startProxy(command, args) {
     name: command,
     transport,
     onTransportError: (error) => {
-      process4.stderr.write(`Upstream MCP transport error: ${error.message}
+      process5.stderr.write(`Upstream MCP transport error: ${error.message}
 `);
       shutdown(1);
     }
@@ -497,36 +677,36 @@ async function startProxy(command, args) {
     if (isShuttingDown) return;
     isShuttingDown = true;
     upstreamClient.disconnect().catch((error) => {
-      process4.stderr.write(
+      process5.stderr.write(
         `dynmcp: error during disconnect: ${error instanceof Error ? error.message : String(error)}
 `
       );
-    }).finally(() => process4.exit(exitCode));
+    }).finally(() => process5.exit(exitCode));
   };
   try {
     await upstreamClient.connect();
   } 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);
   }
   let tools;
   try {
     tools = await upstreamClient.listTools();
   } 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);
   }
   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));
+  process5.on("SIGINT", () => shutdown(0));
+  process5.on("SIGTERM", () => shutdown(0));
+  process5.stdin.on("end", () => shutdown(0));
+  process5.stdin.on("close", () => shutdown(0));
   try {
     await proxyServer.start();
   } catch (error) {
@@ -534,9 +714,9 @@ async function startProxy(command, args) {
     throw error;
   }
 }
-async function startProxyFromConfig(configPath) {
+async function startProxyFromConfig(options = {}) {
   let isShuttingDown = false;
-  const config = loadConfig(configPath);
+  const config = loadConfig(options);
   const mcps = /* @__PURE__ */ new Map();
   for (const [name, entry] of Object.entries(config.mcp)) {
     mcps.set(name, { transport: createTransport(entry) });
@@ -544,7 +724,7 @@ async function startProxyFromConfig(configPath) {
   const orchestrator = new Orchestrator({
     mcps,
     onTransportError: (mcpName2, error) => {
-      process4.stderr.write(`Upstream MCP "${mcpName2}" transport error: ${error.message}
+      process5.stderr.write(`Upstream MCP "${mcpName2}" transport error: ${error.message}
 `);
       shutdown(1);
     }
@@ -553,27 +733,27 @@ async function startProxyFromConfig(configPath) {
     if (isShuttingDown) return;
     isShuttingDown = true;
     orchestrator.disconnectAll().catch((error) => {
-      process4.stderr.write(
+      process5.stderr.write(
         `dynmcp: error during disconnect: ${error instanceof Error ? error.message : String(error)}
 `
       );
-    }).finally(() => process4.exit(exitCode));
+    }).finally(() => process5.exit(exitCode));
   };
   try {
     await orchestrator.connect();
   } 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);
   }
   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));
+  process5.on("SIGINT", () => shutdown(0));
+  process5.on("SIGTERM", () => shutdown(0));
+  process5.stdin.on("end", () => shutdown(0));
+  process5.stdin.on("close", () => shutdown(0));
   try {
     await proxyServer.start();
   } catch (error) {
@@ -593,39 +773,43 @@ var cliBanner = chalk.bold.magentaBright(
 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("--");
+).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 = process6.argv.indexOf("--");
   const configPath = cmd.opts().config;
+  const envFilePath = cmd.opts().env;
   if (separatorIndex !== -1) {
-    const [command, ...args] = process5.argv.slice(separatorIndex + 1);
+    const [command, ...args] = process6.argv.slice(separatorIndex + 1);
     if (command === void 0) {
-      process5.stderr.write(
+      process6.stderr.write(
         "dynmcp: no upstream command provided after --.\nUsage: dynmcp -- <command> [args...]\n"
       );
-      process5.exit(1);
+      process6.exit(1);
     }
     try {
       await startProxy(command, args);
     } catch (error) {
-      process5.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+      process6.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
 `);
-      process5.exit(1);
+      process6.exit(1);
     }
     return;
   }
   try {
-    await startProxyFromConfig(configPath);
+    await startProxyFromConfig({ configPath, envFilePath });
   } catch (error) {
-    process5.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
+    process6.stderr.write(`dynmcp: ${error instanceof Error ? error.message : String(error)}
 `);
-    process5.exit(1);
+    process6.exit(1);
   }
 });
 
 // src/index.ts
-import process6 from "process";
+import process7 from "process";
 async function main() {
-  cli.parse(process6.argv);
+  cli.parse(process7.argv);
 }
 main();
 //# sourceMappingURL=index.js.map