@ai-ecoverse/mcpcat 0.20.2 → 0.20.3

package/dist/host/mcpcat.mjs

@@ -8485,8 +8485,19 @@ function buildServerInfo(discoverResult2) {
     instructions: discoverResult2?.instructions
   };
 }
+function readHiddenTools(result) {
+  const meta = result?._meta;
+  const hidden = meta?.["io.mcpcat/hidden"];
+  const out = {};
+  if (!hidden || typeof hidden !== "object" || Array.isArray(hidden)) return out;
+  for (const [name, why] of Object.entries(hidden)) {
+    if (typeof why === "string") out[name] = why;
+  }
+  return out;
+}
 function buildStatelessMethods(requestFn, discoverResult2) {
   let serverInfoCache;
+  let hidden = {};
   return {
     async info() {
       if (serverInfoCache) return serverInfoCache;
@@ -8494,7 +8505,12 @@ function buildStatelessMethods(requestFn, discoverResult2) {
       return serverInfoCache;
     },
     async listTools() {
-      return (await requestFn("tools/list", {}))?.tools ?? [];
+      const result = await requestFn("tools/list", {});
+      hidden = readHiddenTools(result);
+      return result?.tools ?? [];
+    },
+    hiddenTool(name) {
+      return Object.hasOwn(hidden, name) ? hidden[name] : void 0;
     },
     async callTool(name, args2, _callOptions) {
       const params = {
@@ -8934,12 +8950,18 @@ function buildServerInfo2(discoverResult2) {
   };
 }
 function buildConnectionMethods(rpc, discoverResult2, proc) {
+  let hidden = {};
   return {
     async info() {
       return buildServerInfo2(discoverResult2);
     },
     async listTools() {
-      return (await rpc.request("tools/list", {}))?.tools ?? [];
+      const result = await rpc.request("tools/list", {});
+      hidden = readHiddenTools(result);
+      return result?.tools ?? [];
+    },
+    hiddenTool(name) {
+      return Object.hasOwn(hidden, name) ? hidden[name] : void 0;
     },
     async callTool(name, args2, callOptions) {
       const params = { name, arguments: args2 ?? {} };
@@ -9141,7 +9163,7 @@ function readLine(platform2) {
   return new Promise((resolve, reject) => {
     const reader = platform2.stdin.getReader();
     const chunks = [];
-    function pump() {
+    function pump2() {
       reader.read().then(({ done, value }) => {
         if (done) {
           reader.releaseLock();
@@ -9155,10 +9177,10 @@ function readLine(platform2) {
           resolve(text.split("\n")[0]);
           return;
         }
-        pump();
+        pump2();
       }, reject);
     }
-    pump();
+    pump2();
   });
 }
 function concatChunks(chunks) {
@@ -12037,7 +12059,7 @@ async function writeResponse(writer, response) {
 var PROTOCOL_VERSIONS = ["2026-07-28", "2025-11-25", "2025-06-18"];
 var OUTPUT_CAP = 1048576;
 var JSON_CT = "application/json; charset=utf-8";
-async function handleJsonRpc(raw, tools, call, serverName, serverVersion) {
+async function handleJsonRpc(raw, source, call, serverName, serverVersion) {
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -12054,16 +12076,26 @@ async function handleJsonRpc(raw, tools, call, serverName, serverVersion) {
   if (method === "initialize")
     return rpcOk(id, initializeResult(params, serverName, serverVersion));
   if (method === "server/discover") return rpcOk(id, discoverResult(serverName, serverVersion));
-  if (method === "tools/list") return rpcOk(id, { tools });
   if (method === "ping") return rpcOk(id, {});
-  if (method === "tools/call") return toolCall(id, params, tools, call);
+  if (method === "tools/list" || method === "tools/call") {
+    const listing = Array.isArray(source) ? { tools: source } : await source();
+    if (listing.error) return rpcError(id, -32e3, listing.error);
+    if (method === "tools/call") return toolCall(id, params, listing, call);
+    const hidden = listing.hidden && Object.keys(listing.hidden).length > 0 ? listing.hidden : null;
+    return rpcOk(id, {
+      tools: listing.tools,
+      ...hidden ? { _meta: { "io.mcpcat/hidden": hidden } } : {}
+    });
+  }
   return rpcError(id, -32601, `Method not found: ${method}`);
 }
-async function toolCall(id, params, tools, call) {
+async function toolCall(id, params, { tools, hidden }, call) {
   const name = params && typeof params === "object" ? readString(params, "name") : void 0;
   if (!name) return rpcError(id, -32602, "tools/call requires a name");
-  if (!tools.some((tool) => tool.name === name))
-    return rpcError(id, -32602, `Unknown tool: ${name}`);
+  if (!tools.some((tool) => tool.name === name)) {
+    const why = hidden && Object.hasOwn(hidden, name) ? hidden[name] : void 0;
+    return rpcError(id, -32602, why ? `Unknown tool: ${name}: ${why}` : `Unknown tool: ${name}`);
+  }
   const args2 = params && typeof params === "object" ? Object.getOwnPropertyDescriptor(params, "arguments")?.value : void 0;
   try {
     const result = await call(name, args2);
@@ -12427,7 +12459,149 @@ ${tail}`,
     }
   };
 }
-async function runProcess(platform2, argv, stdin, timeoutMs, limit) {
+var DIALOG_POLL_MS = 250;
+var DIALOG_READY_MS = 1e3;
+var DIALOG_STALL_MS = 1e3;
+function watchLoop(watch) {
+  let timer;
+  const result = new Promise((resolve) => {
+    timer = setInterval(() => {
+      const found = watch();
+      if (found) {
+        clearInterval(timer);
+        resolve(found);
+      }
+    }, DIALOG_POLL_MS);
+  });
+  return {
+    result,
+    stop() {
+      clearInterval(timer);
+    }
+  };
+}
+async function browserSocketUrl(platform2, cdp) {
+  if (/^wss?:\/\//i.test(cdp)) return cdp;
+  if (!/^https?:\/\//i.test(cdp)) return void 0;
+  const res = await platform2.fetch(`${cdp.replace(/\/+$/, "")}/json/version`, {
+    signal: AbortSignal.timeout(DIALOG_READY_MS)
+  });
+  const body = await res.json();
+  return typeof body.webSocketDebuggerUrl === "string" ? body.webSocketDebuggerUrl : void 0;
+}
+function parseCdp(data) {
+  try {
+    return JSON.parse(
+      typeof data === "string" ? data : new TextDecoder().decode(data)
+    );
+  } catch {
+    return void 0;
+  }
+}
+function applyCdp(state, channel, send, msg, settle) {
+  if (msg.method === "Page.javascriptDialogOpening") {
+    state.open = typeof msg.params?.type === "string" ? msg.params.type : "dialog";
+  } else if (msg.method === "Page.javascriptDialogClosed") {
+    state.open = void 0;
+  } else if (msg.method === "Target.detachedFromTarget") {
+    channel.close();
+  } else if (msg.id === 1) {
+    const sessionId = msg.result?.sessionId;
+    if (typeof sessionId !== "string") {
+      channel.close();
+      return;
+    }
+    state.enableSentAt = Date.now();
+    send({ id: 2, sessionId, method: "Page.enable" });
+  } else if (msg.id === 2) {
+    state.enableSentAt = void 0;
+    settle();
+  }
+}
+async function pump(state, channel, send, settle) {
+  const reader = channel.readable.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      const msg = parseCdp(value);
+      if (msg) applyCdp(state, channel, send, msg, settle);
+    }
+  } catch {
+    return;
+  }
+}
+async function attachSocket(platform2, state, url, targetId) {
+  const channel = await platform2.websocket(url).catch(() => void 0);
+  if (!channel) return;
+  state.channel = channel;
+  const writer = channel.writable.getWriter();
+  const send = (message) => {
+    writer.write(JSON.stringify(message)).catch(() => channel.close());
+  };
+  let settle;
+  const settled = new Promise((resolve) => {
+    settle = resolve;
+  });
+  void pump(state, channel, send, settle).then(() => {
+    if (state.channel === channel) {
+      state.channel = void 0;
+      state.open = void 0;
+      state.enableSentAt = void 0;
+    }
+    channel.close();
+    settle();
+  });
+  send({ id: 1, method: "Target.attachToTarget", params: { targetId, flatten: true } });
+  await settled;
+}
+function watchJsDialogs(platform2, cdp, targetId) {
+  const state = {};
+  let connecting;
+  let closed = false;
+  const connect2 = async () => {
+    if (!platform2.websocket) return;
+    const url = await browserSocketUrl(platform2, cdp).catch(() => void 0);
+    if (!url || closed) return;
+    await attachSocket(platform2, state, url, targetId);
+  };
+  return {
+    async ready() {
+      if (closed || state.channel) return;
+      connecting ??= connect2().finally(() => {
+        connecting = void 0;
+      });
+      let timer;
+      await Promise.race([
+        connecting,
+        new Promise((resolve) => {
+          timer = setTimeout(resolve, DIALOG_READY_MS);
+        })
+      ]);
+      clearTimeout(timer);
+    },
+    dialog: () => state.open,
+    stalled: () => state.enableSentAt !== void 0 && Date.now() - state.enableSentAt >= DIALOG_STALL_MS,
+    close() {
+      closed = true;
+      state.channel?.close();
+    }
+  };
+}
+function dialogMessage(tab, type) {
+  return `tab ${tab} is blocked by a JavaScript ${type.replace(/[^a-z]/gi, "")} dialog; answer or dismiss it in the browser, then retry`;
+}
+function timeoutMessage(verb, timeoutMs, tab, watcher) {
+  const head = `${verb} timed out after ${Math.round(timeoutMs / 1e3)}s`;
+  if (!watcher) {
+    return `${head}; if the page shows a JavaScript dialog (alert, confirm, prompt), answer it, and pass --cdp <url> so mcpcat can detect one`;
+  }
+  if (watcher.stalled()) {
+    return `${head}; tab ${tab} does not answer the DevTools protocol, so a JavaScript dialog opened before mcpcat attached may block it; answer it in the browser, then retry`;
+  }
+  return head;
+}
+async function runProcess(platform2, argv, stdin, timeoutMs, limit, watch) {
   let proc;
   try {
     proc = await platform2.spawn({ argv });
@@ -12471,12 +12645,20 @@ async function runProcess(platform2, argv, stdin, timeoutMs, limit) {
     readStream3(proc.stderr, err),
     proc.wait()
   ]);
-  const result = await Promise.race([work, timer]);
+  const watcher = watch ? watchLoop(watch) : void 0;
+  const blocked = watcher ? watcher.result.then((type) => ({ blocked: type })) : new Promise(() => {
+  });
+  const result = await Promise.race([work, timer, blocked]);
   clearTimeout(timeoutId);
+  watcher?.stop();
   if (result === "timeout") {
     await proc.kill("SIGTERM");
     return { stdout: "", stderr: "timed out", exitCode: 124, cut: false };
   }
+  if (!Array.isArray(result)) {
+    await proc.kill("SIGTERM");
+    return { stdout: "", stderr: "blocked", exitCode: 124, cut: false, blocked: result.blocked };
+  }
   const [, , exitResult] = result;
   const stdout = out.finish();
   const stderr = err.finish();
@@ -12487,7 +12669,7 @@ async function runProcess(platform2, argv, stdin, timeoutMs, limit) {
     cut: stdout.cut
   };
 }
-async function resolveWebMcpTab(platform2, options) {
+async function listTabs(platform2, options) {
   const argv = [options.playwrightCli, "tab-list"];
   if (options.cdp) argv.push("--cdp", options.cdp);
   const result = await runProcess(
@@ -12514,6 +12696,13 @@ async function resolveWebMcpTab(platform2, options) {
   if (new Set(rows.map((r) => r.id)).size !== rows.length || active.length > 1) {
     return { error: "could not read playwright-cli tab-list" };
   }
+  return { rows };
+}
+async function resolveWebMcpTab(platform2, options) {
+  const listed = await listTabs(platform2, options);
+  if ("error" in listed) return listed;
+  const { rows } = listed;
+  const active = rows.filter((r) => r.active);
   if (active.length === 1) return { tab: active[0].id };
   if (rows.length === 1) return { tab: rows[0].id };
   return {
@@ -12576,20 +12765,57 @@ function ambiguityError(name, peers) {
     `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`
   );
 }
+async function blockedNow(watcher, tab) {
+  if (!watcher) return void 0;
+  await watcher.ready();
+  const open2 = watcher.dialog();
+  return open2 ? dialogMessage(tab, open2) : void 0;
+}
+async function tabGone(platform2, options) {
+  const { tab } = options;
+  if (!tab) return void 0;
+  const listed = await listTabs(platform2, options);
+  if ("error" in listed || listed.rows.some((r) => r.id === tab)) return void 0;
+  return `tab ${tab} is gone (the browser restarted or the tab closed); restart mcpcat serve --webmcp, or pass --tab <targetId> (see playwright-cli tab-list)`;
+}
+function hiddenToolMessage(name) {
+  return `tool ${name} exists on the page but is hidden because it is consequential (consequentialHint); restart with mcpcat serve --webmcp --allow-consequential to expose it`;
+}
 function createWebMcpHandler(platform2, options) {
   let cache;
   const baseArgs = buildBaseArgs(options);
   const listLimit = Math.max(options.maxOutput, WEBMCP_LIST_FLOOR);
+  const { cdp, tab } = options;
+  const watcher = cdp && tab ? watchJsDialogs(platform2, cdp, tab) : void 0;
+  const watch = watcher ? () => watcher.dialog() : void 0;
   async function listRaw(fresh = false) {
+    const blocked = await blockedNow(watcher, tab);
+    if (blocked) return { tools: [], error: blocked };
     const now = Date.now();
     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, listLimit);
+    const result = await runProcess(
+      platform2,
+      argv,
+      void 0,
+      options.callTimeoutMs,
+      listLimit,
+      watch
+    );
     if (result.exitCode === -1) {
       return { tools: [], error: result.stderr, notFound: true };
     }
+    if (result.blocked) {
+      return { tools: [], error: dialogMessage(tab, result.blocked) };
+    }
+    if (result.exitCode === 124) {
+      return {
+        tools: [],
+        error: timeoutMessage("webmcp-list", options.callTimeoutMs, tab, watcher)
+      };
+    }
     if (result.exitCode !== 0) {
       return { tools: [], error: result.stderr || `webmcp-list exited ${result.exitCode}` };
     }
@@ -12605,6 +12831,10 @@ function createWebMcpHandler(platform2, options) {
     if (!Array.isArray(parsed)) {
       return { tools: [], error: "webmcp-list did not return an array" };
     }
+    if (parsed.length === 0) {
+      const gone2 = await tabGone(platform2, options);
+      if (gone2) return { tools: [], error: gone2 };
+    }
     const tools = parsed;
     cache = { tools, expiresAt: now + options.ttlMs };
     return { tools };
@@ -12612,11 +12842,13 @@ function createWebMcpHandler(platform2, options) {
   async function getRpcTools() {
     const { tools, error, notFound } = await listRaw();
     if (notFound) return null;
-    if (error) return [];
+    if (error) return { tools: [], error };
     const rpcTools = [];
+    const hidden = {};
     for (const { name, tool, peers } of exposedTools(tools)) {
       if (peers.length > 1) continue;
       if (tool.annotations?.consequentialHint && !options.allowConsequential) {
+        hidden[name] = hiddenToolMessage(name);
         continue;
       }
       const mapped = mapDescriptionAnnotations(tool.annotations);
@@ -12627,7 +12859,7 @@ function createWebMcpHandler(platform2, options) {
         annotations: mapped
       });
     }
-    return rpcTools;
+    return { tools: rpcTools, hidden };
   }
   async function callTool(name, args2) {
     const { tools, error } = await listRaw(true);
@@ -12652,11 +12884,18 @@ function createWebMcpHandler(platform2, options) {
       argv,
       stdinData,
       options.callTimeoutMs,
-      options.maxOutput
+      options.maxOutput,
+      watch
     );
     if (result.exitCode === -1) {
       throw new Error(result.stderr || "playwright-cli not found");
     }
+    if (result.blocked) {
+      throw new Error(dialogMessage(tab, result.blocked));
+    }
+    if (result.exitCode === 124) {
+      throw new Error(timeoutMessage("webmcp-call", options.callTimeoutMs, tab, watcher));
+    }
     if (result.exitCode === 2) {
       throw new Error(result.stderr || "webmcp-call error");
     }
@@ -12678,7 +12917,10 @@ function createWebMcpHandler(platform2, options) {
   function invalidateCache() {
     cache = void 0;
   }
-  return { getRpcTools, callTool, invalidateCache };
+  function close() {
+    watcher?.close();
+  }
+  return { getRpcTools, callTool, invalidateCache, close };
 }
 
 // src/serve/runtime.ts
@@ -13441,23 +13683,42 @@ async function buildProxyConnectOpts(platform2, options, version) {
   }
   return { connectOpts, hiddenValues };
 }
-function resolvePlaywrightCli(platform2, explicit) {
+async function resolvePlaywrightCli(platform2, explicit) {
   if (explicit) return explicit;
   if (platform2.kind === "kernel") return "playwright-cli";
   const pathEnv = platform2.env.PATH ?? "";
-  const sep = pathEnv.includes(";") ? ";" : ":";
-  for (const dir of pathEnv.split(sep)) {
+  const windows = pathEnv.includes(";");
+  const names = windows ? ["playwright-cli.exe", "playwright-cli.cmd", "playwright-cli"] : ["playwright-cli"];
+  for (const dir of pathEnv.split(windows ? ";" : ":")) {
     if (!dir) continue;
-    return "playwright-cli";
+    for (const name of names) {
+      const candidate = `${dir.replace(/[\\/]+$/, "")}/${name}`;
+      if (await platform2.fs.exists(candidate).catch(() => false)) return "playwright-cli";
+    }
   }
   return void 0;
 }
+async function listenOrReport(platform2, options, label) {
+  try {
+    return await platform2.listen({ host: options.host, port: options.port });
+  } catch (err) {
+    const { code: code2, message } = err;
+    const reason = code2 === "EADDRINUSE" || /EADDRINUSE/.test(String(message)) ? "address already in use" : String(message ?? err);
+    const host = options.host.includes(":") ? `[${options.host}]` : options.host;
+    await platform2.write(
+      2,
+      sanitizeTerminal(`${label}: cannot listen on ${host}:${options.port}: ${reason}
+`)
+    );
+    return 3;
+  }
+}
 async function runWebMcpServe(platform2, options, version, resolvedBearer, generatedBearer) {
-  const cliPath = resolvePlaywrightCli(platform2, options.webmcpPlaywrightCli);
+  const cliPath = await resolvePlaywrightCli(platform2, options.webmcpPlaywrightCli);
   if (!cliPath) {
     await platform2.write(
       2,
-      "mcpcat serve --webmcp: playwright-cli not found. Install it with: curl -fsSL https://get.sliccy.ai/playwright-cli | sh\n"
+      "mcpcat serve --webmcp: playwright-cli not found on PATH. Install it with: curl -fsSL https://get.sliccy.ai/playwright-cli | sh\n"
     );
     return 3;
   }
@@ -13492,6 +13753,20 @@ async function runWebMcpServe(platform2, options, version, resolvedBearer, gener
     callTimeoutMs: options.callTimeout,
     maxOutput: options.maxOutput
   });
+  try {
+    return await serveWebMcpHandler(
+      platform2,
+      options,
+      handler,
+      version,
+      resolvedBearer,
+      generatedBearer
+    );
+  } finally {
+    handler.close();
+  }
+}
+async function serveWebMcpHandler(platform2, options, handler, version, resolvedBearer, generatedBearer) {
   const probe = await handler.getRpcTools();
   if (probe === null) {
     await platform2.write(
@@ -13501,7 +13776,7 @@ async function runWebMcpServe(platform2, options, version, resolvedBearer, gener
     return 3;
   }
   const serverName = "mcpcat-webmcp";
-  const getTools = async () => await handler.getRpcTools() ?? [];
+  const getTools = async () => await handler.getRpcTools() ?? { tools: [] };
   const callTool = (name, args2) => handler.callTool(name, args2);
   if (options.transport === "stdio") {
     return runWebMcpStdio(platform2, getTools, callTool, serverName, version);
@@ -13532,8 +13807,7 @@ async function runWebMcpStdio(platform2, getTools, callTool, serverName, version
         const line = buffer.slice(0, nlIdx).trim();
         buffer = buffer.slice(nlIdx + 1);
         if (!line) continue;
-        const tools = await getTools();
-        const outcome = await handleJsonRpc(line, tools, callTool, serverName, version);
+        const outcome = await handleJsonRpc(line, getTools, callTool, serverName, version);
         if (outcome.status === 202) continue;
         const writer = platform2.stdout.getWriter();
         await writer.write(enc.encode(`${outcome.body}
@@ -13560,7 +13834,8 @@ async function runWebMcpHttp(platform2, options, getTools, callTool, serverName,
     return 2;
   }
   const allowedOrigins = new Set(options.allowOrigins);
-  const listener = await platform2.listen({ host: options.host, port: options.port });
+  const listener = await listenOrReport(platform2, options, "mcpcat serve --webmcp");
+  if (typeof listener === "number") return listener;
   const actualPort = listener.port;
   const serverOrigins = buildServerOrigins(options.host, actualPort);
   const allowedHosts = buildAllowedHosts(options.host, actualPort, options.allowHosts);
@@ -13666,8 +13941,7 @@ async function runWebMcpHttp(platform2, options, getTools, callTool, serverName,
         };
       }
     }
-    const tools = await getTools();
-    const outcome = await handleJsonRpc(request.body, tools, callTool, serverName, version);
+    const outcome = await handleJsonRpc(request.body, getTools, callTool, serverName, version);
     return {
       status: outcome.status,
       reason: outcome.status === 200 ? "OK" : "Accepted",
@@ -13755,10 +14029,11 @@ async function runProxyHttp(platform2, options, proxy, resolvedBearer, generated
     return 2;
   }
   const allowedOrigins = new Set(options.allowOrigins);
-  const listener = await platform2.listen({
-    host: options.host,
-    port: options.port
-  });
+  const listener = await listenOrReport(platform2, options, "mcpcat serve --proxy");
+  if (typeof listener === "number") {
+    await proxy.shutdown();
+    return listener;
+  }
   const actualPort = listener.port;
   const serverOrigins = buildServerOrigins(options.host, actualPort);
   const allowedHosts = buildAllowedHosts(options.host, actualPort, options.allowHosts);
@@ -13939,7 +14214,8 @@ async function runHttpServer(platform2, options, tools, call, serverName, versio
     return 2;
   }
   const allowedOrigins = new Set(options.allowOrigins);
-  const listener = await platform2.listen({ host: options.host, port: options.port });
+  const listener = await listenOrReport(platform2, options, "mcpcat serve");
+  if (typeof listener === "number") return listener;
   const actualPort = listener.port;
   const serverOrigins = buildServerOrigins(options.host, actualPort);
   const allowedHosts = buildAllowedHosts(options.host, actualPort, options.allowHosts);
@@ -16071,6 +16347,11 @@ async function runCall(platform2, conn, toolName, dataArg, toolArgs, opts) {
   if (toolArgs.length > 0) {
     const tools = await conn.listTools();
     const tool = tools.find((t) => t.name === toolName);
+    const hidden = tool ? void 0 : conn.hiddenTool?.(toolName);
+    if (hidden) {
+      await writeErr(platform2, opts.json ?? false, "usage", hidden);
+      return EXIT_USAGE;
+    }
     const schema = tool?.inputSchema ?? { type: "object", properties: {} };
     const skipRequired = opts.noValidate || !!dataArg;
     const c = coerceArgsBySchema(toolArgs, schema, { noValidate: skipRequired });
@@ -17225,6 +17506,34 @@ function nodeListen(options) {
     });
   });
 }
+function hostWebSocket(url) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    ws.binaryType = "arraybuffer";
+    let feed;
+    const readable = new ReadableStream({
+      start(controller) {
+        feed = controller;
+      }
+    });
+    ws.onclose = () => feed.close();
+    ws.onerror = () => reject(new Error(`websocket ${url} failed`));
+    ws.onmessage = (event) => {
+      feed.enqueue(typeof event.data === "string" ? event.data : new Uint8Array(event.data));
+    };
+    ws.onopen = () => {
+      resolve({
+        readable,
+        writable: new WritableStream({
+          write(chunk) {
+            ws.send(chunk);
+          }
+        }),
+        close: () => ws.close()
+      });
+    };
+  });
+}
 function createHostPlatform() {
   const encoder2 = new TextEncoder();
   return {
@@ -17232,6 +17541,7 @@ function createHostPlatform() {
     fetch: globalThis.fetch,
     spawn: nodeSpawn,
     listen: nodeListen,
+    websocket: hostWebSocket,
     fs: hostFs,
     env: process.env,
     cwd: process.cwd(),
@@ -17269,5 +17579,5 @@ try {
   });
 } catch {
 }
-var code = await run(platform, "0.20.2", args);
+var code = await run(platform, "0.20.3", args);
 process.exit(code);

package/dist/kernel/mcpcat.mjs

@@ -8106,8 +8106,19 @@ function buildServerInfo(discoverResult2) {
     instructions: discoverResult2?.instructions
   };
 }
+function readHiddenTools(result) {
+  const meta = result?._meta;
+  const hidden = meta?.["io.mcpcat/hidden"];
+  const out = {};
+  if (!hidden || typeof hidden !== "object" || Array.isArray(hidden)) return out;
+  for (const [name, why] of Object.entries(hidden)) {
+    if (typeof why === "string") out[name] = why;
+  }
+  return out;
+}
 function buildStatelessMethods(requestFn, discoverResult2) {
   let serverInfoCache;
+  let hidden = {};
   return {
     async info() {
       if (serverInfoCache) return serverInfoCache;
@@ -8115,7 +8126,12 @@ function buildStatelessMethods(requestFn, discoverResult2) {
       return serverInfoCache;
     },
     async listTools() {
-      return (await requestFn("tools/list", {}))?.tools ?? [];
+      const result = await requestFn("tools/list", {});
+      hidden = readHiddenTools(result);
+      return result?.tools ?? [];
+    },
+    hiddenTool(name) {
+      return Object.hasOwn(hidden, name) ? hidden[name] : void 0;
     },
     async callTool(name, args, _callOptions) {
       const params = {
@@ -8555,12 +8571,18 @@ function buildServerInfo2(discoverResult2) {
   };
 }
 function buildConnectionMethods(rpc, discoverResult2, proc) {
+  let hidden = {};
   return {
     async info() {
       return buildServerInfo2(discoverResult2);
     },
     async listTools() {
-      return (await rpc.request("tools/list", {}))?.tools ?? [];
+      const result = await rpc.request("tools/list", {});
+      hidden = readHiddenTools(result);
+      return result?.tools ?? [];
+    },
+    hiddenTool(name) {
+      return Object.hasOwn(hidden, name) ? hidden[name] : void 0;
     },
     async callTool(name, args, callOptions) {
       const params = { name, arguments: args ?? {} };
@@ -8762,7 +8784,7 @@ function readLine(platform2) {
   return new Promise((resolve2, reject) => {
     const reader = platform2.stdin.getReader();
     const chunks = [];
-    function pump() {
+    function pump2() {
       reader.read().then(({ done, value }) => {
         if (done) {
           reader.releaseLock();
@@ -8776,10 +8798,10 @@ function readLine(platform2) {
           resolve2(text.split("\n")[0]);
           return;
         }
-        pump();
+        pump2();
       }, reject);
     }
-    pump();
+    pump2();
   });
 }
 function concatChunks(chunks) {
@@ -11658,7 +11680,7 @@ async function writeResponse(writer, response) {
 var PROTOCOL_VERSIONS = ["2026-07-28", "2025-11-25", "2025-06-18"];
 var OUTPUT_CAP = 1048576;
 var JSON_CT = "application/json; charset=utf-8";
-async function handleJsonRpc(raw, tools, call, serverName, serverVersion) {
+async function handleJsonRpc(raw, source, call, serverName, serverVersion) {
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -11675,16 +11697,26 @@ async function handleJsonRpc(raw, tools, call, serverName, serverVersion) {
   if (method === "initialize")
     return rpcOk(id, initializeResult(params, serverName, serverVersion));
   if (method === "server/discover") return rpcOk(id, discoverResult(serverName, serverVersion));
-  if (method === "tools/list") return rpcOk(id, { tools });
   if (method === "ping") return rpcOk(id, {});
-  if (method === "tools/call") return toolCall(id, params, tools, call);
+  if (method === "tools/list" || method === "tools/call") {
+    const listing = Array.isArray(source) ? { tools: source } : await source();
+    if (listing.error) return rpcError(id, -32e3, listing.error);
+    if (method === "tools/call") return toolCall(id, params, listing, call);
+    const hidden = listing.hidden && Object.keys(listing.hidden).length > 0 ? listing.hidden : null;
+    return rpcOk(id, {
+      tools: listing.tools,
+      ...hidden ? { _meta: { "io.mcpcat/hidden": hidden } } : {}
+    });
+  }
   return rpcError(id, -32601, `Method not found: ${method}`);
 }
-async function toolCall(id, params, tools, call) {
+async function toolCall(id, params, { tools, hidden }, call) {
   const name = params && typeof params === "object" ? readString(params, "name") : void 0;
   if (!name) return rpcError(id, -32602, "tools/call requires a name");
-  if (!tools.some((tool) => tool.name === name))
-    return rpcError(id, -32602, `Unknown tool: ${name}`);
+  if (!tools.some((tool) => tool.name === name)) {
+    const why = hidden && Object.hasOwn(hidden, name) ? hidden[name] : void 0;
+    return rpcError(id, -32602, why ? `Unknown tool: ${name}: ${why}` : `Unknown tool: ${name}`);
+  }
   const args = params && typeof params === "object" ? Object.getOwnPropertyDescriptor(params, "arguments")?.value : void 0;
   try {
     const result = await call(name, args);
@@ -12048,7 +12080,149 @@ ${tail}`,
     }
   };
 }
-async function runProcess(platform2, argv, stdin, timeoutMs, limit) {
+var DIALOG_POLL_MS = 250;
+var DIALOG_READY_MS = 1e3;
+var DIALOG_STALL_MS = 1e3;
+function watchLoop(watch) {
+  let timer;
+  const result = new Promise((resolve2) => {
+    timer = setInterval(() => {
+      const found = watch();
+      if (found) {
+        clearInterval(timer);
+        resolve2(found);
+      }
+    }, DIALOG_POLL_MS);
+  });
+  return {
+    result,
+    stop() {
+      clearInterval(timer);
+    }
+  };
+}
+async function browserSocketUrl(platform2, cdp) {
+  if (/^wss?:\/\//i.test(cdp)) return cdp;
+  if (!/^https?:\/\//i.test(cdp)) return void 0;
+  const res = await platform2.fetch(`${cdp.replace(/\/+$/, "")}/json/version`, {
+    signal: AbortSignal.timeout(DIALOG_READY_MS)
+  });
+  const body = await res.json();
+  return typeof body.webSocketDebuggerUrl === "string" ? body.webSocketDebuggerUrl : void 0;
+}
+function parseCdp(data) {
+  try {
+    return JSON.parse(
+      typeof data === "string" ? data : new TextDecoder().decode(data)
+    );
+  } catch {
+    return void 0;
+  }
+}
+function applyCdp(state, channel, send, msg, settle) {
+  if (msg.method === "Page.javascriptDialogOpening") {
+    state.open = typeof msg.params?.type === "string" ? msg.params.type : "dialog";
+  } else if (msg.method === "Page.javascriptDialogClosed") {
+    state.open = void 0;
+  } else if (msg.method === "Target.detachedFromTarget") {
+    channel.close();
+  } else if (msg.id === 1) {
+    const sessionId = msg.result?.sessionId;
+    if (typeof sessionId !== "string") {
+      channel.close();
+      return;
+    }
+    state.enableSentAt = Date.now();
+    send({ id: 2, sessionId, method: "Page.enable" });
+  } else if (msg.id === 2) {
+    state.enableSentAt = void 0;
+    settle();
+  }
+}
+async function pump(state, channel, send, settle) {
+  const reader = channel.readable.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      const msg = parseCdp(value);
+      if (msg) applyCdp(state, channel, send, msg, settle);
+    }
+  } catch {
+    return;
+  }
+}
+async function attachSocket(platform2, state, url, targetId) {
+  const channel = await platform2.websocket(url).catch(() => void 0);
+  if (!channel) return;
+  state.channel = channel;
+  const writer = channel.writable.getWriter();
+  const send = (message) => {
+    writer.write(JSON.stringify(message)).catch(() => channel.close());
+  };
+  let settle;
+  const settled = new Promise((resolve2) => {
+    settle = resolve2;
+  });
+  void pump(state, channel, send, settle).then(() => {
+    if (state.channel === channel) {
+      state.channel = void 0;
+      state.open = void 0;
+      state.enableSentAt = void 0;
+    }
+    channel.close();
+    settle();
+  });
+  send({ id: 1, method: "Target.attachToTarget", params: { targetId, flatten: true } });
+  await settled;
+}
+function watchJsDialogs(platform2, cdp, targetId) {
+  const state = {};
+  let connecting;
+  let closed = false;
+  const connect2 = async () => {
+    if (!platform2.websocket) return;
+    const url = await browserSocketUrl(platform2, cdp).catch(() => void 0);
+    if (!url || closed) return;
+    await attachSocket(platform2, state, url, targetId);
+  };
+  return {
+    async ready() {
+      if (closed || state.channel) return;
+      connecting ??= connect2().finally(() => {
+        connecting = void 0;
+      });
+      let timer;
+      await Promise.race([
+        connecting,
+        new Promise((resolve2) => {
+          timer = setTimeout(resolve2, DIALOG_READY_MS);
+        })
+      ]);
+      clearTimeout(timer);
+    },
+    dialog: () => state.open,
+    stalled: () => state.enableSentAt !== void 0 && Date.now() - state.enableSentAt >= DIALOG_STALL_MS,
+    close() {
+      closed = true;
+      state.channel?.close();
+    }
+  };
+}
+function dialogMessage(tab, type) {
+  return `tab ${tab} is blocked by a JavaScript ${type.replace(/[^a-z]/gi, "")} dialog; answer or dismiss it in the browser, then retry`;
+}
+function timeoutMessage(verb, timeoutMs, tab, watcher) {
+  const head = `${verb} timed out after ${Math.round(timeoutMs / 1e3)}s`;
+  if (!watcher) {
+    return `${head}; if the page shows a JavaScript dialog (alert, confirm, prompt), answer it, and pass --cdp <url> so mcpcat can detect one`;
+  }
+  if (watcher.stalled()) {
+    return `${head}; tab ${tab} does not answer the DevTools protocol, so a JavaScript dialog opened before mcpcat attached may block it; answer it in the browser, then retry`;
+  }
+  return head;
+}
+async function runProcess(platform2, argv, stdin, timeoutMs, limit, watch) {
   let proc;
   try {
     proc = await platform2.spawn({ argv });
@@ -12092,12 +12266,20 @@ async function runProcess(platform2, argv, stdin, timeoutMs, limit) {
     readStream3(proc.stderr, err),
     proc.wait()
   ]);
-  const result = await Promise.race([work, timer]);
+  const watcher = watch ? watchLoop(watch) : void 0;
+  const blocked = watcher ? watcher.result.then((type) => ({ blocked: type })) : new Promise(() => {
+  });
+  const result = await Promise.race([work, timer, blocked]);
   clearTimeout(timeoutId);
+  watcher?.stop();
   if (result === "timeout") {
     await proc.kill("SIGTERM");
     return { stdout: "", stderr: "timed out", exitCode: 124, cut: false };
   }
+  if (!Array.isArray(result)) {
+    await proc.kill("SIGTERM");
+    return { stdout: "", stderr: "blocked", exitCode: 124, cut: false, blocked: result.blocked };
+  }
   const [, , exitResult] = result;
   const stdout = out.finish();
   const stderr = err.finish();
@@ -12108,7 +12290,7 @@ async function runProcess(platform2, argv, stdin, timeoutMs, limit) {
     cut: stdout.cut
   };
 }
-async function resolveWebMcpTab(platform2, options) {
+async function listTabs(platform2, options) {
   const argv = [options.playwrightCli, "tab-list"];
   if (options.cdp) argv.push("--cdp", options.cdp);
   const result = await runProcess(
@@ -12135,6 +12317,13 @@ async function resolveWebMcpTab(platform2, options) {
   if (new Set(rows.map((r) => r.id)).size !== rows.length || active.length > 1) {
     return { error: "could not read playwright-cli tab-list" };
   }
+  return { rows };
+}
+async function resolveWebMcpTab(platform2, options) {
+  const listed = await listTabs(platform2, options);
+  if ("error" in listed) return listed;
+  const { rows } = listed;
+  const active = rows.filter((r) => r.active);
   if (active.length === 1) return { tab: active[0].id };
   if (rows.length === 1) return { tab: rows[0].id };
   return {
@@ -12197,20 +12386,57 @@ function ambiguityError(name, peers) {
     `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`
   );
 }
+async function blockedNow(watcher, tab) {
+  if (!watcher) return void 0;
+  await watcher.ready();
+  const open = watcher.dialog();
+  return open ? dialogMessage(tab, open) : void 0;
+}
+async function tabGone(platform2, options) {
+  const { tab } = options;
+  if (!tab) return void 0;
+  const listed = await listTabs(platform2, options);
+  if ("error" in listed || listed.rows.some((r) => r.id === tab)) return void 0;
+  return `tab ${tab} is gone (the browser restarted or the tab closed); restart mcpcat serve --webmcp, or pass --tab <targetId> (see playwright-cli tab-list)`;
+}
+function hiddenToolMessage(name) {
+  return `tool ${name} exists on the page but is hidden because it is consequential (consequentialHint); restart with mcpcat serve --webmcp --allow-consequential to expose it`;
+}
 function createWebMcpHandler(platform2, options) {
   let cache;
   const baseArgs = buildBaseArgs(options);
   const listLimit = Math.max(options.maxOutput, WEBMCP_LIST_FLOOR);
+  const { cdp, tab } = options;
+  const watcher = cdp && tab ? watchJsDialogs(platform2, cdp, tab) : void 0;
+  const watch = watcher ? () => watcher.dialog() : void 0;
   async function listRaw(fresh = false) {
+    const blocked = await blockedNow(watcher, tab);
+    if (blocked) return { tools: [], error: blocked };
     const now = Date.now();
     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, listLimit);
+    const result = await runProcess(
+      platform2,
+      argv,
+      void 0,
+      options.callTimeoutMs,
+      listLimit,
+      watch
+    );
     if (result.exitCode === -1) {
       return { tools: [], error: result.stderr, notFound: true };
     }
+    if (result.blocked) {
+      return { tools: [], error: dialogMessage(tab, result.blocked) };
+    }
+    if (result.exitCode === 124) {
+      return {
+        tools: [],
+        error: timeoutMessage("webmcp-list", options.callTimeoutMs, tab, watcher)
+      };
+    }
     if (result.exitCode !== 0) {
       return { tools: [], error: result.stderr || `webmcp-list exited ${result.exitCode}` };
     }
@@ -12226,6 +12452,10 @@ function createWebMcpHandler(platform2, options) {
     if (!Array.isArray(parsed)) {
       return { tools: [], error: "webmcp-list did not return an array" };
     }
+    if (parsed.length === 0) {
+      const gone2 = await tabGone(platform2, options);
+      if (gone2) return { tools: [], error: gone2 };
+    }
     const tools = parsed;
     cache = { tools, expiresAt: now + options.ttlMs };
     return { tools };
@@ -12233,11 +12463,13 @@ function createWebMcpHandler(platform2, options) {
   async function getRpcTools() {
     const { tools, error, notFound } = await listRaw();
     if (notFound) return null;
-    if (error) return [];
+    if (error) return { tools: [], error };
     const rpcTools = [];
+    const hidden = {};
     for (const { name, tool, peers } of exposedTools(tools)) {
       if (peers.length > 1) continue;
       if (tool.annotations?.consequentialHint && !options.allowConsequential) {
+        hidden[name] = hiddenToolMessage(name);
         continue;
       }
       const mapped = mapDescriptionAnnotations(tool.annotations);
@@ -12248,7 +12480,7 @@ function createWebMcpHandler(platform2, options) {
         annotations: mapped
       });
     }
-    return rpcTools;
+    return { tools: rpcTools, hidden };
   }
   async function callTool(name, args) {
     const { tools, error } = await listRaw(true);
@@ -12273,11 +12505,18 @@ function createWebMcpHandler(platform2, options) {
       argv,
       stdinData,
       options.callTimeoutMs,
-      options.maxOutput
+      options.maxOutput,
+      watch
     );
     if (result.exitCode === -1) {
       throw new Error(result.stderr || "playwright-cli not found");
     }
+    if (result.blocked) {
+      throw new Error(dialogMessage(tab, result.blocked));
+    }
+    if (result.exitCode === 124) {
+      throw new Error(timeoutMessage("webmcp-call", options.callTimeoutMs, tab, watcher));
+    }
     if (result.exitCode === 2) {
       throw new Error(result.stderr || "webmcp-call error");
     }
@@ -12299,7 +12538,10 @@ function createWebMcpHandler(platform2, options) {
   function invalidateCache() {
     cache = void 0;
   }
-  return { getRpcTools, callTool, invalidateCache };
+  function close() {
+    watcher?.close();
+  }
+  return { getRpcTools, callTool, invalidateCache, close };
 }
 
 // src/serve/runtime.ts
@@ -13062,23 +13304,42 @@ async function buildProxyConnectOpts(platform2, options, version) {
   }
   return { connectOpts, hiddenValues };
 }
-function resolvePlaywrightCli(platform2, explicit) {
+async function resolvePlaywrightCli(platform2, explicit) {
   if (explicit) return explicit;
   if (platform2.kind === "kernel") return "playwright-cli";
   const pathEnv = platform2.env.PATH ?? "";
-  const sep = pathEnv.includes(";") ? ";" : ":";
-  for (const dir of pathEnv.split(sep)) {
+  const windows = pathEnv.includes(";");
+  const names = windows ? ["playwright-cli.exe", "playwright-cli.cmd", "playwright-cli"] : ["playwright-cli"];
+  for (const dir of pathEnv.split(windows ? ";" : ":")) {
     if (!dir) continue;
-    return "playwright-cli";
+    for (const name of names) {
+      const candidate = `${dir.replace(/[\\/]+$/, "")}/${name}`;
+      if (await platform2.fs.exists(candidate).catch(() => false)) return "playwright-cli";
+    }
   }
   return void 0;
 }
+async function listenOrReport(platform2, options, label) {
+  try {
+    return await platform2.listen({ host: options.host, port: options.port });
+  } catch (err) {
+    const { code, message } = err;
+    const reason = code === "EADDRINUSE" || /EADDRINUSE/.test(String(message)) ? "address already in use" : String(message ?? err);
+    const host = options.host.includes(":") ? `[${options.host}]` : options.host;
+    await platform2.write(
+      2,
+      sanitizeTerminal(`${label}: cannot listen on ${host}:${options.port}: ${reason}
+`)
+    );
+    return 3;
+  }
+}
 async function runWebMcpServe(platform2, options, version, resolvedBearer, generatedBearer) {
-  const cliPath = resolvePlaywrightCli(platform2, options.webmcpPlaywrightCli);
+  const cliPath = await resolvePlaywrightCli(platform2, options.webmcpPlaywrightCli);
   if (!cliPath) {
     await platform2.write(
       2,
-      "mcpcat serve --webmcp: playwright-cli not found. Install it with: curl -fsSL https://get.sliccy.ai/playwright-cli | sh\n"
+      "mcpcat serve --webmcp: playwright-cli not found on PATH. Install it with: curl -fsSL https://get.sliccy.ai/playwright-cli | sh\n"
     );
     return 3;
   }
@@ -13113,6 +13374,20 @@ async function runWebMcpServe(platform2, options, version, resolvedBearer, gener
     callTimeoutMs: options.callTimeout,
     maxOutput: options.maxOutput
   });
+  try {
+    return await serveWebMcpHandler(
+      platform2,
+      options,
+      handler,
+      version,
+      resolvedBearer,
+      generatedBearer
+    );
+  } finally {
+    handler.close();
+  }
+}
+async function serveWebMcpHandler(platform2, options, handler, version, resolvedBearer, generatedBearer) {
   const probe = await handler.getRpcTools();
   if (probe === null) {
     await platform2.write(
@@ -13122,7 +13397,7 @@ async function runWebMcpServe(platform2, options, version, resolvedBearer, gener
     return 3;
   }
   const serverName = "mcpcat-webmcp";
-  const getTools = async () => await handler.getRpcTools() ?? [];
+  const getTools = async () => await handler.getRpcTools() ?? { tools: [] };
   const callTool = (name, args) => handler.callTool(name, args);
   if (options.transport === "stdio") {
     return runWebMcpStdio(platform2, getTools, callTool, serverName, version);
@@ -13153,8 +13428,7 @@ async function runWebMcpStdio(platform2, getTools, callTool, serverName, version
         const line = buffer.slice(0, nlIdx).trim();
         buffer = buffer.slice(nlIdx + 1);
         if (!line) continue;
-        const tools = await getTools();
-        const outcome = await handleJsonRpc(line, tools, callTool, serverName, version);
+        const outcome = await handleJsonRpc(line, getTools, callTool, serverName, version);
         if (outcome.status === 202) continue;
         const writer = platform2.stdout.getWriter();
         await writer.write(enc.encode(`${outcome.body}
@@ -13181,7 +13455,8 @@ async function runWebMcpHttp(platform2, options, getTools, callTool, serverName,
     return 2;
   }
   const allowedOrigins = new Set(options.allowOrigins);
-  const listener = await platform2.listen({ host: options.host, port: options.port });
+  const listener = await listenOrReport(platform2, options, "mcpcat serve --webmcp");
+  if (typeof listener === "number") return listener;
   const actualPort = listener.port;
   const serverOrigins = buildServerOrigins(options.host, actualPort);
   const allowedHosts = buildAllowedHosts(options.host, actualPort, options.allowHosts);
@@ -13287,8 +13562,7 @@ async function runWebMcpHttp(platform2, options, getTools, callTool, serverName,
         };
       }
     }
-    const tools = await getTools();
-    const outcome = await handleJsonRpc(request.body, tools, callTool, serverName, version);
+    const outcome = await handleJsonRpc(request.body, getTools, callTool, serverName, version);
     return {
       status: outcome.status,
       reason: outcome.status === 200 ? "OK" : "Accepted",
@@ -13376,10 +13650,11 @@ async function runProxyHttp(platform2, options, proxy, resolvedBearer, generated
     return 2;
   }
   const allowedOrigins = new Set(options.allowOrigins);
-  const listener = await platform2.listen({
-    host: options.host,
-    port: options.port
-  });
+  const listener = await listenOrReport(platform2, options, "mcpcat serve --proxy");
+  if (typeof listener === "number") {
+    await proxy.shutdown();
+    return listener;
+  }
   const actualPort = listener.port;
   const serverOrigins = buildServerOrigins(options.host, actualPort);
   const allowedHosts = buildAllowedHosts(options.host, actualPort, options.allowHosts);
@@ -13560,7 +13835,8 @@ async function runHttpServer(platform2, options, tools, call, serverName, versio
     return 2;
   }
   const allowedOrigins = new Set(options.allowOrigins);
-  const listener = await platform2.listen({ host: options.host, port: options.port });
+  const listener = await listenOrReport(platform2, options, "mcpcat serve");
+  if (typeof listener === "number") return listener;
   const actualPort = listener.port;
   const serverOrigins = buildServerOrigins(options.host, actualPort);
   const allowedHosts = buildAllowedHosts(options.host, actualPort, options.allowHosts);
@@ -15692,6 +15968,11 @@ async function runCall(platform2, conn, toolName, dataArg, toolArgs, opts) {
   if (toolArgs.length > 0) {
     const tools = await conn.listTools();
     const tool = tools.find((t) => t.name === toolName);
+    const hidden = tool ? void 0 : conn.hiddenTool?.(toolName);
+    if (hidden) {
+      await writeErr(platform2, opts.json ?? false, "usage", hidden);
+      return EXIT_USAGE;
+    }
     const schema = tool?.inputSchema ?? { type: "object", properties: {} };
     const skipRequired = opts.noValidate || !!dataArg;
     const c = coerceArgsBySchema(toolArgs, schema, { noValidate: skipRequired });
@@ -16956,6 +17237,7 @@ function createKernelPlatform(ctx, options) {
     fetch: createKernelFetch(ctx),
     spawn: (options2) => kernelSpawn(ctx, options2),
     listen: (options2) => kernelListen(ctx, options2),
+    ...ctx.websocket ? { websocket: (url) => ctx.websocket(url) } : {},
     fs: kernelFs(ctx),
     env: ctx.env,
     cwd: ctx.cwd,
@@ -16991,7 +17273,7 @@ async function main(ctx) {
     packageDir: "/node_modules/@ai-ecoverse/mcpcat"
   });
   const args = ctx.argv.slice(1);
-  return run(platform2, "0.20.2", args);
+  return run(platform2, "0.20.3", args);
 }
 export {
   main as default

package/package.json

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