@ai-ecoverse/mcpcat 0.7.0 → 0.8.0

package/dist/host/mcpcat.mjs

@@ -6817,16 +6817,16 @@ async function createStatelessConnection(options) {
     }
     if (res.status >= 400) {
       const text = await res.text();
-      let rpcError2;
+      let rpcError3;
       try {
         const parsed = JSON.parse(text);
         if (parsed.error && typeof parsed.error.code === "number") {
-          rpcError2 = parsed.error;
+          rpcError3 = parsed.error;
         }
       } catch {
       }
-      if (rpcError2) {
-        throw new StatelessRpcError(rpcError2.code, rpcError2.message, rpcError2.data);
+      if (rpcError3) {
+        throw new StatelessRpcError(rpcError3.code, rpcError3.message, rpcError3.data);
       }
       throw new StatelessHttpError(res.status, res.statusText, method, text.slice(0, 512));
     }
@@ -9539,6 +9539,208 @@ function checkHost(host, boundLoopback) {
   return { ok: false, reason: `host ${host} is not loopback` };
 }
 
+// src/serve/proxy.ts
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
+  "initialize",
+  "server/discover",
+  "tools/list",
+  "resources/list",
+  "prompts/list",
+  "ping"
+]);
+var PROTOCOL_VERSIONS2 = ["2026-07-28", "2025-11-25", "2025-06-18"];
+var JSON_CT2 = "application/json; charset=utf-8";
+function readId2(value) {
+  const id = Object.getOwnPropertyDescriptor(value, "id")?.value;
+  if (typeof id === "string" || typeof id === "number" || id === null) return id;
+  return null;
+}
+function readString2(value, key) {
+  const found = Object.getOwnPropertyDescriptor(value, key)?.value;
+  return typeof found === "string" ? found : void 0;
+}
+function hasOwn2(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function rpcOk2(id, result) {
+  return {
+    status: 200,
+    contentType: JSON_CT2,
+    body: JSON.stringify({ jsonrpc: "2.0", id, result })
+  };
+}
+function rpcError2(id, code2, message) {
+  return {
+    status: 200,
+    contentType: JSON_CT2,
+    body: JSON.stringify({ jsonrpc: "2.0", id, error: { code: code2, message } })
+  };
+}
+function scrubValue(value, secrets) {
+  if (typeof value === "string") return scrubString(value, secrets);
+  if (Array.isArray(value)) return value.map((v) => scrubValue(v, secrets));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = scrubValue(v, secrets);
+    }
+    return out;
+  }
+  return value;
+}
+function scrubString(s, secrets) {
+  let result = s;
+  for (const h of secrets) {
+    if (result.includes(h)) {
+      result = result.replaceAll(h, "***");
+    }
+  }
+  return result;
+}
+function translateCapabilities(info) {
+  const caps = {};
+  if (info.capabilities.tools) caps.tools = { listChanged: false };
+  if (info.capabilities.resources) caps.resources = { listChanged: false };
+  if (info.capabilities.prompts) caps.prompts = { listChanged: false };
+  return caps;
+}
+function buildServerResult(info, protocolVersion) {
+  return {
+    protocolVersion,
+    capabilities: translateCapabilities(info),
+    serverInfo: {
+      name: info.name ?? "mcpcat-proxy",
+      version: info.version ?? "0.0.0",
+      ...info.title ? { title: info.title } : {}
+    },
+    ...info.instructions ? { instructions: info.instructions } : {}
+  };
+}
+function createProxyHandler(options) {
+  let conn = null;
+  let cachedInfo = null;
+  let connecting = null;
+  const secrets = options.hiddenHeaders;
+  async function doConnect() {
+    const c = await connect(options.platform, options.connectOpts);
+    cachedInfo = await c.info();
+    return c;
+  }
+  async function getConnection() {
+    if (conn) return conn;
+    if (connecting !== null) return connecting;
+    connecting = doConnect();
+    try {
+      conn = await connecting;
+      return conn;
+    } finally {
+      connecting = null;
+    }
+  }
+  async function reconnect() {
+    if (conn) {
+      try {
+        await conn.close();
+      } catch {
+      }
+    }
+    conn = null;
+    cachedInfo = null;
+    return getConnection();
+  }
+  function scrubOk(id, result) {
+    return rpcOk2(id, scrubValue(result, secrets));
+  }
+  function scrubErr(id, code2, message) {
+    return rpcError2(id, code2, scrubString(message, secrets));
+  }
+  function handleInitialize(id, params) {
+    const requested = params && typeof params === "object" ? Object.getOwnPropertyDescriptor(params, "protocolVersion")?.value : void 0;
+    const pv = PROTOCOL_VERSIONS2.find((v) => v === requested) ?? PROTOCOL_VERSIONS2[0];
+    return scrubOk(id, buildServerResult(cachedInfo, pv));
+  }
+  function handleDiscover(id) {
+    return scrubOk(id, {
+      ...buildServerResult(cachedInfo, PROTOCOL_VERSIONS2[0]),
+      supportedVersions: PROTOCOL_VERSIONS2
+    });
+  }
+  async function forwardWithRetry(method, doForward, id) {
+    try {
+      return scrubOk(id, await doForward());
+    } catch (err) {
+      if (!IDEMPOTENT_METHODS.has(method)) {
+        return scrubErr(id, -32e3, err.message);
+      }
+      try {
+        await reconnect();
+        return scrubOk(id, await doForward());
+      } catch (retryErr) {
+        return scrubErr(id, -32e3, retryErr.message);
+      }
+    }
+  }
+  async function handleCall(id, params, c) {
+    const name = params && typeof params === "object" ? readString2(params, "name") : void 0;
+    if (!name) return scrubErr(id, -32602, "tools/call requires a name");
+    const args2 = params && typeof params === "object" ? Object.getOwnPropertyDescriptor(params, "arguments")?.value : void 0;
+    try {
+      return scrubOk(id, await c.callTool(name, args2));
+    } catch (err) {
+      return scrubErr(id, -32e3, err.message);
+    }
+  }
+  async function dispatch(method, id, params) {
+    try {
+      await getConnection();
+    } catch (err) {
+      if (method === "ping") return rpcOk2(id, {});
+      return scrubErr(id, -32e3, `upstream connection failed: ${err.message}`);
+    }
+    if (method === "initialize") return handleInitialize(id, params);
+    if (method === "server/discover") return handleDiscover(id);
+    if (method === "ping") return rpcOk2(id, {});
+    if (method === "tools/list") {
+      return forwardWithRetry(
+        method,
+        async () => {
+          const tools = await (await getConnection()).listTools();
+          return { tools };
+        },
+        id
+      );
+    }
+    if (method === "tools/call") return handleCall(id, params, conn);
+    return scrubErr(id, -32601, `Method not found: ${method}`);
+  }
+  async function handle(raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return rpcError2(null, -32700, "Parse error");
+    }
+    if (Array.isArray(parsed)) return rpcError2(null, -32600, "Batch requests are not supported");
+    if (!parsed || typeof parsed !== "object") return rpcError2(null, -32600, "Invalid request");
+    const method = readString2(parsed, "method");
+    if (!method) return rpcError2(readId2(parsed), -32600, "Invalid request");
+    if (!hasOwn2(parsed, "id")) return { status: 202, contentType: "text/plain", body: "" };
+    const id = readId2(parsed);
+    const params = Object.getOwnPropertyDescriptor(parsed, "params")?.value;
+    return dispatch(method, id, params);
+  }
+  async function shutdown() {
+    if (conn) {
+      try {
+        await conn.close();
+      } catch {
+      }
+      conn = null;
+    }
+  }
+  return { handle, shutdown };
+}
+
 // src/serve/runtime.ts
 var CALL_TIMEOUT_MS = 12e4;
 var MAX_OUTPUT_DEFAULT = 1048576;
@@ -9569,26 +9771,57 @@ function parseSingleFlag(args2, i, opts) {
     opts.host = parsed.host;
     opts.port = parsed.port;
     return parsed.next;
-  } else if (arg === "--bearer" && args2[i + 1]) {
-    opts.bearer = args2[++i];
-  } else if (arg === "--allow-origin" && args2[i + 1]) {
-    opts.allowOrigins.push(args2[++i]);
-  } else if (arg === "--env" && args2[i + 1]) {
-    opts.envAllow.push(args2[++i]);
-  } else if (arg === "--tool" && args2[i + 1]) {
-    opts.toolTemplates.push(args2[++i]);
-  } else if (arg === "--call-timeout" && args2[i + 1]) {
-    opts.callTimeout = Number(args2[++i]) * 1e3;
-  } else if (arg === "--concurrency" && args2[i + 1]) {
-    opts.concurrency = Number(args2[++i]);
-  } else if (arg === "--max-output" && args2[i + 1]) {
-    opts.maxOutput = Number(args2[++i]);
-  } else if (arg === "--cwd" && args2[i + 1]) {
-    opts.cwd = args2[++i];
   } else if (arg === "--json") {
     opts.json = true;
   } else if (!arg.startsWith("-")) {
     opts.commands.push(parseCommandTarget(arg));
+  } else {
+    return parseValueFlag(args2, i, opts);
+  }
+  return i;
+}
+function parseValueFlag(args2, i, opts) {
+  const arg = args2[i];
+  if (!args2[i + 1]) return i;
+  switch (arg) {
+    case "--proxy":
+      opts.proxy = args2[++i];
+      break;
+    case "--bearer":
+      opts.bearer = args2[++i];
+      break;
+    case "--allow-origin":
+      opts.allowOrigins.push(args2[++i]);
+      break;
+    case "--env":
+      opts.envAllow.push(args2[++i]);
+      break;
+    case "--tool":
+      opts.toolTemplates.push(args2[++i]);
+      break;
+    case "--call-timeout":
+      opts.callTimeout = Number(args2[++i]) * 1e3;
+      break;
+    case "--concurrency":
+      opts.concurrency = Number(args2[++i]);
+      break;
+    case "--max-output":
+      opts.maxOutput = Number(args2[++i]);
+      break;
+    case "--cwd":
+      opts.cwd = args2[++i];
+      break;
+    case "-H":
+    case "--header": {
+      const hdr = args2[++i];
+      const colonIdx = hdr.indexOf(":");
+      if (colonIdx > 0) {
+        opts.proxyHeaders.push([hdr.slice(0, colonIdx).trim(), hdr.slice(colonIdx + 1).trim()]);
+      }
+      break;
+    }
+    default:
+      break;
   }
   return i;
 }
@@ -9606,7 +9839,9 @@ function parseServeFlags(args2) {
     maxOutput: MAX_OUTPUT_DEFAULT,
     cwd: void 0,
     json: false,
-    commands: []
+    commands: [],
+    proxy: void 0,
+    proxyHeaders: []
   };
   for (let i = 0; i < args2.length; i++) {
     i = parseSingleFlag(args2, i, opts);
@@ -9933,6 +10168,9 @@ async function runServe(platform2, options, version) {
     }
     resolvedBearer = expanded;
   }
+  if (options.proxy) {
+    return runProxyServe(platform2, options, version, resolvedBearer);
+  }
   const serveCwd = options.cwd ?? platform2.cwd;
   const childEnv = buildChildEnv(platform2, options.envAllow);
   const clis = [];
@@ -9971,6 +10209,240 @@ async function runServe(platform2, options, version) {
     resolvedBearer
   );
 }
+function resolveProxyStdio(target, version) {
+  const rest = target.slice(6);
+  const parts = rest.split(/\s+/).filter(Boolean);
+  return { command: parts[0], args: parts.slice(1), version };
+}
+function resolveProxyUrl(target, headers, version) {
+  const url = target.startsWith("http") ? target : `https://${target}`;
+  return { url, headers, version };
+}
+async function resolveProxyConfig(platform2, target, connectHeaders, hiddenValues, version) {
+  const config = await MergedConfigSource.load(platform2);
+  const entry = await config.get(target);
+  if (!entry) return `unknown target '${target}'`;
+  if ("url" in entry && entry.url) {
+    const merged = { ...entry.headers, ...connectHeaders };
+    if (entry.headers) {
+      for (const v of Object.values(entry.headers)) hiddenValues.add(v);
+    }
+    return { url: entry.url, headers: merged, version };
+  }
+  if ("command" in entry && entry.command) {
+    return {
+      command: entry.command,
+      args: entry.args,
+      env: entry.env,
+      cwd: entry.cwd,
+      version
+    };
+  }
+  return `target '${target}' has no url or command`;
+}
+async function buildProxyConnectOpts(platform2, options, version) {
+  const target = options.proxy;
+  const connectHeaders = {};
+  const hiddenValues = /* @__PURE__ */ new Set();
+  for (const [k, v] of options.proxyHeaders) {
+    const expanded = expandPlaceholdersStrict(v, platform2.env);
+    if (expanded === void 0) return { error: `unset variable in header '${k}'` };
+    const key = k.toLowerCase() === "authorization" ? "Authorization" : k;
+    connectHeaders[key] = expanded;
+    hiddenValues.add(expanded);
+  }
+  const isUrl = target.startsWith("http://") || target.startsWith("https://") || target.includes(".");
+  let connectOpts;
+  if (options.proxyCommand && options.proxyCommand.length > 0) {
+    connectOpts = {
+      command: options.proxyCommand[0],
+      args: options.proxyCommand.slice(1),
+      version
+    };
+  } else if (target.startsWith("stdio:")) {
+    connectOpts = resolveProxyStdio(target, version);
+  } else if (isUrl) {
+    connectOpts = resolveProxyUrl(target, connectHeaders, version);
+  } else {
+    const result = await resolveProxyConfig(
+      platform2,
+      target,
+      connectHeaders,
+      hiddenValues,
+      version
+    );
+    if (typeof result === "string") return { error: result };
+    connectOpts = result;
+  }
+  if (connectOpts.headers) {
+    for (const v of Object.values(connectOpts.headers)) {
+      if (v) hiddenValues.add(v);
+    }
+  }
+  return { connectOpts, hiddenValues };
+}
+async function runProxyServe(platform2, options, version, resolvedBearer) {
+  const built = await buildProxyConnectOpts(platform2, options, version);
+  if ("error" in built) {
+    await platform2.write(2, `mcpcat serve --proxy: ${built.error}
+`);
+    return 2;
+  }
+  const { connectOpts, hiddenValues } = built;
+  if (resolvedBearer) hiddenValues.add(resolvedBearer);
+  const proxy = createProxyHandler({
+    target: options.proxy,
+    connectOpts,
+    platform: platform2,
+    hiddenHeaders: hiddenValues
+  });
+  if (options.transport === "stdio") {
+    return runProxyStdio(platform2, proxy);
+  }
+  return runProxyHttp(platform2, options, proxy, resolvedBearer);
+}
+async function runProxyStdio(platform2, proxy) {
+  const reader = platform2.stdin.getReader();
+  let buffer = "";
+  const dec = new TextDecoder();
+  const enc = new TextEncoder();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += dec.decode(value, { stream: true });
+      let nlIdx;
+      while ((nlIdx = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, nlIdx).trim();
+        buffer = buffer.slice(nlIdx + 1);
+        if (!line) continue;
+        const outcome = await proxy.handle(line);
+        if (outcome.status === 202) continue;
+        const writer = platform2.stdout.getWriter();
+        await writer.write(enc.encode(`${outcome.body}
+`));
+        writer.releaseLock();
+      }
+    }
+  } finally {
+    reader.releaseLock();
+    await proxy.shutdown();
+  }
+  return 0;
+}
+async function runProxyHttp(platform2, options, proxy, resolvedBearer) {
+  if (!platform2.listen) {
+    await platform2.write(2, "mcpcat serve --proxy: HTTP transport requires platform.listen\n");
+    return 3;
+  }
+  const boundLoopback = options.host === "127.0.0.1" || options.host === "localhost" || options.host === "::1";
+  if (!boundLoopback && !resolvedBearer) {
+    await platform2.write(
+      2,
+      "mcpcat serve --proxy: --bearer is required when binding off loopback\n"
+    );
+    return 2;
+  }
+  const allowedOrigins = new Set(options.allowOrigins);
+  const listener = await platform2.listen({
+    host: options.host,
+    port: options.port
+  });
+  const actualPort = listener.port;
+  const listenUrl = `http://${options.host}:${actualPort}/mcp`;
+  if (options.json) {
+    await platform2.write(1, `${JSON.stringify({ url: listenUrl })}
+`);
+  }
+  await platform2.write(2, `mcpcat serve --proxy: listening on ${listenUrl}
+`);
+  if (options.onListening) {
+    await options.onListening(actualPort);
+  }
+  let shutdownRequested = false;
+  const shutdown = () => {
+    if (shutdownRequested) return;
+    shutdownRequested = true;
+    listener.close();
+    void proxy.shutdown();
+  };
+  if (platform2.onSignal) {
+    platform2.onSignal("SIGINT", shutdown);
+    platform2.onSignal("SIGTERM", shutdown);
+  }
+  const handler = (request) => handleProxyMcpRequest(request, proxy, allowedOrigins, boundLoopback, resolvedBearer);
+  try {
+    for await (const connection of listener) {
+      if (shutdownRequested) break;
+      const conn = connection;
+      handleConnection(conn.readable, conn.writable, handler).catch(() => {
+      }).finally(() => {
+        try {
+          conn.close();
+        } catch {
+        }
+      });
+    }
+  } catch {
+    if (!shutdownRequested) throw new Error("listener closed unexpectedly");
+  }
+  return 0;
+}
+async function handleProxyMcpRequest(request, proxy, allowedOrigins, boundLoopback, resolvedBearer) {
+  if (resolvedBearer) {
+    const authHeader = request.headers.authorization;
+    const provided = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : "";
+    if (!provided || !constantTimeEqual(provided, resolvedBearer)) {
+      return {
+        status: 401,
+        reason: "Unauthorized",
+        headers: { "content-type": "text/plain" },
+        body: "Unauthorized"
+      };
+    }
+  }
+  const originCheck = checkOrigin(request.headers.origin, allowedOrigins, boundLoopback);
+  if (!originCheck.ok) {
+    return {
+      status: 403,
+      reason: "Forbidden",
+      headers: { "content-type": "text/plain" },
+      body: originCheck.reason ?? "Forbidden"
+    };
+  }
+  const hostCheck = checkHost(request.headers.host, boundLoopback);
+  if (!hostCheck.ok) {
+    return {
+      status: 403,
+      reason: "Forbidden",
+      headers: { "content-type": "text/plain" },
+      body: hostCheck.reason ?? "Forbidden"
+    };
+  }
+  if (request.target !== "/mcp") {
+    return {
+      status: 404,
+      reason: "Not Found",
+      headers: { "content-type": "text/plain" },
+      body: "Not Found"
+    };
+  }
+  if (request.method !== "POST") {
+    return {
+      status: 405,
+      reason: "Method Not Allowed",
+      headers: { "content-type": "text/plain", allow: "POST" },
+      body: "Method Not Allowed"
+    };
+  }
+  const outcome = await proxy.handle(request.body);
+  return {
+    status: outcome.status,
+    reason: outcome.status === 200 ? "OK" : "Accepted",
+    headers: { "content-type": outcome.contentType },
+    body: outcome.body
+  };
+}
 async function runStdioServer(platform2, tools, call, serverName, version) {
   const reader = platform2.stdin.getReader();
   let buffer = "";
@@ -10477,6 +10949,14 @@ function parseAddFlagAt(flagArgs, i, flags) {
     flags.noProbe = true;
     return { next: i + 1 };
   }
+  if (arg === "--bridge") {
+    flags.bridge = true;
+    return { next: i + 1 };
+  }
+  if (arg === "--bearer" && i + 1 < flagArgs.length) {
+    flags.bearer = flagArgs[i + 1];
+    return { next: i + 2 };
+  }
   if (arg === "--config" && i + 1 < flagArgs.length) {
     flags.configFile = flagArgs[i + 1];
     return { next: i + 2 };
@@ -10513,6 +10993,7 @@ function parseAddFlags(args2) {
   const flags = {
     local: false,
     noProbe: false,
+    bridge: false,
     headers: [],
     envPairs: [],
     positional: [],
@@ -10875,6 +11356,54 @@ async function runImport(platform2, args2) {
   }
   return 0;
 }
+async function runBridge(platform2, args2, version) {
+  if (platform2.kind === "host") {
+    await platform2.write(
+      2,
+      "mcpcat add --bridge: not available on the host.\nOn the host, add stdio entries directly with: mcpcat add <name> -- <cmd>\nTo expose a stdio server over HTTP: mcpcat serve --proxy <target> --http <port>\n"
+    );
+    return 2;
+  }
+  const flags = parseAddFlags(args2);
+  if (typeof flags === "string") {
+    await platform2.write(2, `mcpcat add --bridge: ${flags}
+`);
+    return 2;
+  }
+  const name = flags.positional[0];
+  if (!name) {
+    await platform2.write(2, "mcpcat add --bridge: requires a server name\n");
+    return 2;
+  }
+  if (flags.cmdArgs.length === 0) {
+    await platform2.write(2, "mcpcat add --bridge: requires -- <command> [args...]\n");
+    return 2;
+  }
+  if (flags.bearer) {
+    await platform2.write(
+      2,
+      "mcpcat add --bridge: --bearer is not needed on the kernel loopback.\nThe kernel loopback is only reachable from inside the kernel and the agent.\n"
+    );
+    return 2;
+  }
+  const serveOptions = parseServeFlags(["--proxy", "__bridge__", "--http", "0", "--json"]);
+  serveOptions.proxyCommand = flags.cmdArgs;
+  const path = flags.configFile ?? (flags.local ? projectConfigPath(platform2) : userConfigPath(platform2));
+  serveOptions.onListening = async (actualPort) => {
+    const bridgeUrl = `http://${actualPort}.kernel.localhost/mcp`;
+    const httpConfig = { url: bridgeUrl };
+    if (flags.description) httpConfig.description = flags.description;
+    if (flags.exposure) httpConfig.exposure = flags.exposure;
+    const { replaced } = await addServer(platform2.fs, path, name, httpConfig);
+    await platform2.write(
+      1,
+      `${replaced ? "replaced" : "added"} ${name} in ${path}
+bridge does not survive a reload; runs in the foreground (start with &)
+`
+    );
+  };
+  return runServe(platform2, serveOptions, version);
+}
 
 // src/cli/main.ts
 var VERBS = [
@@ -10939,6 +11468,9 @@ Client verbs:
 
 Configuration verbs:
   add <name> <url>           Add a server to mcp.json
+  add <name> --bridge -- 
+    Bridge a stdio server to HTTP (kernel only,
+                             runs in foreground, does not survive reload)
   rm <name>                  Remove a server
   list                       List configured servers
   enable|disable <name>      Toggle a server
@@ -10948,7 +11480,7 @@ Configuration verbs:
   logout <target>            Remove tokens (not implemented yet)
 
 Server and code verbs:
-  serve [--stdio|--http] \u2026   Expose commands as MCP server
+  serve [--stdio|--http] \u2026   Expose commands or proxy upstream as MCP server
   code [-e src|file.js]      Run a codemode script
   grep <pattern> [target\u2026]   Search tools by name or description
   discover <url>             Find MCP servers at a URL
@@ -11301,10 +11833,11 @@ async function probeServer(_name, config, platform2) {
     return err.message;
   }
 }
-async function dispatchConfigVerb(platform2, verb, args2) {
+async function dispatchConfigVerb(platform2, verb, args2, version) {
   const rest = args2.slice(1);
   switch (verb) {
     case "add":
+      if (rest.includes("--bridge")) return runBridge(platform2, rest, version);
       return runAdd(platform2, rest, probeServer);
     case "rm":
       return runRm(platform2, rest);
@@ -11347,7 +11880,7 @@ async function dispatchDiscoveryVerb(platform2, parsed, args2) {
 async function dispatchServeVerb(platform2, args2, version) {
   const serveArgs = args2.slice(args2.indexOf("serve") + 1);
   const serveOptions = parseServeFlags(serveArgs);
-  if (serveOptions.commands.length === 0 && serveOptions.toolTemplates.length === 0) {
+  if (!serveOptions.proxy && serveOptions.commands.length === 0 && serveOptions.toolTemplates.length === 0) {
     await platform2.write(2, "mcpcat serve: no commands or --tool templates given\n");
     return 2;
   }
@@ -11511,7 +12044,7 @@ async function run(platform2, version, args2) {
   if (parsed.verb in CONFIG_VERBS) {
     const disc = await dispatchDiscoveryVerb(platform2, parsed, args2);
     if (disc !== void 0) return disc;
-    return dispatchConfigVerb(platform2, parsed.verb, args2);
+    return dispatchConfigVerb(platform2, parsed.verb, args2, version);
   }
   const discResult = await dispatchDiscoveryVerb(platform2, parsed, args2);
   if (discResult !== void 0) return discResult;
@@ -11754,6 +12287,7 @@ function nodeListen(options) {
 function createHostPlatform() {
   const encoder2 = new TextEncoder();
   return {
+    kind: "host",
     fetch: globalThis.fetch,
     spawn: nodeSpawn,
     listen: nodeListen,

package/dist/kernel/mcpcat.mjs

@@ -6418,16 +6418,16 @@ async function createStatelessConnection(options) {
     }
     if (res.status >= 400) {
       const text = await res.text();
-      let rpcError2;
+      let rpcError3;
       try {
         const parsed = JSON.parse(text);
         if (parsed.error && typeof parsed.error.code === "number") {
-          rpcError2 = parsed.error;
+          rpcError3 = parsed.error;
         }
       } catch {
       }
-      if (rpcError2) {
-        throw new StatelessRpcError(rpcError2.code, rpcError2.message, rpcError2.data);
+      if (rpcError3) {
+        throw new StatelessRpcError(rpcError3.code, rpcError3.message, rpcError3.data);
       }
       throw new StatelessHttpError(res.status, res.statusText, method, text.slice(0, 512));
     }
@@ -9140,6 +9140,208 @@ function checkHost(host, boundLoopback) {
   return { ok: false, reason: `host ${host} is not loopback` };
 }
 
+// src/serve/proxy.ts
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
+  "initialize",
+  "server/discover",
+  "tools/list",
+  "resources/list",
+  "prompts/list",
+  "ping"
+]);
+var PROTOCOL_VERSIONS2 = ["2026-07-28", "2025-11-25", "2025-06-18"];
+var JSON_CT2 = "application/json; charset=utf-8";
+function readId2(value) {
+  const id = Object.getOwnPropertyDescriptor(value, "id")?.value;
+  if (typeof id === "string" || typeof id === "number" || id === null) return id;
+  return null;
+}
+function readString2(value, key) {
+  const found = Object.getOwnPropertyDescriptor(value, key)?.value;
+  return typeof found === "string" ? found : void 0;
+}
+function hasOwn2(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function rpcOk2(id, result) {
+  return {
+    status: 200,
+    contentType: JSON_CT2,
+    body: JSON.stringify({ jsonrpc: "2.0", id, result })
+  };
+}
+function rpcError2(id, code, message) {
+  return {
+    status: 200,
+    contentType: JSON_CT2,
+    body: JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } })
+  };
+}
+function scrubValue(value, secrets) {
+  if (typeof value === "string") return scrubString(value, secrets);
+  if (Array.isArray(value)) return value.map((v) => scrubValue(v, secrets));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = scrubValue(v, secrets);
+    }
+    return out;
+  }
+  return value;
+}
+function scrubString(s, secrets) {
+  let result = s;
+  for (const h of secrets) {
+    if (result.includes(h)) {
+      result = result.replaceAll(h, "***");
+    }
+  }
+  return result;
+}
+function translateCapabilities(info) {
+  const caps = {};
+  if (info.capabilities.tools) caps.tools = { listChanged: false };
+  if (info.capabilities.resources) caps.resources = { listChanged: false };
+  if (info.capabilities.prompts) caps.prompts = { listChanged: false };
+  return caps;
+}
+function buildServerResult(info, protocolVersion) {
+  return {
+    protocolVersion,
+    capabilities: translateCapabilities(info),
+    serverInfo: {
+      name: info.name ?? "mcpcat-proxy",
+      version: info.version ?? "0.0.0",
+      ...info.title ? { title: info.title } : {}
+    },
+    ...info.instructions ? { instructions: info.instructions } : {}
+  };
+}
+function createProxyHandler(options) {
+  let conn = null;
+  let cachedInfo = null;
+  let connecting = null;
+  const secrets = options.hiddenHeaders;
+  async function doConnect() {
+    const c = await connect(options.platform, options.connectOpts);
+    cachedInfo = await c.info();
+    return c;
+  }
+  async function getConnection() {
+    if (conn) return conn;
+    if (connecting !== null) return connecting;
+    connecting = doConnect();
+    try {
+      conn = await connecting;
+      return conn;
+    } finally {
+      connecting = null;
+    }
+  }
+  async function reconnect() {
+    if (conn) {
+      try {
+        await conn.close();
+      } catch {
+      }
+    }
+    conn = null;
+    cachedInfo = null;
+    return getConnection();
+  }
+  function scrubOk(id, result) {
+    return rpcOk2(id, scrubValue(result, secrets));
+  }
+  function scrubErr(id, code, message) {
+    return rpcError2(id, code, scrubString(message, secrets));
+  }
+  function handleInitialize(id, params) {
+    const requested = params && typeof params === "object" ? Object.getOwnPropertyDescriptor(params, "protocolVersion")?.value : void 0;
+    const pv = PROTOCOL_VERSIONS2.find((v) => v === requested) ?? PROTOCOL_VERSIONS2[0];
+    return scrubOk(id, buildServerResult(cachedInfo, pv));
+  }
+  function handleDiscover(id) {
+    return scrubOk(id, {
+      ...buildServerResult(cachedInfo, PROTOCOL_VERSIONS2[0]),
+      supportedVersions: PROTOCOL_VERSIONS2
+    });
+  }
+  async function forwardWithRetry(method, doForward, id) {
+    try {
+      return scrubOk(id, await doForward());
+    } catch (err) {
+      if (!IDEMPOTENT_METHODS.has(method)) {
+        return scrubErr(id, -32e3, err.message);
+      }
+      try {
+        await reconnect();
+        return scrubOk(id, await doForward());
+      } catch (retryErr) {
+        return scrubErr(id, -32e3, retryErr.message);
+      }
+    }
+  }
+  async function handleCall(id, params, c) {
+    const name = params && typeof params === "object" ? readString2(params, "name") : void 0;
+    if (!name) return scrubErr(id, -32602, "tools/call requires a name");
+    const args = params && typeof params === "object" ? Object.getOwnPropertyDescriptor(params, "arguments")?.value : void 0;
+    try {
+      return scrubOk(id, await c.callTool(name, args));
+    } catch (err) {
+      return scrubErr(id, -32e3, err.message);
+    }
+  }
+  async function dispatch(method, id, params) {
+    try {
+      await getConnection();
+    } catch (err) {
+      if (method === "ping") return rpcOk2(id, {});
+      return scrubErr(id, -32e3, `upstream connection failed: ${err.message}`);
+    }
+    if (method === "initialize") return handleInitialize(id, params);
+    if (method === "server/discover") return handleDiscover(id);
+    if (method === "ping") return rpcOk2(id, {});
+    if (method === "tools/list") {
+      return forwardWithRetry(
+        method,
+        async () => {
+          const tools = await (await getConnection()).listTools();
+          return { tools };
+        },
+        id
+      );
+    }
+    if (method === "tools/call") return handleCall(id, params, conn);
+    return scrubErr(id, -32601, `Method not found: ${method}`);
+  }
+  async function handle(raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return rpcError2(null, -32700, "Parse error");
+    }
+    if (Array.isArray(parsed)) return rpcError2(null, -32600, "Batch requests are not supported");
+    if (!parsed || typeof parsed !== "object") return rpcError2(null, -32600, "Invalid request");
+    const method = readString2(parsed, "method");
+    if (!method) return rpcError2(readId2(parsed), -32600, "Invalid request");
+    if (!hasOwn2(parsed, "id")) return { status: 202, contentType: "text/plain", body: "" };
+    const id = readId2(parsed);
+    const params = Object.getOwnPropertyDescriptor(parsed, "params")?.value;
+    return dispatch(method, id, params);
+  }
+  async function shutdown() {
+    if (conn) {
+      try {
+        await conn.close();
+      } catch {
+      }
+      conn = null;
+    }
+  }
+  return { handle, shutdown };
+}
+
 // src/serve/runtime.ts
 var CALL_TIMEOUT_MS = 12e4;
 var MAX_OUTPUT_DEFAULT = 1048576;
@@ -9170,26 +9372,57 @@ function parseSingleFlag(args, i, opts) {
     opts.host = parsed.host;
     opts.port = parsed.port;
     return parsed.next;
-  } else if (arg === "--bearer" && args[i + 1]) {
-    opts.bearer = args[++i];
-  } else if (arg === "--allow-origin" && args[i + 1]) {
-    opts.allowOrigins.push(args[++i]);
-  } else if (arg === "--env" && args[i + 1]) {
-    opts.envAllow.push(args[++i]);
-  } else if (arg === "--tool" && args[i + 1]) {
-    opts.toolTemplates.push(args[++i]);
-  } else if (arg === "--call-timeout" && args[i + 1]) {
-    opts.callTimeout = Number(args[++i]) * 1e3;
-  } else if (arg === "--concurrency" && args[i + 1]) {
-    opts.concurrency = Number(args[++i]);
-  } else if (arg === "--max-output" && args[i + 1]) {
-    opts.maxOutput = Number(args[++i]);
-  } else if (arg === "--cwd" && args[i + 1]) {
-    opts.cwd = args[++i];
   } else if (arg === "--json") {
     opts.json = true;
   } else if (!arg.startsWith("-")) {
     opts.commands.push(parseCommandTarget(arg));
+  } else {
+    return parseValueFlag(args, i, opts);
+  }
+  return i;
+}
+function parseValueFlag(args, i, opts) {
+  const arg = args[i];
+  if (!args[i + 1]) return i;
+  switch (arg) {
+    case "--proxy":
+      opts.proxy = args[++i];
+      break;
+    case "--bearer":
+      opts.bearer = args[++i];
+      break;
+    case "--allow-origin":
+      opts.allowOrigins.push(args[++i]);
+      break;
+    case "--env":
+      opts.envAllow.push(args[++i]);
+      break;
+    case "--tool":
+      opts.toolTemplates.push(args[++i]);
+      break;
+    case "--call-timeout":
+      opts.callTimeout = Number(args[++i]) * 1e3;
+      break;
+    case "--concurrency":
+      opts.concurrency = Number(args[++i]);
+      break;
+    case "--max-output":
+      opts.maxOutput = Number(args[++i]);
+      break;
+    case "--cwd":
+      opts.cwd = args[++i];
+      break;
+    case "-H":
+    case "--header": {
+      const hdr = args[++i];
+      const colonIdx = hdr.indexOf(":");
+      if (colonIdx > 0) {
+        opts.proxyHeaders.push([hdr.slice(0, colonIdx).trim(), hdr.slice(colonIdx + 1).trim()]);
+      }
+      break;
+    }
+    default:
+      break;
   }
   return i;
 }
@@ -9207,7 +9440,9 @@ function parseServeFlags(args) {
     maxOutput: MAX_OUTPUT_DEFAULT,
     cwd: void 0,
     json: false,
-    commands: []
+    commands: [],
+    proxy: void 0,
+    proxyHeaders: []
   };
   for (let i = 0; i < args.length; i++) {
     i = parseSingleFlag(args, i, opts);
@@ -9534,6 +9769,9 @@ async function runServe(platform2, options, version) {
     }
     resolvedBearer = expanded;
   }
+  if (options.proxy) {
+    return runProxyServe(platform2, options, version, resolvedBearer);
+  }
   const serveCwd = options.cwd ?? platform2.cwd;
   const childEnv = buildChildEnv(platform2, options.envAllow);
   const clis = [];
@@ -9572,6 +9810,240 @@ async function runServe(platform2, options, version) {
     resolvedBearer
   );
 }
+function resolveProxyStdio(target, version) {
+  const rest = target.slice(6);
+  const parts = rest.split(/\s+/).filter(Boolean);
+  return { command: parts[0], args: parts.slice(1), version };
+}
+function resolveProxyUrl(target, headers, version) {
+  const url = target.startsWith("http") ? target : `https://${target}`;
+  return { url, headers, version };
+}
+async function resolveProxyConfig(platform2, target, connectHeaders, hiddenValues, version) {
+  const config = await MergedConfigSource.load(platform2);
+  const entry = await config.get(target);
+  if (!entry) return `unknown target '${target}'`;
+  if ("url" in entry && entry.url) {
+    const merged = { ...entry.headers, ...connectHeaders };
+    if (entry.headers) {
+      for (const v of Object.values(entry.headers)) hiddenValues.add(v);
+    }
+    return { url: entry.url, headers: merged, version };
+  }
+  if ("command" in entry && entry.command) {
+    return {
+      command: entry.command,
+      args: entry.args,
+      env: entry.env,
+      cwd: entry.cwd,
+      version
+    };
+  }
+  return `target '${target}' has no url or command`;
+}
+async function buildProxyConnectOpts(platform2, options, version) {
+  const target = options.proxy;
+  const connectHeaders = {};
+  const hiddenValues = /* @__PURE__ */ new Set();
+  for (const [k, v] of options.proxyHeaders) {
+    const expanded = expandPlaceholdersStrict(v, platform2.env);
+    if (expanded === void 0) return { error: `unset variable in header '${k}'` };
+    const key = k.toLowerCase() === "authorization" ? "Authorization" : k;
+    connectHeaders[key] = expanded;
+    hiddenValues.add(expanded);
+  }
+  const isUrl = target.startsWith("http://") || target.startsWith("https://") || target.includes(".");
+  let connectOpts;
+  if (options.proxyCommand && options.proxyCommand.length > 0) {
+    connectOpts = {
+      command: options.proxyCommand[0],
+      args: options.proxyCommand.slice(1),
+      version
+    };
+  } else if (target.startsWith("stdio:")) {
+    connectOpts = resolveProxyStdio(target, version);
+  } else if (isUrl) {
+    connectOpts = resolveProxyUrl(target, connectHeaders, version);
+  } else {
+    const result = await resolveProxyConfig(
+      platform2,
+      target,
+      connectHeaders,
+      hiddenValues,
+      version
+    );
+    if (typeof result === "string") return { error: result };
+    connectOpts = result;
+  }
+  if (connectOpts.headers) {
+    for (const v of Object.values(connectOpts.headers)) {
+      if (v) hiddenValues.add(v);
+    }
+  }
+  return { connectOpts, hiddenValues };
+}
+async function runProxyServe(platform2, options, version, resolvedBearer) {
+  const built = await buildProxyConnectOpts(platform2, options, version);
+  if ("error" in built) {
+    await platform2.write(2, `mcpcat serve --proxy: ${built.error}
+`);
+    return 2;
+  }
+  const { connectOpts, hiddenValues } = built;
+  if (resolvedBearer) hiddenValues.add(resolvedBearer);
+  const proxy = createProxyHandler({
+    target: options.proxy,
+    connectOpts,
+    platform: platform2,
+    hiddenHeaders: hiddenValues
+  });
+  if (options.transport === "stdio") {
+    return runProxyStdio(platform2, proxy);
+  }
+  return runProxyHttp(platform2, options, proxy, resolvedBearer);
+}
+async function runProxyStdio(platform2, proxy) {
+  const reader = platform2.stdin.getReader();
+  let buffer = "";
+  const dec = new TextDecoder();
+  const enc = new TextEncoder();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += dec.decode(value, { stream: true });
+      let nlIdx;
+      while ((nlIdx = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, nlIdx).trim();
+        buffer = buffer.slice(nlIdx + 1);
+        if (!line) continue;
+        const outcome = await proxy.handle(line);
+        if (outcome.status === 202) continue;
+        const writer = platform2.stdout.getWriter();
+        await writer.write(enc.encode(`${outcome.body}
+`));
+        writer.releaseLock();
+      }
+    }
+  } finally {
+    reader.releaseLock();
+    await proxy.shutdown();
+  }
+  return 0;
+}
+async function runProxyHttp(platform2, options, proxy, resolvedBearer) {
+  if (!platform2.listen) {
+    await platform2.write(2, "mcpcat serve --proxy: HTTP transport requires platform.listen\n");
+    return 3;
+  }
+  const boundLoopback = options.host === "127.0.0.1" || options.host === "localhost" || options.host === "::1";
+  if (!boundLoopback && !resolvedBearer) {
+    await platform2.write(
+      2,
+      "mcpcat serve --proxy: --bearer is required when binding off loopback\n"
+    );
+    return 2;
+  }
+  const allowedOrigins = new Set(options.allowOrigins);
+  const listener = await platform2.listen({
+    host: options.host,
+    port: options.port
+  });
+  const actualPort = listener.port;
+  const listenUrl = `http://${options.host}:${actualPort}/mcp`;
+  if (options.json) {
+    await platform2.write(1, `${JSON.stringify({ url: listenUrl })}
+`);
+  }
+  await platform2.write(2, `mcpcat serve --proxy: listening on ${listenUrl}
+`);
+  if (options.onListening) {
+    await options.onListening(actualPort);
+  }
+  let shutdownRequested = false;
+  const shutdown = () => {
+    if (shutdownRequested) return;
+    shutdownRequested = true;
+    listener.close();
+    void proxy.shutdown();
+  };
+  if (platform2.onSignal) {
+    platform2.onSignal("SIGINT", shutdown);
+    platform2.onSignal("SIGTERM", shutdown);
+  }
+  const handler = (request) => handleProxyMcpRequest(request, proxy, allowedOrigins, boundLoopback, resolvedBearer);
+  try {
+    for await (const connection of listener) {
+      if (shutdownRequested) break;
+      const conn = connection;
+      handleConnection(conn.readable, conn.writable, handler).catch(() => {
+      }).finally(() => {
+        try {
+          conn.close();
+        } catch {
+        }
+      });
+    }
+  } catch {
+    if (!shutdownRequested) throw new Error("listener closed unexpectedly");
+  }
+  return 0;
+}
+async function handleProxyMcpRequest(request, proxy, allowedOrigins, boundLoopback, resolvedBearer) {
+  if (resolvedBearer) {
+    const authHeader = request.headers.authorization;
+    const provided = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : "";
+    if (!provided || !constantTimeEqual(provided, resolvedBearer)) {
+      return {
+        status: 401,
+        reason: "Unauthorized",
+        headers: { "content-type": "text/plain" },
+        body: "Unauthorized"
+      };
+    }
+  }
+  const originCheck = checkOrigin(request.headers.origin, allowedOrigins, boundLoopback);
+  if (!originCheck.ok) {
+    return {
+      status: 403,
+      reason: "Forbidden",
+      headers: { "content-type": "text/plain" },
+      body: originCheck.reason ?? "Forbidden"
+    };
+  }
+  const hostCheck = checkHost(request.headers.host, boundLoopback);
+  if (!hostCheck.ok) {
+    return {
+      status: 403,
+      reason: "Forbidden",
+      headers: { "content-type": "text/plain" },
+      body: hostCheck.reason ?? "Forbidden"
+    };
+  }
+  if (request.target !== "/mcp") {
+    return {
+      status: 404,
+      reason: "Not Found",
+      headers: { "content-type": "text/plain" },
+      body: "Not Found"
+    };
+  }
+  if (request.method !== "POST") {
+    return {
+      status: 405,
+      reason: "Method Not Allowed",
+      headers: { "content-type": "text/plain", allow: "POST" },
+      body: "Method Not Allowed"
+    };
+  }
+  const outcome = await proxy.handle(request.body);
+  return {
+    status: outcome.status,
+    reason: outcome.status === 200 ? "OK" : "Accepted",
+    headers: { "content-type": outcome.contentType },
+    body: outcome.body
+  };
+}
 async function runStdioServer(platform2, tools, call, serverName, version) {
   const reader = platform2.stdin.getReader();
   let buffer = "";
@@ -10078,6 +10550,14 @@ function parseAddFlagAt(flagArgs, i, flags) {
     flags.noProbe = true;
     return { next: i + 1 };
   }
+  if (arg === "--bridge") {
+    flags.bridge = true;
+    return { next: i + 1 };
+  }
+  if (arg === "--bearer" && i + 1 < flagArgs.length) {
+    flags.bearer = flagArgs[i + 1];
+    return { next: i + 2 };
+  }
   if (arg === "--config" && i + 1 < flagArgs.length) {
     flags.configFile = flagArgs[i + 1];
     return { next: i + 2 };
@@ -10114,6 +10594,7 @@ function parseAddFlags(args) {
   const flags = {
     local: false,
     noProbe: false,
+    bridge: false,
     headers: [],
     envPairs: [],
     positional: [],
@@ -10476,6 +10957,54 @@ async function runImport(platform2, args) {
   }
   return 0;
 }
+async function runBridge(platform2, args, version) {
+  if (platform2.kind === "host") {
+    await platform2.write(
+      2,
+      "mcpcat add --bridge: not available on the host.\nOn the host, add stdio entries directly with: mcpcat add <name> -- <cmd>\nTo expose a stdio server over HTTP: mcpcat serve --proxy <target> --http <port>\n"
+    );
+    return 2;
+  }
+  const flags = parseAddFlags(args);
+  if (typeof flags === "string") {
+    await platform2.write(2, `mcpcat add --bridge: ${flags}
+`);
+    return 2;
+  }
+  const name = flags.positional[0];
+  if (!name) {
+    await platform2.write(2, "mcpcat add --bridge: requires a server name\n");
+    return 2;
+  }
+  if (flags.cmdArgs.length === 0) {
+    await platform2.write(2, "mcpcat add --bridge: requires -- <command> [args...]\n");
+    return 2;
+  }
+  if (flags.bearer) {
+    await platform2.write(
+      2,
+      "mcpcat add --bridge: --bearer is not needed on the kernel loopback.\nThe kernel loopback is only reachable from inside the kernel and the agent.\n"
+    );
+    return 2;
+  }
+  const serveOptions = parseServeFlags(["--proxy", "__bridge__", "--http", "0", "--json"]);
+  serveOptions.proxyCommand = flags.cmdArgs;
+  const path = flags.configFile ?? (flags.local ? projectConfigPath(platform2) : userConfigPath(platform2));
+  serveOptions.onListening = async (actualPort) => {
+    const bridgeUrl = `http://${actualPort}.kernel.localhost/mcp`;
+    const httpConfig = { url: bridgeUrl };
+    if (flags.description) httpConfig.description = flags.description;
+    if (flags.exposure) httpConfig.exposure = flags.exposure;
+    const { replaced } = await addServer(platform2.fs, path, name, httpConfig);
+    await platform2.write(
+      1,
+      `${replaced ? "replaced" : "added"} ${name} in ${path}
+bridge does not survive a reload; runs in the foreground (start with &)
+`
+    );
+  };
+  return runServe(platform2, serveOptions, version);
+}
 
 // src/cli/main.ts
 var VERBS = [
@@ -10540,6 +11069,9 @@ Client verbs:
 
 Configuration verbs:
   add <name> <url>           Add a server to mcp.json
+  add <name> --bridge -- 
+    Bridge a stdio server to HTTP (kernel only,
+                             runs in foreground, does not survive reload)
   rm <name>                  Remove a server
   list                       List configured servers
   enable|disable <name>      Toggle a server
@@ -10549,7 +11081,7 @@ Configuration verbs:
   logout <target>            Remove tokens (not implemented yet)
 
 Server and code verbs:
-  serve [--stdio|--http] \u2026   Expose commands as MCP server
+  serve [--stdio|--http] \u2026   Expose commands or proxy upstream as MCP server
   code [-e src|file.js]      Run a codemode script
   grep <pattern> [target\u2026]   Search tools by name or description
   discover <url>             Find MCP servers at a URL
@@ -10902,10 +11434,11 @@ async function probeServer(_name, config, platform2) {
     return err.message;
   }
 }
-async function dispatchConfigVerb(platform2, verb, args) {
+async function dispatchConfigVerb(platform2, verb, args, version) {
   const rest = args.slice(1);
   switch (verb) {
     case "add":
+      if (rest.includes("--bridge")) return runBridge(platform2, rest, version);
       return runAdd(platform2, rest, probeServer);
     case "rm":
       return runRm(platform2, rest);
@@ -10948,7 +11481,7 @@ async function dispatchDiscoveryVerb(platform2, parsed, args) {
 async function dispatchServeVerb(platform2, args, version) {
   const serveArgs = args.slice(args.indexOf("serve") + 1);
   const serveOptions = parseServeFlags(serveArgs);
-  if (serveOptions.commands.length === 0 && serveOptions.toolTemplates.length === 0) {
+  if (!serveOptions.proxy && serveOptions.commands.length === 0 && serveOptions.toolTemplates.length === 0) {
     await platform2.write(2, "mcpcat serve: no commands or --tool templates given\n");
     return 2;
   }
@@ -11112,7 +11645,7 @@ async function run(platform2, version, args) {
   if (parsed.verb in CONFIG_VERBS) {
     const disc = await dispatchDiscoveryVerb(platform2, parsed, args);
     if (disc !== void 0) return disc;
-    return dispatchConfigVerb(platform2, parsed.verb, args);
+    return dispatchConfigVerb(platform2, parsed.verb, args, version);
   }
   const discResult = await dispatchDiscoveryVerb(platform2, parsed, args);
   if (discResult !== void 0) return discResult;
@@ -11272,6 +11805,7 @@ async function kernelListen(ctx, options) {
 function createKernelPlatform(ctx, options) {
   const encoder2 = new TextEncoder();
   return {
+    kind: "kernel",
     fetch: ctx.fetch,
     spawn: (options2) => kernelSpawn(ctx, options2),
     listen: (options2) => kernelListen(ctx, options2),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/mcpcat",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "A curl for the Model Context Protocol",
   "type": "module",
   "license": "Apache-2.0",