@ai-ecoverse/mcpcat 0.15.5 → 0.15.7

package/dist/host/mcpcat.mjs

@@ -1854,6 +1854,16 @@ var init_version = __esm({
 });
 
 // node_modules/quickjs-wasi/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  CompileFlags: () => CompileFlags,
+  EvalFlags: () => EvalFlags,
+  Intrinsics: () => Intrinsics,
+  JSException: () => JSException,
+  JSValueHandle: () => JSValueHandle,
+  MAX_STACK_SIZE: () => MAX_STACK_SIZE,
+  QuickJS: () => QuickJS
+});
 function stringKeyNeedsValuePath(key) {
   return key.includes("\0") || LONE_SURROGATE_RE.test(key);
 }
@@ -5329,8 +5339,8 @@ function parseCodemodeSource(input) {
     throw new CodemodeSourceError(`The ${CODEMODE_OPTIONS_PREFIX} line must be the first line of the input; found one on line ${misplaced + 1}`);
   }
   const newline = input.indexOf("\n");
-  const firstLine = lines[0].replace(/\r$/, "");
-  const trimmed = firstLine.trimStart();
+  const firstLine2 = lines[0].replace(/\r$/, "");
+  const trimmed = firstLine2.trimStart();
   if (!trimmed.startsWith(CODEMODE_OPTIONS_PREFIX))
     return { code: input, options: {} };
   const code2 = newline === -1 ? "" : input.slice(newline);
@@ -5365,8 +5375,8 @@ SOURCE: /[\s\S]+/
 });
 
 // node_modules/@earendil-works/pi-codemode/dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
+var dist_exports2 = {};
+__export(dist_exports2, {
   CODEMODE_OPTIONS_PREFIX: () => CODEMODE_OPTIONS_PREFIX,
   CODEMODE_SOURCE_GRAMMAR: () => CODEMODE_SOURCE_GRAMMAR,
   CodemodeSandbox: () => CodemodeSandbox,
@@ -8369,8 +8379,9 @@ var McpTimeoutError2 = class extends Error {
 var McpAuthError = class extends Error {
   status;
   target;
-  constructor(status, target) {
-    super(`HTTP ${status}: authentication required. Run: mcpcat login ${target}`);
+  constructor(status, target, reason) {
+    const why = reason ? ` (${reason})` : "";
+    super(`HTTP ${status}: authentication required${why}. Run: mcpcat login ${target}`);
     this.name = "McpAuthError";
     this.status = status;
     this.target = target;
@@ -8388,12 +8399,23 @@ var TransportRefusalError = class extends Error {
 };
 var AuthRetryableError = class extends Error {
   response;
-  constructor(response) {
+  reason;
+  constructor(response, reason) {
     super(`HTTP ${response.status}: auth retry`);
     this.name = "AuthRetryableError";
     this.response = response;
+    this.reason = reason;
   }
 };
+var KERNEL_REFUSAL = "nodeTransport refuses ";
+function firstLine(text) {
+  return text.trim().split("\n")[0].trim().slice(0, 200);
+}
+async function authReason(res) {
+  const type = res.headers.get("content-type") ?? "";
+  if (!type.toLowerCase().startsWith("text/plain")) return void 0;
+  return firstLine(await res.text()) || void 0;
+}
 function selectSseFrame(body, targetId) {
   const text = new TextDecoder().decode(body);
   const blocks = text.replace(/\r\n/g, "\n").split(/\n\n/);
@@ -8510,7 +8532,8 @@ async function createStatelessConnection(options) {
     clientInfo = { name: "mcpcat", version: "0.0.0" },
     signal: externalSignal,
     verbose,
-    authProvider
+    authProvider,
+    transportRefusals
   } = options;
   let nextId2 = 1;
   let negotiatedVersion;
@@ -8528,18 +8551,14 @@ async function createStatelessConnection(options) {
     return h;
   }
   async function handleErrorStatus(res, method) {
-    if (res.status === 403) {
-      const wwwAuth = res.headers.get("www-authenticate") ?? "";
-      if (!wwwAuth) {
-        const body = await res.text();
-        if (body && !body.includes("insufficient_scope")) {
-          throw new TransportRefusalError(403, body.split("\n")[0].slice(0, 200));
-        }
+    if (res.status === 401 || res.status === 403) {
+      const reason = await authReason(res);
+      if (transportRefusals && res.status === 403 && !res.headers.has("www-authenticate") && reason?.startsWith(KERNEL_REFUSAL)) {
+        throw new TransportRefusalError(403, reason);
       }
+      if (authProvider) throw new AuthRetryableError(res, reason);
+      throw new McpAuthError(res.status, url, reason);
     }
-    if ((res.status === 401 || res.status === 403) && authProvider)
-      throw new AuthRetryableError(res);
-    if (res.status === 401 || res.status === 403) throw new McpAuthError(res.status, url);
     const text = await res.text();
     let rpc;
     try {
@@ -8594,7 +8613,7 @@ async function createStatelessConnection(options) {
     return frame.result;
   }
   async function handleAuthError(err, token) {
-    if (!authProvider?.onUnauthorized) throw new McpAuthError(err.response.status, url);
+    if (!authProvider?.onUnauthorized) throw new McpAuthError(err.response.status, url, err.reason);
     try {
       await authProvider.onUnauthorized({
         response: err.response,
@@ -8604,7 +8623,7 @@ async function createStatelessConnection(options) {
       });
     } catch (authErr) {
       if (authErr instanceof AuthStepUpError || authErr instanceof JerkTimeoutError) throw authErr;
-      throw new McpAuthError(err.response.status, url);
+      throw new McpAuthError(err.response.status, url, err.reason);
     }
   }
   async function request(method, params) {
@@ -9065,7 +9084,8 @@ async function connect(platform2, options) {
       timeoutMs: options.timeoutMs,
       signal: options.signal,
       verbose: options.verbose,
-      authProvider: options.authProvider
+      authProvider: options.authProvider,
+      transportRefusals: platform2.kind === "kernel"
     });
   } catch (err) {
     const isMethodNotFound = err instanceof StatelessRpcError && err.code === -32601 || err instanceof StatelessHttpError && err.status >= 400 && err.status < 500;
@@ -9357,7 +9377,7 @@ function toolDeclaration(tool) {
   };
 }
 async function runDescribeTs(platform2, targets, budget) {
-  const { renderDeclarations: renderDeclarations2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+  const { renderDeclarations: renderDeclarations2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports2));
   const allTools = [];
   for (const target of targets) {
     const tools = await target.conn.listTools();
@@ -9428,6 +9448,39 @@ async function runGrep(platform2, pattern, targets, options) {
 // src/codemode/run.ts
 init_dist2();
 init_source();
+
+// src/codemode/deadline.ts
+var expiries = /* @__PURE__ */ new WeakMap();
+var hooked = /* @__PURE__ */ new WeakSet();
+function hookDeadlines(quickjs) {
+  if (hooked.has(quickjs)) return;
+  hooked.add(quickjs);
+  const create = quickjs.create.bind(quickjs);
+  quickjs.create = (options) => {
+    const expired = options.wasm ? expiries.get(options.wasm) : void 0;
+    const inner = options.interruptHandler;
+    if (!expired || !inner) return create(options);
+    return create({ ...options, interruptHandler: () => expired() || inner() });
+  };
+}
+function bindDeadline(wasm, timeoutMs, now = Date.now) {
+  let endsAt = Number.POSITIVE_INFINITY;
+  let tripped = false;
+  expiries.set(wasm, () => {
+    if (!tripped && now() >= endsAt) tripped = true;
+    return tripped;
+  });
+  return {
+    start() {
+      endsAt = now() + timeoutMs;
+    },
+    get tripped() {
+      return tripped;
+    }
+  };
+}
+
+// src/codemode/run.ts
 async function loadStore(platform2, stateDir2) {
   const storePath = `${stateDir2}/codemode-store.json`;
   try {
@@ -9613,9 +9666,23 @@ async function runCode(targets, source, options) {
     ...buildDiscoveryGlobals(allDeclaredTools, namespaces, searchDocs),
     ...options.allowShell ? [buildShellGlobal(platform2)] : []
   ];
-  const sandbox = await createSandbox(platform2, toolImpls, globals, timeoutMs, memoryLimitBytes);
+  const { sandbox, deadline } = await createSandbox(
+    platform2,
+    toolImpls,
+    globals,
+    timeoutMs,
+    memoryLimitBytes
+  );
   try {
-    const result = await sandbox.execute(code2, { store });
+    deadline?.start();
+    const executed = await sandbox.execute(code2, { store });
+    const result = deadline?.tripped && !executed.ok ? {
+      ...executed,
+      error: {
+        kind: "timeout",
+        message: `Execution timed out after ${timeoutMs} ms`
+      }
+    } : executed;
     if (result.ok) {
       const writes = result.storeWrites;
       if (Object.keys(writes.set).length > 0 || writes.delete.length > 0) {
@@ -9661,12 +9728,23 @@ async function createSandbox(platform2, tools, globals, timeoutMs, memoryLimitBy
   const isKernel2 = platform2.packageDir !== void 0;
   if (isKernel2) {
     const { InlineCodemodeSandbox: InlineCodemodeSandbox2 } = await Promise.resolve().then(() => (init_portable(), portable_exports));
+    const { QuickJS: QuickJS2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+    hookDeadlines(QuickJS2);
     const wasm = await loadWasmKernel(platform2);
-    return new InlineCodemodeSandbox2({ tools, globals, timeoutMs, wasm, memoryLimitBytes });
+    const deadline = bindDeadline(wasm, timeoutMs);
+    const sandbox2 = new InlineCodemodeSandbox2({
+      tools,
+      globals,
+      timeoutMs,
+      wasm,
+      memoryLimitBytes,
+      interruptBudget: Number.POSITIVE_INFINITY
+    });
+    return { sandbox: sandbox2, deadline };
   }
-  const { CodemodeSandbox: CodemodeSandbox2, loadQuickJSWasm: loadQuickJSWasm2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+  const { CodemodeSandbox: CodemodeSandbox2, loadQuickJSWasm: loadQuickJSWasm2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports2));
   const wasmPath = await resolveWasmPath(platform2);
-  return new CodemodeSandbox2({
+  const sandbox = new CodemodeSandbox2({
     tools,
     globals,
     timeoutMs,
@@ -9674,6 +9752,7 @@ async function createSandbox(platform2, tools, globals, timeoutMs, memoryLimitBy
     wasm: loadQuickJSWasm2(wasmPath),
     workerUrl: new URL("./codemode-worker.mjs", import.meta.url)
   });
+  return { sandbox };
 }
 async function resolveWasmPath(platform2) {
   const candidates = [
@@ -12183,16 +12262,45 @@ function wrapUntrusted(content) {
 ${neutralised}
 ${closeTag}`;
 }
-async function runProcess(platform2, argv, stdin, timeoutMs) {
+var WEBMCP_LIST_FLOOR = 1048576;
+function capCollector(limit) {
+  const dec = new TextDecoder();
+  const half = Math.floor(limit / 2);
+  let head = "";
+  let tail = "";
+  let total = 0;
+  const take = (piece) => {
+    if (!piece) return;
+    total += piece.length;
+    if (head.length < limit) head += piece.slice(0, limit - head.length);
+    tail = half > 0 ? (tail + piece).slice(-half) : "";
+  };
+  return {
+    push(chunk) {
+      take(dec.decode(chunk, { stream: true }));
+    },
+    finish() {
+      take(dec.decode());
+      if (total <= limit) return { text: head, cut: false };
+      return {
+        text: `${head.slice(0, half)}
+\u2026 ${total - limit} characters cut \u2026
+${tail}`,
+        cut: true
+      };
+    }
+  };
+}
+async function runProcess(platform2, argv, stdin, timeoutMs, limit) {
   let proc;
   try {
     proc = await platform2.spawn({ argv });
-  } catch (err) {
-    const code2 = err.code;
+  } catch (err2) {
+    const code2 = err2.code;
     if (code2 === "ENOENT" || code2 === "EACCES") {
-      return { stdout: "", stderr: `command not found: ${argv[0]}`, exitCode: -1 };
+      return { stdout: "", stderr: `command not found: ${argv[0]}`, exitCode: -1, cut: false };
     }
-    throw err;
+    throw err2;
   }
   if (stdin !== void 0) {
     const writer = proc.stdin.getWriter();
@@ -12204,8 +12312,8 @@ async function runProcess(platform2, argv, stdin, timeoutMs) {
     } catch {
     }
   }
-  const stdoutChunks = [];
-  const stderrChunks = [];
+  const out = capCollector(limit);
+  const err = capCollector(limit);
   const readStream3 = async (stream, into) => {
     const r = stream.getReader();
     try {
@@ -12218,53 +12326,136 @@ async function runProcess(platform2, argv, stdin, timeoutMs) {
       r.releaseLock();
     }
   };
-  const timer = new Promise(
-    (resolve) => setTimeout(() => resolve("timeout"), timeoutMs ?? 3e4)
-  );
+  let timeoutId;
+  const timer = new Promise((resolve) => {
+    timeoutId = setTimeout(() => resolve("timeout"), timeoutMs);
+  });
   const work = Promise.all([
-    readStream3(proc.stdout, stdoutChunks),
-    readStream3(proc.stderr, stderrChunks),
+    readStream3(proc.stdout, out),
+    readStream3(proc.stderr, err),
     proc.wait()
   ]);
   const result = await Promise.race([work, timer]);
+  clearTimeout(timeoutId);
   if (result === "timeout") {
     await proc.kill("SIGTERM");
-    return { stdout: "", stderr: "timed out", exitCode: 124 };
+    return { stdout: "", stderr: "timed out", exitCode: 124, cut: false };
   }
   const [, , exitResult] = result;
-  const dec = new TextDecoder();
-  const concat2 = (chunks) => {
-    const total = chunks.reduce((s, c) => s + c.length, 0);
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const c of chunks) {
-      out.set(c, offset);
-      offset += c.length;
-    }
-    return out;
+  const stdout = out.finish();
+  const stderr = err.finish();
+  return {
+    stdout: stdout.text,
+    stderr: stderr.text,
+    exitCode: exitResult.status,
+    cut: stdout.cut
   };
+}
+async function resolveWebMcpTab(platform2, options) {
+  const argv = [options.playwrightCli, "tab-list"];
+  if (options.cdp) argv.push("--cdp", options.cdp);
+  const result = await runProcess(
+    platform2,
+    argv,
+    void 0,
+    options.callTimeoutMs,
+    WEBMCP_LIST_FLOOR
+  );
+  if (result.exitCode === -1) return { error: result.stderr, notFound: true };
+  if (result.exitCode !== 0) {
+    return { error: result.stderr.trim() || `tab-list exited ${result.exitCode}` };
+  }
+  const rows = [];
+  for (const line of result.stdout.split("\n")) {
+    const match = /^(\d+): \[([^\]\s]+)\] /.exec(line);
+    if (!match) continue;
+    if (Number(match[1]) !== rows.length + 1) {
+      return { error: "could not read playwright-cli tab-list" };
+    }
+    rows.push({ id: match[2], active: line.endsWith('" (active)') });
+  }
+  const active = rows.filter((r) => r.active);
+  if (new Set(rows.map((r) => r.id)).size !== rows.length || active.length > 1) {
+    return { error: "could not read playwright-cli tab-list" };
+  }
+  if (active.length === 1) return { tab: active[0].id };
+  if (rows.length === 1) return { tab: rows[0].id };
   return {
-    stdout: dec.decode(concat2(stdoutChunks)),
-    stderr: dec.decode(concat2(stderrChunks)),
-    exitCode: exitResult.status
+    error: rows.length === 0 ? "no browser tab is open; open one or pass --tab <targetId>" : "no current playwright-cli tab; pass --tab <targetId> (see playwright-cli tab-list)"
   };
 }
+function mapDescriptionAnnotations(ann) {
+  const mapped = { openWorldHint: true };
+  if (!ann) return mapped;
+  if (ann.readOnlyHint !== void 0) mapped.readOnlyHint = ann.readOnlyHint;
+  if (ann.consequentialHint) mapped.destructiveHint = true;
+  return mapped;
+}
+function originPrefix(tools) {
+  const origins = new Set(tools.map((t) => t.origin));
+  return origins.size > 1;
+}
+function hostFromOrigin(origin) {
+  try {
+    return new URL(origin).host;
+  } catch {
+    return origin;
+  }
+}
+function buildDescription(tool) {
+  const parts = [];
+  if (tool.description) parts.push(tool.description);
+  parts.push(`[origin: ${tool.origin}]`);
+  return parts.join("\n");
+}
+function buildToolName(tool, prefix) {
+  const base = tool.name;
+  if (!prefix) return base;
+  const host = hostFromOrigin(tool.origin).replace(/[^a-zA-Z0-9_]/g, "_");
+  return `${host}__${base}`;
+}
+function exposedTools(tools) {
+  const needPrefix = originPrefix(tools);
+  const byBase = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const name = buildToolName(tool, needPrefix);
+    byBase.set(tool.name, [...byBase.get(tool.name) ?? [], tool]);
+    byName.set(name, [...byName.get(name) ?? [], tool]);
+  }
+  return tools.map((tool) => {
+    const name = buildToolName(tool, needPrefix);
+    const sameBase = byBase.get(tool.name);
+    const sameName = byName.get(name);
+    return { name, tool, peers: sameBase.length > 1 ? sameBase : sameName };
+  });
+}
+function ambiguityError(name, peers) {
+  const origins = [...new Set(peers.map((t) => String(t.origin)))].join(", ");
+  return new Error(
+    `tool "${name}" is ambiguous: ${peers.length} tools on the page match it (${origins}), and playwright-cli runs the first tool by name and cannot select one by origin, so mcpcat refuses the call`
+  );
+}
 function createWebMcpHandler(platform2, options) {
   let cache;
   const baseArgs = buildBaseArgs(options);
-  async function listRaw() {
+  const listLimit = Math.max(options.maxOutput, WEBMCP_LIST_FLOOR);
+  async function listRaw(fresh = false) {
     const now = Date.now();
-    if (cache && now < cache.expiresAt) {
+    if (!fresh && cache && now < cache.expiresAt) {
       return { tools: cache.tools };
     }
     const argv = [options.playwrightCli, "webmcp-list", "--json", ...baseArgs];
-    const result = await runProcess(platform2, argv, void 0, options.callTimeoutMs);
+    const result = await runProcess(platform2, argv, void 0, options.callTimeoutMs, listLimit);
     if (result.exitCode === -1) {
       return { tools: [], error: result.stderr, notFound: true };
     }
     if (result.exitCode !== 0) {
       return { tools: [], error: result.stderr || `webmcp-list exited ${result.exitCode}` };
     }
+    if (result.cut) {
+      return { tools: [], error: `webmcp-list output exceeds ${listLimit} characters` };
+    }
     let parsed;
     try {
       parsed = JSON.parse(result.stdout);
@@ -12278,49 +12469,19 @@ function createWebMcpHandler(platform2, options) {
     cache = { tools, expiresAt: now + options.ttlMs };
     return { tools };
   }
-  function mapDescriptionAnnotations(ann) {
-    const mapped = { openWorldHint: true };
-    if (!ann) return mapped;
-    if (ann.readOnlyHint !== void 0) mapped.readOnlyHint = ann.readOnlyHint;
-    if (ann.consequentialHint) mapped.destructiveHint = true;
-    return mapped;
-  }
-  function originPrefix(tools) {
-    const origins = new Set(tools.map((t) => t.origin));
-    return origins.size > 1;
-  }
-  function hostFromOrigin(origin) {
-    try {
-      return new URL(origin).host;
-    } catch {
-      return origin;
-    }
-  }
-  function buildDescription(tool) {
-    const parts = [];
-    if (tool.description) parts.push(tool.description);
-    parts.push(`[origin: ${tool.origin}]`);
-    return parts.join("\n");
-  }
-  function buildToolName(tool, prefix) {
-    const base = tool.name;
-    if (!prefix) return base;
-    const host = hostFromOrigin(tool.origin).replace(/[^a-zA-Z0-9_]/g, "_");
-    return `${host}__${base}`;
-  }
   async function getRpcTools() {
     const { tools, error, notFound } = await listRaw();
     if (notFound) return null;
     if (error) return [];
-    const needPrefix = originPrefix(tools);
     const rpcTools = [];
-    for (const tool of tools) {
+    for (const { name, tool, peers } of exposedTools(tools)) {
+      if (peers.length > 1) continue;
       if (tool.annotations?.consequentialHint && !options.allowConsequential) {
         continue;
       }
       const mapped = mapDescriptionAnnotations(tool.annotations);
       rpcTools.push({
-        name: buildToolName(tool, needPrefix),
+        name,
         description: buildDescription(tool),
         inputSchema: tool.inputSchema,
         annotations: mapped
@@ -12329,21 +12490,30 @@ function createWebMcpHandler(platform2, options) {
     return rpcTools;
   }
   async function callTool(name, args2) {
-    const { tools, error } = await listRaw();
+    const { tools, error } = await listRaw(true);
     if (error) {
       return { stdout: "", stderr: error, exitCode: 2 };
     }
-    const needPrefix = originPrefix(tools);
-    const tool = tools.find((t) => buildToolName(t, needPrefix) === name);
-    if (!tool) {
+    const match = exposedTools(tools).find((t) => t.name === name);
+    if (!match) {
       return { stdout: "", stderr: `unknown tool: ${name}`, exitCode: 2 };
     }
+    if (match.peers.length > 1) {
+      throw ambiguityError(name, match.peers);
+    }
+    const { tool } = match;
     const argv = [options.playwrightCli, "webmcp-call", tool.name, "-", ...baseArgs];
     if (options.allowConsequential) {
       argv.push("--allow-consequential");
     }
     const stdinData = JSON.stringify(args2 ?? {});
-    const result = await runProcess(platform2, argv, stdinData, options.callTimeoutMs);
+    const result = await runProcess(
+      platform2,
+      argv,
+      stdinData,
+      options.callTimeoutMs,
+      options.maxOutput
+    );
     if (result.exitCode === -1) {
       throw new Error(result.stderr || "playwright-cli not found");
     }
@@ -12869,6 +13039,7 @@ async function discoverWithSignal(platform2, commands, childEnv, cwd) {
   };
   platform2.onSignal?.("SIGTERM", onShutdown);
   platform2.onSignal?.("SIGINT", onShutdown);
+  platform2.onSignal?.("SIGHUP", onShutdown);
   for (const cmd of commands) {
     try {
       const cli = await discoverCli(platform2, cmd.path, cmd.name, childEnv, cwd, earlyAbort.signal);
@@ -13094,9 +13265,30 @@ async function runWebMcpServe(platform2, options, version, resolvedBearer, gener
     return 3;
   }
   const cdp = options.webmcpCdp ?? platform2.env.SLICC_CDP_URL;
+  let tab = options.webmcpTab;
+  if (!tab) {
+    const resolved = await resolveWebMcpTab(platform2, {
+      playwrightCli: cliPath,
+      cdp,
+      callTimeoutMs: options.callTimeout
+    });
+    if (resolved.notFound) {
+      await platform2.write(
+        2,
+        "mcpcat serve --webmcp: playwright-cli not found. Install it with: curl -fsSL https://get.sliccy.ai/playwright-cli | sh\n"
+      );
+      return 3;
+    }
+    if (!resolved.tab) {
+      await platform2.write(2, `mcpcat serve --webmcp: ${resolved.error}
+`);
+      return 3;
+    }
+    tab = resolved.tab;
+  }
   const handler = createWebMcpHandler(platform2, {
     playwrightCli: cliPath,
-    tab: options.webmcpTab,
+    tab,
     cdp,
     allowConsequential: options.webmcpAllowConsequential,
     ttlMs: options.webmcpTtl,
@@ -13178,6 +13370,21 @@ async function runWebMcpHttp(platform2, options, getTools, callTool, serverName,
   const address = serveAddress(platform2, options.host, actualPort);
   const listenUrl = address.url;
   let tokenFilePath;
+  let shutdownRequested = false;
+  const shutdown = () => {
+    if (shutdownRequested) return;
+    shutdownRequested = true;
+    listener.close();
+    if (tokenFilePath) {
+      platform2.fs.unlink?.(tokenFilePath).catch(() => {
+      });
+    }
+  };
+  if (platform2.onSignal) {
+    platform2.onSignal("SIGINT", shutdown);
+    platform2.onSignal("SIGTERM", shutdown);
+    platform2.onSignal("SIGHUP", shutdown);
+  }
   if (generatedBearer && resolvedBearer) {
     tokenFilePath = await publishBearer(
       platform2,
@@ -13186,31 +13393,22 @@ async function runWebMcpHttp(platform2, options, getTools, callTool, serverName,
       address,
       options.json
     );
+    if (shutdownRequested && tokenFilePath) {
+      await platform2.fs.unlink?.(tokenFilePath).catch(() => {
+      });
+    }
   } else {
     if (options.json) {
       await platform2.write(1, `${JSON.stringify(address)}
 `);
     }
   }
-  await platform2.write(2, `mcpcat serve --webmcp: listening on ${listenUrl}
+  if (!shutdownRequested) {
+    await platform2.write(2, `mcpcat serve --webmcp: listening on ${listenUrl}
 `);
-  if (options.onListening) {
-    await options.onListening(actualPort);
-  }
-  let shutdownRequested = false;
-  const shutdown = () => {
-    if (shutdownRequested) return;
-    shutdownRequested = true;
-    listener.close();
-    if (tokenFilePath) {
-      platform2.fs.unlink?.(tokenFilePath).catch(() => {
-      });
+    if (options.onListening) {
+      await options.onListening(actualPort);
     }
-  };
-  if (platform2.onSignal) {
-    platform2.onSignal("SIGINT", shutdown);
-    platform2.onSignal("SIGTERM", shutdown);
-    platform2.onSignal("SIGHUP", shutdown);
   }
   const handler = async (request) => {
     if (request.target !== "/mcp") {
@@ -13374,6 +13572,23 @@ async function runProxyHttp(platform2, options, proxy, resolvedBearer, generated
   const address = serveAddress(platform2, options.host, actualPort);
   const listenUrl = address.url;
   let tokenFilePath;
+  let shutdownRequested = false;
+  let proxyDone;
+  const shutdown = () => {
+    if (shutdownRequested) return;
+    shutdownRequested = true;
+    listener.close();
+    proxyDone = proxy.shutdown();
+    if (tokenFilePath) {
+      platform2.fs.unlink?.(tokenFilePath).catch(() => {
+      });
+    }
+  };
+  if (platform2.onSignal) {
+    platform2.onSignal("SIGINT", shutdown);
+    platform2.onSignal("SIGTERM", shutdown);
+    platform2.onSignal("SIGHUP", shutdown);
+  }
   if (generatedBearer && resolvedBearer) {
     tokenFilePath = await publishBearer(
       platform2,
@@ -13382,32 +13597,22 @@ async function runProxyHttp(platform2, options, proxy, resolvedBearer, generated
       address,
       options.json
     );
+    if (shutdownRequested && tokenFilePath) {
+      await platform2.fs.unlink?.(tokenFilePath).catch(() => {
+      });
+    }
   } else {
     if (options.json) {
       await platform2.write(1, `${JSON.stringify(address)}
 `);
     }
   }
-  await platform2.write(2, `mcpcat serve --proxy: listening on ${listenUrl}
+  if (!shutdownRequested) {
+    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 (tokenFilePath) {
-      platform2.fs.unlink?.(tokenFilePath).catch(() => {
-      });
+    if (options.onListening) {
+      await options.onListening(actualPort);
     }
-  };
-  if (platform2.onSignal) {
-    platform2.onSignal("SIGINT", shutdown);
-    platform2.onSignal("SIGTERM", shutdown);
-    platform2.onSignal("SIGHUP", shutdown);
   }
   const handler = (request) => handleProxyMcpRequest(
     request,
@@ -13432,6 +13637,7 @@ async function runProxyHttp(platform2, options, proxy, resolvedBearer, generated
   } catch {
     if (!shutdownRequested) throw new Error("listener closed unexpectedly");
   }
+  await proxyDone;
   return 0;
 }
 async function handleProxyMcpRequest(request, proxy, serverOrigins, allowedOrigins, allowedHosts, resolvedBearer) {
@@ -13551,22 +13757,6 @@ async function runHttpServer(platform2, options, tools, call, serverName, versio
   const address = serveAddress(platform2, options.host, actualPort);
   const listenUrl = address.url;
   let tokenFilePath;
-  if (generatedBearer && resolvedBearer) {
-    tokenFilePath = await publishBearer(
-      platform2,
-      resolvedBearer,
-      actualPort,
-      address,
-      options.json
-    );
-  } else {
-    if (options.json) {
-      await platform2.write(1, `${JSON.stringify(address)}
-`);
-    }
-  }
-  await platform2.write(2, `mcpcat serve: listening on ${listenUrl}
-`);
   let shutdownRequested = false;
   let inflightDone;
   const shutdown = () => {
@@ -13584,6 +13774,28 @@ async function runHttpServer(platform2, options, tools, call, serverName, versio
     platform2.onSignal("SIGTERM", shutdown);
     platform2.onSignal("SIGHUP", shutdown);
   }
+  if (generatedBearer && resolvedBearer) {
+    tokenFilePath = await publishBearer(
+      platform2,
+      resolvedBearer,
+      actualPort,
+      address,
+      options.json
+    );
+    if (shutdownRequested && tokenFilePath) {
+      await platform2.fs.unlink?.(tokenFilePath).catch(() => {
+      });
+    }
+  } else {
+    if (options.json) {
+      await platform2.write(1, `${JSON.stringify(address)}
+`);
+    }
+  }
+  if (!shutdownRequested) {
+    await platform2.write(2, `mcpcat serve: listening on ${listenUrl}
+`);
+  }
   const handler = (request) => handleMcpRequest(
     request,
     tools,
@@ -16734,5 +16946,5 @@ try {
   });
 } catch {
 }
-var code = await run(platform, "0.15.5", args);
+var code = await run(platform, "0.15.7", args);
 process.exit(code);