mcpknife 0.1.5 → 0.1.6

package/dist/cli.js

@@ -4,7 +4,7 @@
 import { createRequire as createRequire2 } from "node:module";
 import { readFileSync as readFileSync3 } from "node:fs";
 import { fileURLToPath } from "node:url";
-import path3 from "node:path";
+import path4 from "node:path";
 
 // src/config.ts
 import { readFileSync } from "node:fs";
@@ -94,13 +94,13 @@ var CONFIG_FLAG_MAP = [
   { configKey: "apiKey", flag: "--api-key", isBoolean: false },
   { configKey: "verbose", flag: "--verbose", isBoolean: true }
 ];
-function hasFlag(argv2, flag) {
-  return argv2.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+function hasFlag(argv, flag) {
+  return argv.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
 }
-function buildArgv(config2, rawArgv2) {
+function buildArgv(config, rawArgv2) {
   const injected = [];
   for (const { configKey, flag, isBoolean } of CONFIG_FLAG_MAP) {
-    const value = config2[configKey];
+    const value = config[configKey];
     if (value === void 0 || value === false) continue;
     if (hasFlag(rawArgv2, flag)) continue;
     if (isBoolean) {
@@ -114,8 +114,8 @@ function buildArgv(config2, rawArgv2) {
 
 // src/spawn.ts
 import { spawn } from "node:child_process";
-function spawnTool(binaryPath2, argv2) {
-  const child = spawn(process.execPath, [binaryPath2, ...argv2], {
+function spawnTool(binaryPath, argv) {
+  const child = spawn(process.execPath, [binaryPath, ...argv], {
     stdio: "inherit",
     env: process.env
   });
@@ -130,7 +130,7 @@ function spawnTool(binaryPath2, argv2) {
   forwardSignal("SIGTERM");
   child.on("error", (err) => {
     if (err.code === "ENOENT") {
-      console.error(`mcpknife: binary not found: ${binaryPath2}`);
+      console.error(`mcpknife: binary not found: ${binaryPath}`);
       console.error(`Try reinstalling: npm install -g mcpknife`);
     } else {
       console.error(`mcpknife: failed to start: ${err.message}`);
@@ -146,11 +146,561 @@ function spawnTool(binaryPath2, argv2) {
   });
 }
 
+// src/export.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// src/codegen.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import path3 from "node:path";
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+}
+function writeJSON(filePath, data) {
+  writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+function writeText(filePath, content) {
+  writeFileSync(filePath, content);
+}
+function generatePackageJson(stages) {
+  const stageNames = stages.map((s) => s.stage).join("+");
+  return {
+    name: "exported-mcp-server",
+    version: "1.0.0",
+    description: `Standalone MCP server exported from mcpknife pipeline (${stageNames})`,
+    type: "module",
+    main: "server.js",
+    scripts: {
+      start: "node server.js"
+    },
+    dependencies: {
+      "@modelcontextprotocol/sdk": "^1.12.1"
+    }
+  };
+}
+function generateReadme(stages) {
+  const lines = [
+    "# Exported MCP Server",
+    "",
+    `Standalone server exported from a mcpknife pipeline with ${stages.length} stage(s).`,
+    "",
+    "## Quick Start",
+    "",
+    "```bash",
+    "npm install",
+    "node server.js",
+    "```",
+    "",
+    `The server listens on \`http://localhost:\${PORT}/mcp\` (default PORT=8000).`,
+    "",
+    "## Pipeline Stages",
+    ""
+  ];
+  for (const stage of stages) {
+    lines.push(`### ${stage.stage} (v${stage.version})`);
+    lines.push("");
+    if (stage.stage === "boot") {
+      const boot = stage;
+      lines.push(`Tools: ${boot.tools.map((t) => t.name).join(", ")}`);
+      if (boot.whitelist_domains.length > 0) {
+        lines.push(`Network domains: ${boot.whitelist_domains.join(", ")}`);
+      }
+    } else if (stage.stage === "mod") {
+      const mod = stage;
+      if (mod.pass_through_tools.length > 0) {
+        lines.push(`Pass-through: ${mod.pass_through_tools.map((t) => t.exposed_name).join(", ")}`);
+      }
+      if (mod.synthetic_tools.length > 0) {
+        lines.push(`Synthetic: ${mod.synthetic_tools.map((t) => t.name).join(", ")}`);
+      }
+      if (mod.hidden_tools.length > 0) {
+        lines.push(`Hidden: ${mod.hidden_tools.join(", ")}`);
+      }
+    } else if (stage.stage === "ui") {
+      const ui = stage;
+      lines.push(`UI resources: ${ui.ui_resources.map((r) => r.tool_name).join(", ")}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function getExposedTools(stages) {
+  const boot = stages.find((s) => s.stage === "boot");
+  const mod = stages.find((s) => s.stage === "mod");
+  if (mod) {
+    const tools = [];
+    for (const t of mod.pass_through_tools) {
+      tools.push({
+        name: t.exposed_name,
+        description: t.description || "",
+        inputSchema: t.exposed_schema
+      });
+    }
+    for (const t of mod.synthetic_tools) {
+      tools.push({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.input_schema
+      });
+    }
+    return tools;
+  }
+  if (boot) {
+    return boot.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.input_schema
+    }));
+  }
+  return [];
+}
+function generateServerJs(stages) {
+  const boot = stages.find((s) => s.stage === "boot");
+  const mod = stages.find((s) => s.stage === "mod");
+  const ui = stages.find((s) => s.stage === "ui");
+  const hasNetwork = boot?.tools.some((t) => t.needs_network) ?? false;
+  const whitelistDomains = boot?.whitelist_domains ?? [];
+  const exposedTools = getExposedTools(stages);
+  const importLines = [
+    'import { Server } from "@modelcontextprotocol/sdk/server/index.js";',
+    'import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";',
+    'import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";',
+    'import http from "node:http";',
+    'import vm from "node:vm";',
+    'import { readFileSync } from "node:fs";',
+    'import { fileURLToPath } from "node:url";',
+    'import path from "node:path";'
+  ];
+  if (ui) {
+    importLines.push(
+      'import { ListResourcesRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";'
+    );
+  }
+  const parts = [];
+  parts.push(importLines.join("\n"));
+  parts.push("");
+  parts.push("const __filename = fileURLToPath(import.meta.url);");
+  parts.push("const __dirname = path.dirname(__filename);");
+  parts.push("");
+  if (hasNetwork) {
+    parts.push(`const WHITELIST_DOMAINS = ${JSON.stringify(whitelistDomains)};`);
+    parts.push("");
+    parts.push(`function isAllowed(url) {
+  try {
+    const hostname = new URL(url).hostname;
+    return WHITELIST_DOMAINS.some(d => hostname === d || hostname.endsWith("." + d));
+  } catch {
+    return false;
+  }
+}
+
+const whitelistedFetch = (url, opts) => {
+  if (!isAllowed(url)) {
+    throw new Error("Network access denied: " + url);
+  }
+  return fetch(url, opts);
+};`);
+    parts.push("");
+  }
+  parts.push(`const SANDBOX_TIMEOUT_MS = 30000;
+
+function runHandler(code, args) {
+  const sandbox = {
+    args,
+    JSON, Math, String, Number, Boolean, Array, Object, Map, Set,
+    Date, RegExp, parseInt, parseFloat, isNaN, isFinite,
+    structuredClone, console: { log: console.log },
+    Promise,${hasNetwork ? "\n    fetch: whitelistedFetch," : ""}
+  };
+
+  const context = vm.createContext(sandbox);
+  const wrappedCode = "(async function(args) { " + code + " })(args)";
+  const script = new vm.Script(wrappedCode);
+  return script.runInContext(context, { timeout: SANDBOX_TIMEOUT_MS });
+}`);
+  parts.push("");
+  if (boot) {
+    parts.push(`// Boot tool handlers
+const bootHandlers = new Map();
+${boot.tools.map(
+      (t) => `bootHandlers.set(${JSON.stringify(t.name)}, readFileSync(path.join(__dirname, "handlers", ${JSON.stringify(t.name + ".js")}), "utf-8"));`
+    ).join("\n")}`);
+    parts.push("");
+    parts.push(`async function callBootTool(name, args) {
+  const code = bootHandlers.get(name);
+  if (!code) throw new Error("Unknown boot tool: " + name);
+  return runHandler(code, args);
+}`);
+    parts.push("");
+  }
+  if (mod) {
+    if (mod.pass_through_tools.some((t) => t.input_transform_code || t.output_transform_code)) {
+      parts.push(`// Mod transforms
+const transforms = new Map();
+${mod.pass_through_tools.filter((t) => t.input_transform_code || t.output_transform_code).map(
+        (t) => `transforms.set(${JSON.stringify(t.exposed_name)}, JSON.parse(readFileSync(path.join(__dirname, "transforms", ${JSON.stringify(t.exposed_name + ".json")}), "utf-8")));`
+      ).join("\n")}`);
+      parts.push("");
+    }
+    if (mod.synthetic_tools.length > 0) {
+      parts.push(`// Synthetic tool orchestrations
+const orchestrations = new Map();
+${mod.synthetic_tools.map(
+        (t) => `orchestrations.set(${JSON.stringify(t.name)}, readFileSync(path.join(__dirname, "orchestrations", ${JSON.stringify(t.name + ".js")}), "utf-8"));`
+      ).join("\n")}`);
+      parts.push("");
+    }
+    parts.push(`const toolRouting = new Map();`);
+    for (const t of mod.pass_through_tools) {
+      parts.push(`toolRouting.set(${JSON.stringify(t.exposed_name)}, ${JSON.stringify(t.upstream_name)});`);
+    }
+    parts.push("");
+  }
+  parts.push(`async function dispatchTool(name, args) {`);
+  if (mod) {
+    parts.push(`  // Synthetic tools
+  if (orchestrations && orchestrations.has(name)) {
+    const code = orchestrations.get(name);
+    const callTool = async (n, a) => callBootTool(n, a);
+    const sandbox = {
+      args, callTool,
+      JSON, Math, String, Number, Boolean, Array, Object, Map, Set,
+      Date, RegExp, parseInt, parseFloat, isNaN, isFinite,
+      structuredClone, console: { log: console.log },
+      Promise,${hasNetwork ? "\n      fetch: whitelistedFetch," : ""}
+    };
+    const context = vm.createContext(sandbox);
+    const wrappedCode = "(async function(args, callTool) { " + code + " })(args, callTool)";
+    const script = new vm.Script(wrappedCode);
+    return script.runInContext(context, { timeout: SANDBOX_TIMEOUT_MS });
+  }`);
+    parts.push("");
+    parts.push(`  // Pass-through and modified tools
+  const upstreamName = toolRouting.get(name);
+  if (upstreamName !== undefined) {
+    let callArgs = args;
+
+    // Apply input transform if present
+    const transform = transforms ? transforms.get(name) : undefined;
+    if (transform && transform.input_transform_code) {
+      try {
+        const fn = new Function("args", transform.input_transform_code);
+        callArgs = fn(args);
+      } catch (err) {
+        console.error("Input transform error for " + name + ": " + err);
+      }
+    }
+
+    // Call boot handler
+    let result = await callBootTool(upstreamName, callArgs);
+
+    // Apply output transform if present
+    if (transform && transform.output_transform_code) {
+      try {
+        const fn = new Function("result", transform.output_transform_code);
+        result = fn(result);
+      } catch (err) {
+        console.error("Output transform error for " + name + ": " + err);
+      }
+    }
+
+    return result;
+  }`);
+    parts.push("");
+  }
+  if (boot && !mod) {
+    parts.push(`  return callBootTool(name, args);`);
+  } else {
+    parts.push(`  return { content: [{ type: "text", text: "Unknown tool: " + name }], isError: true };`);
+  }
+  parts.push(`}`);
+  parts.push("");
+  parts.push(`const TOOLS = ${JSON.stringify(exposedTools, null, 2)};`);
+  parts.push("");
+  if (ui && ui.ui_resources.length > 0) {
+    parts.push(`// UI resources
+const uiResources = new Map();
+${ui.ui_resources.map(
+      (r) => `uiResources.set(${JSON.stringify(r.resource_uri)}, {
+  toolName: ${JSON.stringify(r.tool_name)},
+  html: readFileSync(path.join(__dirname, "ui", ${JSON.stringify(r.tool_name + ".html")}), "utf-8"),
+});`
+    ).join("\n")}`);
+    parts.push("");
+  }
+  parts.push(`const PORT = parseInt(process.env.PORT || "8000", 10);
+
+const httpServer = http.createServer(async (req, res) => {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, mcp-session-id");
+
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  if (req.method === "POST" && (req.url === "/mcp" || req.url === "/")) {
+    const mcpServer = new Server(
+      { name: "exported-mcp-server", version: "1.0.0" },
+      { capabilities: { tools: {}${ui ? ", resources: {}" : ""} } },
+    );
+
+    mcpServer.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: TOOLS.map(t => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+      })),
+    }));
+
+    mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      return dispatchTool(name, args || {});
+    });`);
+  if (ui && ui.ui_resources.length > 0) {
+    parts.push(`
+    mcpServer.setRequestHandler(ListResourcesRequestSchema, async () => ({
+      resources: Array.from(uiResources.entries()).map(([uri, r]) => ({
+        uri,
+        name: r.toolName + " UI",
+        description: "Generated interactive UI for " + r.toolName,
+        mimeType: "text/html",
+      })),
+    }));
+
+    mcpServer.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const uri = request.params.uri;
+      const resource = uiResources.get(uri);
+      if (!resource) throw new Error("Unknown resource: " + uri);
+      return {
+        contents: [{ uri, mimeType: "text/html", text: resource.html }],
+      };
+    });`);
+  }
+  parts.push(`
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    try {
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      const body = JSON.parse(Buffer.concat(chunks).toString());
+      await mcpServer.connect(transport);
+      await transport.handleRequest(req, res, body);
+      res.on("close", () => {
+        transport.close();
+        mcpServer.close();
+      });
+    } catch (error) {
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32603, message: String(error) },
+          id: null,
+        }));
+      }
+    }
+  } else if (req.method === "GET" && req.url === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "ok", tools: TOOLS.length }));
+  } else {
+    res.writeHead(404);
+    res.end("Not found");
+  }
+});
+
+httpServer.listen(PORT, () => {
+  console.log("Exported MCP server listening on http://localhost:" + PORT + "/mcp");
+  console.log("Serving " + TOOLS.length + " tool(s)");
+});
+
+process.on("SIGINT", () => { httpServer.close(); process.exit(0); });
+process.on("SIGTERM", () => { httpServer.close(); process.exit(0); });`);
+  return parts.join("\n");
+}
+async function generateProject(stages, outputDir) {
+  const absDir = path3.resolve(outputDir);
+  ensureDir(absDir);
+  const boot = stages.find((s) => s.stage === "boot");
+  const mod = stages.find((s) => s.stage === "mod");
+  const ui = stages.find((s) => s.stage === "ui");
+  writeJSON(path3.join(absDir, "package.json"), generatePackageJson(stages));
+  if (boot) {
+    const handlersDir = path3.join(absDir, "handlers");
+    ensureDir(handlersDir);
+    for (const tool of boot.tools) {
+      writeText(path3.join(handlersDir, `${tool.name}.js`), tool.handler_code);
+    }
+  }
+  if (mod) {
+    const modifiedTools = mod.pass_through_tools.filter(
+      (t) => t.input_transform_code || t.output_transform_code
+    );
+    if (modifiedTools.length > 0) {
+      const transformsDir = path3.join(absDir, "transforms");
+      ensureDir(transformsDir);
+      for (const tool of modifiedTools) {
+        writeJSON(path3.join(transformsDir, `${tool.exposed_name}.json`), {
+          input_transform_code: tool.input_transform_code,
+          output_transform_code: tool.output_transform_code
+        });
+      }
+    }
+    if (mod.synthetic_tools.length > 0) {
+      const orchDir = path3.join(absDir, "orchestrations");
+      ensureDir(orchDir);
+      for (const tool of mod.synthetic_tools) {
+        writeText(path3.join(orchDir, `${tool.name}.js`), tool.orchestration_code);
+      }
+    }
+  }
+  if (ui && ui.ui_resources.length > 0) {
+    const uiDir = path3.join(absDir, "ui");
+    ensureDir(uiDir);
+    for (const resource of ui.ui_resources) {
+      writeText(path3.join(uiDir, `${resource.tool_name}.html`), resource.html);
+    }
+  }
+  writeText(path3.join(absDir, "server.js"), generateServerJs(stages));
+  writeText(path3.join(absDir, "README.md"), generateReadme(stages));
+}
+
+// src/export.ts
+function parseExportArgs(argv) {
+  let outputDir = "./exported_mcp";
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      help = true;
+    } else if (arg === "--output-dir" && i + 1 < argv.length) {
+      outputDir = argv[++i];
+    } else if (arg.startsWith("--output-dir=")) {
+      outputDir = arg.slice("--output-dir=".length);
+    }
+  }
+  return { outputDir, help };
+}
+function printExportHelp() {
+  console.log(`mcpknife export \u2014 dump a self-contained MCP server project to disk
+
+Usage:
+  mcpknife export [--output-dir <dir>]
+
+Options:
+  --output-dir <dir>  Output directory (default: ./exported_mcp)
+  --help              Show this help message
+
+The export command reads an upstream MCP server URL from stdin (pipe protocol)
+and recursively walks the _mcp_metadata chain to collect all implementation code,
+then combines it into a standalone Node.js project.
+
+Examples:
+  mcpknife boot --prompt "Dictionary API" | mcpknife export
+  mcpknife boot ... | mcpknife mod ... | mcpknife export --output-dir ./my-server
+  mcpknife boot ... | mcpknife mod ... | mcpknife ui | mcpknife export`);
+}
+function readUrlFromStdin(timeoutMs = 1e4) {
+  return new Promise((resolve, reject) => {
+    if (process.stdin.isTTY) {
+      reject(new Error(
+        "export reads upstream URL from stdin pipe.\nUsage: mcpknife boot ... | mcpknife export\n   or: mcpknife boot ... | mcpknife mod ... | mcpknife export"
+      ));
+      return;
+    }
+    let data = "";
+    const timer = setTimeout(() => {
+      process.stdin.removeAllListeners();
+      process.stdin.destroy();
+      reject(new Error("Timed out waiting for upstream URL on stdin"));
+    }, timeoutMs);
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+      const lines = data.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+          clearTimeout(timer);
+          process.stdin.removeAllListeners();
+          process.stdin.destroy();
+          resolve(trimmed);
+          return;
+        }
+      }
+    });
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      const trimmed = data.trim();
+      if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+        resolve(trimmed);
+      } else {
+        reject(new Error(`Invalid upstream URL on stdin: "${trimmed.slice(0, 100)}"`));
+      }
+    });
+    process.stdin.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    process.stdin.resume();
+  });
+}
+async function fetchMetadata(url) {
+  const client = new Client(
+    { name: "mcpknife-export", version: "0.1.0" },
+    { capabilities: {} }
+  );
+  const transport = new StreamableHTTPClientTransport(new URL(url));
+  await client.connect(transport);
+  try {
+    const result = await client.callTool({
+      name: "_mcp_metadata",
+      arguments: {}
+    });
+    const content = result.content;
+    if (!content || content.length === 0 || !content[0].text) {
+      throw new Error(`Empty _mcp_metadata response from ${url}`);
+    }
+    return JSON.parse(content[0].text);
+  } finally {
+    await client.close();
+  }
+}
+async function crawlPipeline(url) {
+  const stages = [];
+  let currentUrl = url;
+  while (currentUrl) {
+    const metadata = await fetchMetadata(currentUrl);
+    stages.push(metadata);
+    currentUrl = metadata.upstream_url ?? null;
+  }
+  stages.reverse();
+  return stages;
+}
+async function runExport(argv) {
+  const { outputDir, help } = parseExportArgs(argv);
+  if (help) {
+    printExportHelp();
+    return;
+  }
+  console.error("[export] Reading upstream URL from stdin...");
+  const url = await readUrlFromStdin();
+  console.error(`[export] Upstream URL: ${url}`);
+  console.error("[export] Crawling pipeline metadata...");
+  const stages = await crawlPipeline(url);
+  console.error(`[export] Found ${stages.length} stage(s): ${stages.map((s) => s.stage).join(" \u2192 ")}`);
+  console.error(`[export] Generating project in ${outputDir}...`);
+  await generateProject(stages, outputDir);
+  console.error(`[export] Done! Project written to ${outputDir}`);
+  console.error(`[export] To run: cd ${outputDir} && npm install && node server.js`);
+}
+
 // src/cli.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path3.dirname(__filename);
+var __dirname = path4.dirname(__filename);
 var require3 = createRequire2(import.meta.url);
-var pkgPath = path3.resolve(__dirname, "..", "package.json");
+var pkgPath = path4.resolve(__dirname, "..", "package.json");
 var version = "0.1.0";
 try {
   const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
@@ -167,6 +717,7 @@ Commands:
   boot    Generate an MCP server from a prompt and API docs
   mod     Transform tools on an existing MCP server
   ui      Add interactive UI to an MCP server
+  export  Dump a self-contained MCP server project to disk
 
 Options:
   --help      Show this help message
@@ -185,6 +736,9 @@ Examples:
   # Full pipeline
   mcpknife boot --prompt "Yahoo Finance" | mcpknife mod --prompt "combine tools" | mcpknife ui
 
+  # Export standalone server
+  mcpknife boot --prompt "Dictionary API" | mcpknife mod --prompt "synonyms" | mcpknife export
+
 Run 'mcpknife <command> --help' for command-specific options.`);
 }
 var args = process.argv.slice(2);
@@ -201,12 +755,18 @@ if (args[0] === "--version" || args[0] === "-V") {
 }
 var subcommand = args[0];
 var rawArgv = args.slice(1);
-if (!BINARY_MAP[subcommand]) {
+if (subcommand === "export") {
+  runExport(rawArgv).then(() => process.exit(0)).catch((err) => {
+    console.error(`mcpknife export: ${err.message}`);
+    process.exit(1);
+  });
+} else if (!BINARY_MAP[subcommand]) {
   console.error(`mcpknife: unknown subcommand '${subcommand}'`);
   console.error(`Run 'mcpknife --help' for usage`);
   process.exit(1);
+} else {
+  const config = loadConfig();
+  const binaryPath = resolveBinary(subcommand);
+  const argv = buildArgv(config, rawArgv);
+  spawnTool(binaryPath, argv);
 }
-var config = loadConfig();
-var binaryPath = resolveBinary(subcommand);
-var argv = buildArgv(config, rawArgv);
-spawnTool(binaryPath, argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcpknife",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Swiss Army knife for MCP servers — generate, transform, and add UIs with Unix pipes",
   "type": "module",
   "bin": {
@@ -28,9 +28,10 @@
   "license": "Apache-2.0",
   "author": "Vivek Haldar",
   "dependencies": {
-    "mcp-gen-ui": "^0.1.9",
-    "mcpblox": "^0.1.1",
-    "mcpboot": "^0.1.0"
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "mcp-gen-ui": "^0.1.11",
+    "mcpblox": "^0.1.3",
+    "mcpboot": "^0.1.3"
   },
   "devDependencies": {
     "esbuild": "^0.25.0",