@ai-ecoverse/mcpcat 0.14.7 → 0.15.1

package/dist/host/mcpcat.mjs

@@ -8343,6 +8343,16 @@ var McpAuthError = class extends Error {
     this.target = target;
   }
 };
+var TransportRefusalError = class extends Error {
+  status;
+  reason;
+  constructor(status, reason) {
+    super(reason);
+    this.name = "TransportRefusalError";
+    this.status = status;
+    this.reason = reason;
+  }
+};
 var AuthRetryableError = class extends Error {
   response;
   constructor(response) {
@@ -8485,6 +8495,15 @@ 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) && authProvider)
       throw new AuthRetryableError(res);
     if (res.status === 401 || res.status === 403) throw new McpAuthError(res.status, url);
@@ -9018,6 +9037,7 @@ async function connect(platform2, options) {
     const isMethodNotFound = err instanceof StatelessRpcError && err.code === -32601 || err instanceof StatelessHttpError && err.status >= 400 && err.status < 500;
     if (options.protocolVersion?.startsWith("2026")) throw err;
     if (err instanceof McpAuthError || err instanceof AuthStepUpError) throw err;
+    if (err instanceof TransportRefusalError) throw err;
     if (err.name === "McpOAuthAuthorizationRequiredError") throw err;
     if (isMethodNotFound) {
       return createPiConnection({
@@ -11803,7 +11823,8 @@ ${stderr}` : stderr : stdout;
   return {
     content: [{ type: "text", text }],
     isError: result.exitCode !== 0,
-    structuredContent: { stdout, stderr, exitCode: result.exitCode }
+    structuredContent: { stdout, stderr, exitCode: result.exitCode },
+    ...result.meta ? { _meta: result.meta } : {}
   };
 }
 function initializeResult(params, serverName, serverVersion) {
@@ -12103,6 +12124,219 @@ function createProxyHandler(options) {
   return { handle, shutdown };
 }
 
+// src/serve/webmcp.ts
+function buildBaseArgs(options) {
+  const args2 = [];
+  if (options.cdp) {
+    args2.push("--cdp", options.cdp);
+  }
+  if (options.tab) {
+    args2.push("--tab", options.tab);
+  }
+  return args2;
+}
+function generateNonce() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function wrapUntrusted(content) {
+  const nonce = generateNonce();
+  const openTag = `<<untrusted-page-content id=${nonce}>>`;
+  const closeTag = `<<end id=${nonce}>>`;
+  const neutralised = content.replaceAll("<<untrusted-page-content", "< <untrusted-page-content");
+  return `${openTag}
+${neutralised}
+${closeTag}`;
+}
+async function runProcess(platform2, argv, stdin, timeoutMs) {
+  let proc;
+  try {
+    proc = await platform2.spawn({ argv });
+  } catch (err) {
+    const code2 = err.code;
+    if (code2 === "ENOENT" || code2 === "EACCES") {
+      return { stdout: "", stderr: `command not found: ${argv[0]}`, exitCode: -1 };
+    }
+    throw err;
+  }
+  if (stdin !== void 0) {
+    const writer = proc.stdin.getWriter();
+    await writer.write(new TextEncoder().encode(stdin));
+    await writer.close();
+  } else {
+    try {
+      await proc.stdin.getWriter().close();
+    } catch {
+    }
+  }
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  const readStream3 = async (stream, into) => {
+    const r = stream.getReader();
+    try {
+      for (; ; ) {
+        const { done, value } = await r.read();
+        if (done) break;
+        into.push(value);
+      }
+    } finally {
+      r.releaseLock();
+    }
+  };
+  const timer = new Promise(
+    (resolve) => setTimeout(() => resolve("timeout"), timeoutMs ?? 3e4)
+  );
+  const work = Promise.all([
+    readStream3(proc.stdout, stdoutChunks),
+    readStream3(proc.stderr, stderrChunks),
+    proc.wait()
+  ]);
+  const result = await Promise.race([work, timer]);
+  if (result === "timeout") {
+    await proc.kill("SIGTERM");
+    return { stdout: "", stderr: "timed out", exitCode: 124 };
+  }
+  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;
+  };
+  return {
+    stdout: dec.decode(concat2(stdoutChunks)),
+    stderr: dec.decode(concat2(stderrChunks)),
+    exitCode: exitResult.status
+  };
+}
+function createWebMcpHandler(platform2, options) {
+  let cache;
+  const baseArgs = buildBaseArgs(options);
+  async function listRaw() {
+    const now = Date.now();
+    if (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);
+    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}` };
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(result.stdout);
+    } catch {
+      return { tools: [], error: "webmcp-list returned invalid JSON" };
+    }
+    if (!Array.isArray(parsed)) {
+      return { tools: [], error: "webmcp-list did not return an array" };
+    }
+    const tools = parsed;
+    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) {
+      if (tool.annotations?.consequentialHint && !options.allowConsequential) {
+        continue;
+      }
+      const mapped = mapDescriptionAnnotations(tool.annotations);
+      rpcTools.push({
+        name: buildToolName(tool, needPrefix),
+        description: buildDescription(tool),
+        inputSchema: tool.inputSchema,
+        annotations: mapped
+      });
+    }
+    return rpcTools;
+  }
+  async function callTool(name, args2) {
+    const { tools, error } = await listRaw();
+    if (error) {
+      return { stdout: "", stderr: error, exitCode: 2 };
+    }
+    const needPrefix = originPrefix(tools);
+    const tool = tools.find((t) => buildToolName(t, needPrefix) === name);
+    if (!tool) {
+      return { stdout: "", stderr: `unknown tool: ${name}`, exitCode: 2 };
+    }
+    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);
+    if (result.exitCode === -1) {
+      throw new Error(result.stderr || "playwright-cli not found");
+    }
+    if (result.exitCode === 2) {
+      throw new Error(result.stderr || "webmcp-call error");
+    }
+    const meta = {
+      "io.mcpcat/untrusted": true,
+      origin: tool.origin
+    };
+    if (result.exitCode === 1) {
+      return {
+        stdout: "",
+        stderr: wrapUntrusted(result.stderr || result.stdout),
+        exitCode: 1,
+        meta
+      };
+    }
+    const text = wrapUntrusted(result.stdout);
+    return { stdout: text, stderr: result.stderr, exitCode: 0, meta };
+  }
+  function invalidateCache() {
+    cache = void 0;
+  }
+  return { getRpcTools, callTool, invalidateCache };
+}
+
 // src/serve/runtime.ts
 var CALL_TIMEOUT_MS = 12e4;
 var MAX_OUTPUT_DEFAULT = 1048576;
@@ -12137,6 +12371,10 @@ function parseSingleFlag(args2, i, opts) {
     opts.json = true;
   } else if (arg === "--no-auth") {
     opts.noAuth = true;
+  } else if (arg === "--webmcp") {
+    opts.webmcp = true;
+  } else if (arg === "--allow-consequential") {
+    opts.webmcpAllowConsequential = true;
   } else if (!arg.startsWith("-")) {
     opts.commands.push(parseCommandTarget(arg));
   } else {
@@ -12178,6 +12416,18 @@ function parseValueFlag(args2, i, opts) {
     case "--cwd":
       opts.cwd = args2[++i];
       break;
+    case "--tab":
+      opts.webmcpTab = args2[++i];
+      break;
+    case "--webmcp-ttl":
+      opts.webmcpTtl = Number(args2[++i]) * 1e3;
+      break;
+    case "--playwright-cli":
+      opts.webmcpPlaywrightCli = args2[++i];
+      break;
+    case "--cdp":
+      opts.webmcpCdp = args2[++i];
+      break;
     case "-H":
     case "--header": {
       const hdr = args2[++i];
@@ -12210,7 +12460,13 @@ function parseServeFlags(args2) {
     json: false,
     commands: [],
     proxy: void 0,
-    proxyHeaders: []
+    proxyHeaders: [],
+    webmcp: false,
+    webmcpTab: void 0,
+    webmcpTtl: 5e3,
+    webmcpAllowConsequential: false,
+    webmcpPlaywrightCli: void 0,
+    webmcpCdp: void 0
   };
   for (let i = 0; i < args2.length; i++) {
     i = parseSingleFlag(args2, i, opts);
@@ -12592,25 +12848,25 @@ async function discoverWithSignal(platform2, commands, childEnv, cwd) {
   if (earlyShutdown) return { exitCode: 143, inflightDone };
   return { clis };
 }
-async function runServe(platform2, options, version) {
-  let resolvedBearer;
-  let generatedBearer = false;
+async function resolveBearer(platform2, options) {
   if (options._resolvedBearer) {
-    resolvedBearer = options._resolvedBearer;
-  } else if (options.bearer) {
+    return { resolved: options._resolvedBearer, generated: false };
+  }
+  if (options.bearer) {
     const expanded = expandBearerToken(options.bearer, platform2.env);
     if (!expanded) {
       await platform2.write(
         2,
         "mcpcat serve: --bearer requires a ${NAME} variable reference, not a literal token. Use --bearer '${MY_TOKEN}' and set MY_TOKEN in the environment.\n"
       );
-      return 2;
+      return { exitCode: 2 };
     }
-    resolvedBearer = expanded;
-  } else if (options.noAuth) {
+    return { resolved: expanded, generated: false };
+  }
+  if (options.noAuth) {
     if (options.transport === "http" && !isLoopbackBind(options.host)) {
       await platform2.write(2, "mcpcat serve: --no-auth is only allowed on loopback\n");
-      return 2;
+      return { exitCode: 2 };
     }
     if (options.transport === "http") {
       await platform2.write(
@@ -12618,21 +12874,30 @@ async function runServe(platform2, options, version) {
         "mcpcat serve: warning: running without authentication on loopback\n"
       );
     }
-    resolvedBearer = void 0;
-  } else if (options.transport === "http") {
+    return { resolved: void 0, generated: false };
+  }
+  if (options.transport === "http") {
     if (platform2.kind === "kernel") {
       await platform2.write(
         2,
         "mcpcat serve: kernel HTTP serve requires --bearer '${VAR}' or --no-auth\n"
       );
-      return 2;
+      return { exitCode: 2 };
     }
-    resolvedBearer = generateToken();
-    generatedBearer = true;
+    return { resolved: generateToken(), generated: true };
   }
+  return { resolved: void 0, generated: false };
+}
+async function runServe(platform2, options, version) {
+  const bearerResult = await resolveBearer(platform2, options);
+  if ("exitCode" in bearerResult) return bearerResult.exitCode;
+  const { resolved: resolvedBearer, generated: generatedBearer } = bearerResult;
   if (options.proxy) {
     return runProxyServe(platform2, options, version, resolvedBearer, generatedBearer);
   }
+  if (options.webmcp) {
+    return runWebMcpServe(platform2, options, version, resolvedBearer, generatedBearer);
+  }
   const serveCwd = options.cwd ?? platform2.cwd;
   const childEnv = buildChildEnv(platform2, options.envAllow);
   const discovery = await discoverWithSignal(platform2, options.commands, childEnv, serveCwd);
@@ -12766,6 +13031,233 @@ async function buildProxyConnectOpts(platform2, options, version) {
   }
   return { connectOpts, hiddenValues };
 }
+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)) {
+    if (!dir) continue;
+    return "playwright-cli";
+  }
+  return void 0;
+}
+async function runWebMcpServe(platform2, options, version, resolvedBearer, generatedBearer) {
+  const cliPath = 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"
+    );
+    return 3;
+  }
+  const cdp = options.webmcpCdp ?? platform2.env.SLICC_CDP_URL;
+  const handler = createWebMcpHandler(platform2, {
+    playwrightCli: cliPath,
+    tab: options.webmcpTab,
+    cdp,
+    allowConsequential: options.webmcpAllowConsequential,
+    ttlMs: options.webmcpTtl,
+    callTimeoutMs: options.callTimeout,
+    maxOutput: options.maxOutput
+  });
+  const probe = await handler.getRpcTools();
+  if (probe === null) {
+    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;
+  }
+  const serverName = "mcpcat-webmcp";
+  const getTools = async () => await handler.getRpcTools() ?? [];
+  const callTool = (name, args2) => handler.callTool(name, args2);
+  if (options.transport === "stdio") {
+    return runWebMcpStdio(platform2, getTools, callTool, serverName, version);
+  }
+  return runWebMcpHttp(
+    platform2,
+    options,
+    getTools,
+    callTool,
+    serverName,
+    version,
+    resolvedBearer,
+    generatedBearer
+  );
+}
+async function runWebMcpStdio(platform2, getTools, callTool, serverName, version) {
+  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 tools = await getTools();
+        const outcome = await handleJsonRpc(line, tools, callTool, serverName, version);
+        if (outcome.status === 202) continue;
+        const writer = platform2.stdout.getWriter();
+        await writer.write(enc.encode(`${outcome.body}
+`));
+        writer.releaseLock();
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return 0;
+}
+async function runWebMcpHttp(platform2, options, getTools, callTool, serverName, version, resolvedBearer, generatedBearer) {
+  if (!platform2.listen) {
+    await platform2.write(2, "mcpcat serve --webmcp: HTTP transport requires platform.listen\n");
+    return 3;
+  }
+  const boundLoopback = isLoopbackBind(options.host);
+  if (!boundLoopback && !resolvedBearer) {
+    await platform2.write(
+      2,
+      "mcpcat serve --webmcp: --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 serverOrigins = buildServerOrigins(options.host, actualPort);
+  const allowedHosts = buildAllowedHosts(options.host, actualPort, options.allowHosts);
+  const listenUrl = `http://${options.host}:${actualPort}/mcp`;
+  let tokenFilePath;
+  if (generatedBearer && resolvedBearer) {
+    tokenFilePath = await publishBearer(
+      platform2,
+      resolvedBearer,
+      actualPort,
+      listenUrl,
+      options.json
+    );
+  } else {
+    if (options.json) {
+      await platform2.write(1, `${JSON.stringify({ url: listenUrl })}
+`);
+    }
+  }
+  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 (platform2.onSignal) {
+    platform2.onSignal("SIGINT", shutdown);
+    platform2.onSignal("SIGTERM", shutdown);
+    platform2.onSignal("SIGHUP", shutdown);
+  }
+  const handler = async (request) => {
+    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"
+      };
+    }
+    if (!checkContentType(request.headers["content-type"])) {
+      return {
+        status: 415,
+        reason: "Unsupported Media Type",
+        headers: { "content-type": "text/plain" },
+        body: "Content-Type must be application/json"
+      };
+    }
+    if (!checkAcceptHeader(request.headers.accept)) {
+      return {
+        status: 406,
+        reason: "Not Acceptable",
+        headers: { "content-type": "text/plain" },
+        body: "Accept must include application/json or text/event-stream"
+      };
+    }
+    const originCheck = checkOrigin(request.headers.origin, serverOrigins, allowedOrigins);
+    if (!originCheck.ok) {
+      return {
+        status: 403,
+        reason: "Forbidden",
+        headers: { "content-type": "text/plain" },
+        body: originCheck.reason ?? "Forbidden"
+      };
+    }
+    const hostCheck = checkHost(request.headers.host, allowedHosts);
+    if (!hostCheck.ok) {
+      return {
+        status: 403,
+        reason: "Forbidden",
+        headers: { "content-type": "text/plain" },
+        body: hostCheck.reason ?? "Forbidden"
+      };
+    }
+    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 tools = await getTools();
+    const outcome = await handleJsonRpc(request.body, tools, callTool, serverName, version);
+    return {
+      status: outcome.status,
+      reason: outcome.status === 200 ? "OK" : "Accepted",
+      headers: { "content-type": outcome.contentType },
+      body: outcome.body
+    };
+  };
+  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 runProxyServe(platform2, options, version, resolvedBearer, generatedBearer) {
   const built = await buildProxyConnectOpts(platform2, options, version);
   if ("error" in built) {
@@ -13977,7 +14469,10 @@ async function sealSecret(platform2, name, value, options) {
   }
   const response = JSON.parse(responseText);
   if (response.error) {
-    throw Object.assign(new Error(response.error), { sealErrno: response.errno ?? "EACCES" });
+    const isStructured = typeof response.error === "object" && response.error !== null && response.error.code;
+    const errno = isStructured ? response.error.code : response.errno ?? "EACCES";
+    const message = isStructured ? response.error.message : response.error;
+    throw Object.assign(new Error(String(message)), { sealErrno: errno });
   }
   return { placeholder: response.placeholder };
 }
@@ -13989,6 +14484,7 @@ function sealErrorMessage(errno, name) {
   if (errno === "EEXIST") return `a non-bridge secret named ${name} already exists`;
   if (errno === "ENOTCONN") return "no vault available; use --bearer '${VAR}' or --no-auth";
   if (errno === "EACCES") return "vault locked; use --bearer '${VAR}' or --no-auth";
+  if (errno === "ETIMEDOUT") return "vault did not respond in time";
   return `vault error: ${errno}`;
 }
 
@@ -15344,7 +15840,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.proxy && serveOptions.commands.length === 0 && serveOptions.toolTemplates.length === 0) {
+  if (!serveOptions.proxy && !serveOptions.webmcp && serveOptions.commands.length === 0 && serveOptions.toolTemplates.length === 0) {
     await platform2.write(2, "mcpcat serve: no commands or --tool templates given\n");
     return 2;
   }
@@ -15616,6 +16112,9 @@ function classifyError(err) {
   if (err instanceof InputRequiredError) {
     return { code: EXIT_INPUT_REQUIRED, kind: "input_required", msg: err.requestJson };
   }
+  if (err instanceof TransportRefusalError) {
+    return { code: EXIT_CONNECTION, kind: "connection", msg: err.reason };
+  }
   if (err instanceof McpTimeoutError2) {
     return { code: EXIT_TIMEOUT, kind: "timeout", msg: err.message };
   }
@@ -15672,6 +16171,14 @@ async function resolveAuthProvider(platform2, hasAuthHeader, url, target, config
   return { provider, credentialSecrets };
 }
 function classifyConnectionError(err, target, interrupted) {
+  if (err instanceof TransportRefusalError) {
+    const hint = "in seven, reach the host via http://host.slicc.internal:<port>; in tests, enable the transport's hostLoopback";
+    return {
+      code: EXIT_CONNECTION,
+      kind: "connection",
+      msg: `${err.reason} (${hint})`
+    };
+  }
   if (err instanceof McpAuthError || err instanceof AuthStepUpError || err instanceof JerkSignInRequiredError) {
     return classifyError(err);
   }
@@ -16177,5 +16684,5 @@ try {
   });
 } catch {
 }
-var code = await run(platform, "0.14.7", args);
+var code = await run(platform, "0.15.1", args);
 process.exit(code);

package/dist/kernel/mcpcat.mjs

@@ -7964,6 +7964,16 @@ var McpAuthError = class extends Error {
     this.target = target;
   }
 };
+var TransportRefusalError = class extends Error {
+  status;
+  reason;
+  constructor(status, reason) {
+    super(reason);
+    this.name = "TransportRefusalError";
+    this.status = status;
+    this.reason = reason;
+  }
+};
 var AuthRetryableError = class extends Error {
   response;
   constructor(response) {
@@ -8106,6 +8116,15 @@ 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) && authProvider)
       throw new AuthRetryableError(res);
     if (res.status === 401 || res.status === 403) throw new McpAuthError(res.status, url);
@@ -8639,6 +8658,7 @@ async function connect(platform2, options) {
     const isMethodNotFound = err instanceof StatelessRpcError && err.code === -32601 || err instanceof StatelessHttpError && err.status >= 400 && err.status < 500;
     if (options.protocolVersion?.startsWith("2026")) throw err;
     if (err instanceof McpAuthError || err instanceof AuthStepUpError) throw err;
+    if (err instanceof TransportRefusalError) throw err;
     if (err.name === "McpOAuthAuthorizationRequiredError") throw err;
     if (isMethodNotFound) {
       return createPiConnection({
@@ -11424,7 +11444,8 @@ ${stderr}` : stderr : stdout;
   return {
     content: [{ type: "text", text }],
     isError: result.exitCode !== 0,
-    structuredContent: { stdout, stderr, exitCode: result.exitCode }
+    structuredContent: { stdout, stderr, exitCode: result.exitCode },
+    ...result.meta ? { _meta: result.meta } : {}
   };
 }
 function initializeResult(params, serverName, serverVersion) {
@@ -11724,6 +11745,219 @@ function createProxyHandler(options) {
   return { handle, shutdown };
 }
 
+// src/serve/webmcp.ts
+function buildBaseArgs(options) {
+  const args = [];
+  if (options.cdp) {
+    args.push("--cdp", options.cdp);
+  }
+  if (options.tab) {
+    args.push("--tab", options.tab);
+  }
+  return args;
+}
+function generateNonce() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function wrapUntrusted(content) {
+  const nonce = generateNonce();
+  const openTag = `<<untrusted-page-content id=${nonce}>>`;
+  const closeTag = `<<end id=${nonce}>>`;
+  const neutralised = content.replaceAll("<<untrusted-page-content", "< <untrusted-page-content");
+  return `${openTag}
+${neutralised}
+${closeTag}`;
+}
+async function runProcess(platform2, argv, stdin, timeoutMs) {
+  let proc;
+  try {
+    proc = await platform2.spawn({ argv });
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "EACCES") {
+      return { stdout: "", stderr: `command not found: ${argv[0]}`, exitCode: -1 };
+    }
+    throw err;
+  }
+  if (stdin !== void 0) {
+    const writer = proc.stdin.getWriter();
+    await writer.write(new TextEncoder().encode(stdin));
+    await writer.close();
+  } else {
+    try {
+      await proc.stdin.getWriter().close();
+    } catch {
+    }
+  }
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  const readStream3 = async (stream, into) => {
+    const r = stream.getReader();
+    try {
+      for (; ; ) {
+        const { done, value } = await r.read();
+        if (done) break;
+        into.push(value);
+      }
+    } finally {
+      r.releaseLock();
+    }
+  };
+  const timer = new Promise(
+    (resolve2) => setTimeout(() => resolve2("timeout"), timeoutMs ?? 3e4)
+  );
+  const work = Promise.all([
+    readStream3(proc.stdout, stdoutChunks),
+    readStream3(proc.stderr, stderrChunks),
+    proc.wait()
+  ]);
+  const result = await Promise.race([work, timer]);
+  if (result === "timeout") {
+    await proc.kill("SIGTERM");
+    return { stdout: "", stderr: "timed out", exitCode: 124 };
+  }
+  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;
+  };
+  return {
+    stdout: dec.decode(concat2(stdoutChunks)),
+    stderr: dec.decode(concat2(stderrChunks)),
+    exitCode: exitResult.status
+  };
+}
+function createWebMcpHandler(platform2, options) {
+  let cache;
+  const baseArgs = buildBaseArgs(options);
+  async function listRaw() {
+    const now = Date.now();
+    if (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);
+    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}` };
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(result.stdout);
+    } catch {
+      return { tools: [], error: "webmcp-list returned invalid JSON" };
+    }
+    if (!Array.isArray(parsed)) {
+      return { tools: [], error: "webmcp-list did not return an array" };
+    }
+    const tools = parsed;
+    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) {
+      if (tool.annotations?.consequentialHint && !options.allowConsequential) {
+        continue;
+      }
+      const mapped = mapDescriptionAnnotations(tool.annotations);
+      rpcTools.push({
+        name: buildToolName(tool, needPrefix),
+        description: buildDescription(tool),
+        inputSchema: tool.inputSchema,
+        annotations: mapped
+      });
+    }
+    return rpcTools;
+  }
+  async function callTool(name, args) {
+    const { tools, error } = await listRaw();
+    if (error) {
+      return { stdout: "", stderr: error, exitCode: 2 };
+    }
+    const needPrefix = originPrefix(tools);
+    const tool = tools.find((t) => buildToolName(t, needPrefix) === name);
+    if (!tool) {
+      return { stdout: "", stderr: `unknown tool: ${name}`, exitCode: 2 };
+    }
+    const argv = [options.playwrightCli, "webmcp-call", tool.name, "-", ...baseArgs];
+    if (options.allowConsequential) {
+      argv.push("--allow-consequential");
+    }
+    const stdinData = JSON.stringify(args ?? {});
+    const result = await runProcess(platform2, argv, stdinData, options.callTimeoutMs);
+    if (result.exitCode === -1) {
+      throw new Error(result.stderr || "playwright-cli not found");
+    }
+    if (result.exitCode === 2) {
+      throw new Error(result.stderr || "webmcp-call error");
+    }
+    const meta = {
+      "io.mcpcat/untrusted": true,
+      origin: tool.origin
+    };
+    if (result.exitCode === 1) {
+      return {
+        stdout: "",
+        stderr: wrapUntrusted(result.stderr || result.stdout),
+        exitCode: 1,
+        meta
+      };
+    }
+    const text = wrapUntrusted(result.stdout);
+    return { stdout: text, stderr: result.stderr, exitCode: 0, meta };
+  }
+  function invalidateCache() {
+    cache = void 0;
+  }
+  return { getRpcTools, callTool, invalidateCache };
+}
+
 // src/serve/runtime.ts
 var CALL_TIMEOUT_MS = 12e4;
 var MAX_OUTPUT_DEFAULT = 1048576;
@@ -11758,6 +11992,10 @@ function parseSingleFlag(args, i, opts) {
     opts.json = true;
   } else if (arg === "--no-auth") {
     opts.noAuth = true;
+  } else if (arg === "--webmcp") {
+    opts.webmcp = true;
+  } else if (arg === "--allow-consequential") {
+    opts.webmcpAllowConsequential = true;
   } else if (!arg.startsWith("-")) {
     opts.commands.push(parseCommandTarget(arg));
   } else {
@@ -11799,6 +12037,18 @@ function parseValueFlag(args, i, opts) {
     case "--cwd":
       opts.cwd = args[++i];
       break;
+    case "--tab":
+      opts.webmcpTab = args[++i];
+      break;
+    case "--webmcp-ttl":
+      opts.webmcpTtl = Number(args[++i]) * 1e3;
+      break;
+    case "--playwright-cli":
+      opts.webmcpPlaywrightCli = args[++i];
+      break;
+    case "--cdp":
+      opts.webmcpCdp = args[++i];
+      break;
     case "-H":
     case "--header": {
       const hdr = args[++i];
@@ -11831,7 +12081,13 @@ function parseServeFlags(args) {
     json: false,
     commands: [],
     proxy: void 0,
-    proxyHeaders: []
+    proxyHeaders: [],
+    webmcp: false,
+    webmcpTab: void 0,
+    webmcpTtl: 5e3,
+    webmcpAllowConsequential: false,
+    webmcpPlaywrightCli: void 0,
+    webmcpCdp: void 0
   };
   for (let i = 0; i < args.length; i++) {
     i = parseSingleFlag(args, i, opts);
@@ -12213,25 +12469,25 @@ async function discoverWithSignal(platform2, commands, childEnv, cwd) {
   if (earlyShutdown) return { exitCode: 143, inflightDone };
   return { clis };
 }
-async function runServe(platform2, options, version) {
-  let resolvedBearer;
-  let generatedBearer = false;
+async function resolveBearer(platform2, options) {
   if (options._resolvedBearer) {
-    resolvedBearer = options._resolvedBearer;
-  } else if (options.bearer) {
+    return { resolved: options._resolvedBearer, generated: false };
+  }
+  if (options.bearer) {
     const expanded = expandBearerToken(options.bearer, platform2.env);
     if (!expanded) {
       await platform2.write(
         2,
         "mcpcat serve: --bearer requires a ${NAME} variable reference, not a literal token. Use --bearer '${MY_TOKEN}' and set MY_TOKEN in the environment.\n"
       );
-      return 2;
+      return { exitCode: 2 };
     }
-    resolvedBearer = expanded;
-  } else if (options.noAuth) {
+    return { resolved: expanded, generated: false };
+  }
+  if (options.noAuth) {
     if (options.transport === "http" && !isLoopbackBind(options.host)) {
       await platform2.write(2, "mcpcat serve: --no-auth is only allowed on loopback\n");
-      return 2;
+      return { exitCode: 2 };
     }
     if (options.transport === "http") {
       await platform2.write(
@@ -12239,21 +12495,30 @@ async function runServe(platform2, options, version) {
         "mcpcat serve: warning: running without authentication on loopback\n"
       );
     }
-    resolvedBearer = void 0;
-  } else if (options.transport === "http") {
+    return { resolved: void 0, generated: false };
+  }
+  if (options.transport === "http") {
     if (platform2.kind === "kernel") {
       await platform2.write(
         2,
         "mcpcat serve: kernel HTTP serve requires --bearer '${VAR}' or --no-auth\n"
       );
-      return 2;
+      return { exitCode: 2 };
     }
-    resolvedBearer = generateToken();
-    generatedBearer = true;
+    return { resolved: generateToken(), generated: true };
   }
+  return { resolved: void 0, generated: false };
+}
+async function runServe(platform2, options, version) {
+  const bearerResult = await resolveBearer(platform2, options);
+  if ("exitCode" in bearerResult) return bearerResult.exitCode;
+  const { resolved: resolvedBearer, generated: generatedBearer } = bearerResult;
   if (options.proxy) {
     return runProxyServe(platform2, options, version, resolvedBearer, generatedBearer);
   }
+  if (options.webmcp) {
+    return runWebMcpServe(platform2, options, version, resolvedBearer, generatedBearer);
+  }
   const serveCwd = options.cwd ?? platform2.cwd;
   const childEnv = buildChildEnv(platform2, options.envAllow);
   const discovery = await discoverWithSignal(platform2, options.commands, childEnv, serveCwd);
@@ -12387,6 +12652,233 @@ async function buildProxyConnectOpts(platform2, options, version) {
   }
   return { connectOpts, hiddenValues };
 }
+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)) {
+    if (!dir) continue;
+    return "playwright-cli";
+  }
+  return void 0;
+}
+async function runWebMcpServe(platform2, options, version, resolvedBearer, generatedBearer) {
+  const cliPath = 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"
+    );
+    return 3;
+  }
+  const cdp = options.webmcpCdp ?? platform2.env.SLICC_CDP_URL;
+  const handler = createWebMcpHandler(platform2, {
+    playwrightCli: cliPath,
+    tab: options.webmcpTab,
+    cdp,
+    allowConsequential: options.webmcpAllowConsequential,
+    ttlMs: options.webmcpTtl,
+    callTimeoutMs: options.callTimeout,
+    maxOutput: options.maxOutput
+  });
+  const probe = await handler.getRpcTools();
+  if (probe === null) {
+    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;
+  }
+  const serverName = "mcpcat-webmcp";
+  const getTools = async () => await handler.getRpcTools() ?? [];
+  const callTool = (name, args) => handler.callTool(name, args);
+  if (options.transport === "stdio") {
+    return runWebMcpStdio(platform2, getTools, callTool, serverName, version);
+  }
+  return runWebMcpHttp(
+    platform2,
+    options,
+    getTools,
+    callTool,
+    serverName,
+    version,
+    resolvedBearer,
+    generatedBearer
+  );
+}
+async function runWebMcpStdio(platform2, getTools, callTool, serverName, version) {
+  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 tools = await getTools();
+        const outcome = await handleJsonRpc(line, tools, callTool, serverName, version);
+        if (outcome.status === 202) continue;
+        const writer = platform2.stdout.getWriter();
+        await writer.write(enc.encode(`${outcome.body}
+`));
+        writer.releaseLock();
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return 0;
+}
+async function runWebMcpHttp(platform2, options, getTools, callTool, serverName, version, resolvedBearer, generatedBearer) {
+  if (!platform2.listen) {
+    await platform2.write(2, "mcpcat serve --webmcp: HTTP transport requires platform.listen\n");
+    return 3;
+  }
+  const boundLoopback = isLoopbackBind(options.host);
+  if (!boundLoopback && !resolvedBearer) {
+    await platform2.write(
+      2,
+      "mcpcat serve --webmcp: --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 serverOrigins = buildServerOrigins(options.host, actualPort);
+  const allowedHosts = buildAllowedHosts(options.host, actualPort, options.allowHosts);
+  const listenUrl = `http://${options.host}:${actualPort}/mcp`;
+  let tokenFilePath;
+  if (generatedBearer && resolvedBearer) {
+    tokenFilePath = await publishBearer(
+      platform2,
+      resolvedBearer,
+      actualPort,
+      listenUrl,
+      options.json
+    );
+  } else {
+    if (options.json) {
+      await platform2.write(1, `${JSON.stringify({ url: listenUrl })}
+`);
+    }
+  }
+  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 (platform2.onSignal) {
+    platform2.onSignal("SIGINT", shutdown);
+    platform2.onSignal("SIGTERM", shutdown);
+    platform2.onSignal("SIGHUP", shutdown);
+  }
+  const handler = async (request) => {
+    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"
+      };
+    }
+    if (!checkContentType(request.headers["content-type"])) {
+      return {
+        status: 415,
+        reason: "Unsupported Media Type",
+        headers: { "content-type": "text/plain" },
+        body: "Content-Type must be application/json"
+      };
+    }
+    if (!checkAcceptHeader(request.headers.accept)) {
+      return {
+        status: 406,
+        reason: "Not Acceptable",
+        headers: { "content-type": "text/plain" },
+        body: "Accept must include application/json or text/event-stream"
+      };
+    }
+    const originCheck = checkOrigin(request.headers.origin, serverOrigins, allowedOrigins);
+    if (!originCheck.ok) {
+      return {
+        status: 403,
+        reason: "Forbidden",
+        headers: { "content-type": "text/plain" },
+        body: originCheck.reason ?? "Forbidden"
+      };
+    }
+    const hostCheck = checkHost(request.headers.host, allowedHosts);
+    if (!hostCheck.ok) {
+      return {
+        status: 403,
+        reason: "Forbidden",
+        headers: { "content-type": "text/plain" },
+        body: hostCheck.reason ?? "Forbidden"
+      };
+    }
+    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 tools = await getTools();
+    const outcome = await handleJsonRpc(request.body, tools, callTool, serverName, version);
+    return {
+      status: outcome.status,
+      reason: outcome.status === 200 ? "OK" : "Accepted",
+      headers: { "content-type": outcome.contentType },
+      body: outcome.body
+    };
+  };
+  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 runProxyServe(platform2, options, version, resolvedBearer, generatedBearer) {
   const built = await buildProxyConnectOpts(platform2, options, version);
   if ("error" in built) {
@@ -13598,7 +14090,10 @@ async function sealSecret(platform2, name, value, options) {
   }
   const response = JSON.parse(responseText);
   if (response.error) {
-    throw Object.assign(new Error(response.error), { sealErrno: response.errno ?? "EACCES" });
+    const isStructured = typeof response.error === "object" && response.error !== null && response.error.code;
+    const errno = isStructured ? response.error.code : response.errno ?? "EACCES";
+    const message = isStructured ? response.error.message : response.error;
+    throw Object.assign(new Error(String(message)), { sealErrno: errno });
   }
   return { placeholder: response.placeholder };
 }
@@ -13610,6 +14105,7 @@ function sealErrorMessage(errno, name) {
   if (errno === "EEXIST") return `a non-bridge secret named ${name} already exists`;
   if (errno === "ENOTCONN") return "no vault available; use --bearer '${VAR}' or --no-auth";
   if (errno === "EACCES") return "vault locked; use --bearer '${VAR}' or --no-auth";
+  if (errno === "ETIMEDOUT") return "vault did not respond in time";
   return `vault error: ${errno}`;
 }
 
@@ -14965,7 +15461,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.proxy && serveOptions.commands.length === 0 && serveOptions.toolTemplates.length === 0) {
+  if (!serveOptions.proxy && !serveOptions.webmcp && serveOptions.commands.length === 0 && serveOptions.toolTemplates.length === 0) {
     await platform2.write(2, "mcpcat serve: no commands or --tool templates given\n");
     return 2;
   }
@@ -15237,6 +15733,9 @@ function classifyError(err) {
   if (err instanceof InputRequiredError) {
     return { code: EXIT_INPUT_REQUIRED, kind: "input_required", msg: err.requestJson };
   }
+  if (err instanceof TransportRefusalError) {
+    return { code: EXIT_CONNECTION, kind: "connection", msg: err.reason };
+  }
   if (err instanceof McpTimeoutError2) {
     return { code: EXIT_TIMEOUT, kind: "timeout", msg: err.message };
   }
@@ -15293,6 +15792,14 @@ async function resolveAuthProvider(platform2, hasAuthHeader, url, target, config
   return { provider, credentialSecrets };
 }
 function classifyConnectionError(err, target, interrupted) {
+  if (err instanceof TransportRefusalError) {
+    const hint = "in seven, reach the host via http://host.slicc.internal:<port>; in tests, enable the transport's hostLoopback";
+    return {
+      code: EXIT_CONNECTION,
+      kind: "connection",
+      msg: `${err.reason} (${hint})`
+    };
+  }
   if (err instanceof McpAuthError || err instanceof AuthStepUpError || err instanceof JerkSignInRequiredError) {
     return classifyError(err);
   }
@@ -15841,7 +16348,7 @@ async function main(ctx) {
     packageDir: "/node_modules/@ai-ecoverse/mcpcat"
   });
   const args = ctx.argv.slice(1);
-  return run(platform2, "0.14.7", args);
+  return run(platform2, "0.15.1", args);
 }
 export {
   main as default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/mcpcat",
-  "version": "0.14.7",
+  "version": "0.15.1",
   "description": "A curl for the Model Context Protocol",
   "type": "module",
   "license": "Apache-2.0",
@@ -56,7 +56,7 @@
     "trust:dry": "npx fledgling sync --dry-run -y --skip-publish"
   },
   "devDependencies": {
-    "@ai-ecoverse/slicc-kernel": "1.83.0",
+    "@ai-ecoverse/slicc-kernel": "1.85.0",
     "@ai-ecoverse/slicc-shared-web": "1.13.1",
     "@biomejs/biome": "2.5.15",
     "@earendil-works/pi-codemode": "1.2.0",