@ai-ecoverse/mcpcat 0.12.0 → 0.13.0

package/dist/kernel/mcpcat.mjs

@@ -48,9 +48,11 @@ __export(node_stub_exports, {
   readFile: () => readFile,
   rename: () => rename,
   resolve: () => resolve,
+  rmdir: () => rmdir,
   spawn: () => spawn,
   stat: () => stat,
   tmpdir: () => tmpdir,
+  unlink: () => unlink,
   workerData: () => workerData,
   writeFile: () => writeFile
 });
@@ -78,6 +80,12 @@ function rename() {
 function stat() {
   throw new Error("not available in kernel");
 }
+function rmdir() {
+  throw new Error("not available in kernel");
+}
+function unlink() {
+  throw new Error("not available in kernel");
+}
 function isatty() {
   return false;
 }
@@ -5957,6 +5965,133 @@ var McpOAuthProvider = class {
   }
 };
 
+// src/auth/jerk-token-source.ts
+var MIN_VERSION = [0, 13, 0];
+var VERSION_TIMEOUT_MS = 2e3;
+var cachedAvailable;
+function parseVersion(raw) {
+  const match = raw.trim().match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return void 0;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function versionSatisfied(actual) {
+  for (let i = 0; i < 3; i++) {
+    if (actual[i] > MIN_VERSION[i]) return true;
+    if (actual[i] < MIN_VERSION[i]) return false;
+  }
+  return true;
+}
+async function readAll(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  const total = chunks.reduce((s, c) => s + c.length, 0);
+  const buf = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    buf.set(c, off);
+    off += c.length;
+  }
+  return new TextDecoder().decode(buf);
+}
+async function jerkOnPath(platform2) {
+  const pathVar = platform2.env.PATH ?? platform2.env.Path ?? "";
+  const sep = pathVar.includes(";") ? ";" : ":";
+  const dirs = pathVar.split(sep).filter(Boolean);
+  for (const dir of dirs) {
+    if (await platform2.fs.exists(`${dir}/jerk`)) return true;
+  }
+  return false;
+}
+async function jerkAvailable(platform2) {
+  if (cachedAvailable !== void 0) return cachedAvailable;
+  if (!await jerkOnPath(platform2)) {
+    cachedAvailable = false;
+    return false;
+  }
+  try {
+    const proc = await platform2.spawn({ argv: ["jerk", "--version"] });
+    const timeout = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("timeout")), VERSION_TIMEOUT_MS);
+    });
+    const work = Promise.all([readAll(proc.stdout), proc.wait()]).then(([out, result]) => {
+      proc.stderr.cancel().catch(() => {
+      });
+      if (result.status !== 0) return false;
+      const ver = parseVersion(out);
+      return ver !== void 0 && versionSatisfied(ver);
+    });
+    cachedAvailable = await Promise.race([work, timeout]);
+  } catch {
+    cachedAvailable = false;
+  }
+  return cachedAvailable;
+}
+function jerkId(name) {
+  if (name.startsWith("mcp:")) return name;
+  if (name.startsWith("url:")) return `mcp:${name}`;
+  return `mcp:${name}`;
+}
+var JERK_EXIT_SIGN_IN = 3;
+var JERK_EXIT_UNAVAILABLE = 4;
+var JerkSignInRequiredError = class extends Error {
+  id;
+  scope;
+  constructor(id, scope) {
+    const scopeHint = scope ? ` --scope ${scope}` : "";
+    super(`sign-in required. Run: jerk ${id} create${scopeHint}`);
+    this.name = "JerkSignInRequiredError";
+    this.id = id;
+    this.scope = scope;
+  }
+};
+var JerkTokenSource = class {
+  platform;
+  constructor(platform2) {
+    this.platform = platform2;
+  }
+  async getToken(name, serverUrl, scope) {
+    const id = jerkId(name);
+    const argv = ["jerk", id, "get", "--reveal", "--json"];
+    if (scope) {
+      argv.push("--scope", scope);
+    }
+    const proc = await this.platform.spawn({ argv });
+    const [outRaw, , result] = await Promise.all([
+      readAll(proc.stdout),
+      readAll(proc.stderr),
+      proc.wait()
+    ]);
+    if (result.status === JERK_EXIT_SIGN_IN) {
+      throw new JerkSignInRequiredError(id, scope);
+    }
+    if (result.status === JERK_EXIT_UNAVAILABLE) {
+      return void 0;
+    }
+    if (result.status !== 0) {
+      return void 0;
+    }
+    const parsed = JSON.parse(outRaw.trim());
+    if (!parsed.token) return void 0;
+    return {
+      accessToken: parsed.token,
+      expiresAt: parsed.expires_at
+    };
+  }
+  async load(_name, _serverUrl) {
+    return void 0;
+  }
+  async save(_name, _serverUrl, _state) {
+  }
+  async remove(_name, _serverUrl) {
+    return false;
+  }
+};
+
 // src/auth/auth-provider.ts
 var CIMD_URL = "https://mcpcat.sliccy.ai/oauth/client.json";
 var CLIENT_NAME = "mcpcat";
@@ -6009,6 +6144,47 @@ var AuthStepUpError = class extends Error {
   }
 };
 function createMcpAuthProvider(options) {
+  if (options.source instanceof JerkTokenSource) {
+    return createJerkAuthProvider({ ...options, source: options.source });
+  }
+  return createPiAuthProvider(options);
+}
+function createJerkAuthProvider(options) {
+  const { name, serverUrl, source } = options;
+  let currentToken;
+  return {
+    async token() {
+      const result = await source.getToken(name, serverUrl);
+      currentToken = result?.accessToken;
+      return currentToken;
+    },
+    async onUnauthorized(context) {
+      const challenge = parseWwwAuthenticate(context.response.headers.get("www-authenticate"));
+      if (challenge.error === "insufficient_scope") {
+        try {
+          const result2 = await source.getToken(name, serverUrl, challenge.scope);
+          if (result2) {
+            currentToken = result2.accessToken;
+            return;
+          }
+        } catch (err) {
+          if (err instanceof JerkSignInRequiredError) {
+            throw new AuthStepUpError(challenge.scope, options.name);
+          }
+          throw err;
+        }
+        throw new AuthStepUpError(challenge.scope, options.name);
+      }
+      const result = await source.getToken(name, serverUrl);
+      if (result) {
+        currentToken = result.accessToken;
+        return;
+      }
+      throw new McpOAuthAuthorizationRequiredError();
+    }
+  };
+}
+function createPiAuthProvider(options) {
   const { name, serverUrl, source, oauth, platform: platform2 } = options;
   const store = new SourceBackedStore(source, name, serverUrl);
   let refreshing;
@@ -7454,6 +7630,53 @@ function buildServerInfo(discoverResult2) {
     instructions: discoverResult2?.instructions
   };
 }
+function buildStatelessMethods(requestFn, discoverResult2) {
+  let serverInfoCache;
+  return {
+    async info() {
+      if (serverInfoCache) return serverInfoCache;
+      serverInfoCache = buildServerInfo(discoverResult2);
+      return serverInfoCache;
+    },
+    async listTools() {
+      return (await requestFn("tools/list", {}))?.tools ?? [];
+    },
+    async callTool(name, args, _callOptions) {
+      const params = {
+        name,
+        arguments: args ?? {}
+      };
+      if (_callOptions?.inputResponses) {
+        params._inputResponses = _callOptions.inputResponses;
+      }
+      const result = await requestFn("tools/call", params);
+      if ((result.resultType ?? "complete") === "input_required") {
+        throw new InputRequiredError(
+          JSON.stringify({ name, arguments: args ?? {}, result }, null, 2)
+        );
+      }
+      return result;
+    },
+    async listResources() {
+      return (await requestFn("resources/list", {}))?.resources ?? [];
+    },
+    async listResourceTemplates() {
+      return (await requestFn("resources/templates/list", {}))?.resourceTemplates ?? [];
+    },
+    async readResource(uri) {
+      return await requestFn("resources/read", { uri });
+    },
+    async listPrompts() {
+      return (await requestFn("prompts/list", {}))?.prompts ?? [];
+    },
+    async getPrompt(name, args) {
+      return await requestFn("prompts/get", {
+        name,
+        arguments: args ?? {}
+      });
+    }
+  };
+}
 async function createStatelessConnection(options) {
   const {
     url,
@@ -7557,11 +7780,16 @@ async function createStatelessConnection(options) {
       protocolVersion: negotiatedVersion ?? STATELESS_PROTOCOL_VERSION,
       clientInfo
     };
+    const cleanParams = { ...params };
+    if (cleanParams._inputResponses) {
+      meta.inputResponses = cleanParams._inputResponses;
+      delete cleanParams._inputResponses;
+    }
     const body = JSON.stringify({
       jsonrpc: "2.0",
       id,
       method,
-      params: { ...params, _meta: meta }
+      params: { ...cleanParams, _meta: meta }
     });
     for (let attempt = 0; attempt < 2; attempt++) {
       const { res, token } = await doFetch(method, params, body);
@@ -7590,28 +7818,9 @@ async function createStatelessConnection(options) {
     );
   }
   negotiatedVersion = STATELESS_PROTOCOL_VERSION;
-  let serverInfoCache;
+  const extra = buildStatelessMethods(request, discoverResult2);
   return {
-    async info() {
-      if (serverInfoCache) return serverInfoCache;
-      serverInfoCache = buildServerInfo(discoverResult2);
-      return serverInfoCache;
-    },
-    async listTools() {
-      return (await request("tools/list", {}))?.tools ?? [];
-    },
-    async callTool(name, args, _callOptions) {
-      const result = await request("tools/call", {
-        name,
-        arguments: args ?? {}
-      });
-      if ((result.resultType ?? "complete") === "input_required") {
-        throw new InputRequiredError(
-          JSON.stringify({ name, arguments: args ?? {}, result }, null, 2)
-        );
-      }
-      return result;
-    },
+    ...extra,
     async close() {
     }
   };
@@ -7661,7 +7870,9 @@ async function createPiConnection(options) {
   const clientOptions = {
     name: "mcpcat",
     version: options.version ?? "0.0.0",
-    requestTimeoutMs: options.timeoutMs
+    requestTimeoutMs: options.timeoutMs,
+    capabilities: { elicitation: {} },
+    roots: options.roots
   };
   const client = new McpClient(clientOptions);
   const transport = buildTransport(options);
@@ -7707,7 +7918,32 @@ async function createPiConnection(options) {
             inner?.(p);
           };
         }
-        return client.callTool(name, args, o);
+        const callArgs = callOptions?.inputResponses ? { ...args, _meta: { inputResponses: callOptions.inputResponses } } : args;
+        return client.callTool(name, callArgs, o);
+      },
+      async listResources() {
+        return client.listResources(reqOpts2());
+      },
+      async listResourceTemplates() {
+        return client.listResourceTemplates(reqOpts2());
+      },
+      async readResource(uri) {
+        return client.readResource(uri, reqOpts2());
+      },
+      async listPrompts() {
+        const result = await client.request(
+          "prompts/list",
+          {},
+          reqOpts2()
+        );
+        return result?.prompts ?? [];
+      },
+      async getPrompt(name, args) {
+        return client.request(
+          "prompts/get",
+          { name, arguments: args ?? {} },
+          reqOpts2()
+        );
       },
       async close() {
         await client.close();
@@ -7725,6 +7961,192 @@ async function createPiConnection(options) {
   }
 }
 
+// src/client/stdio-stateless.ts
+var PROTOCOL_VERSION = "2026-07-28";
+function createStdioJsonRpc(proc, platform2, options) {
+  const encoder2 = new TextEncoder();
+  const decoder3 = new TextDecoder();
+  let nextId2 = 1;
+  let readBuffer = "";
+  const reader = proc.stdout.getReader();
+  let negotiatedVersion;
+  const { version = "0.0.0", timeoutMs = 6e4, signal: externalSignal, verbose } = options;
+  async function readLine2() {
+    while (true) {
+      const nlIdx = readBuffer.indexOf("\n");
+      if (nlIdx >= 0) {
+        const line = readBuffer.slice(0, nlIdx).trim();
+        readBuffer = readBuffer.slice(nlIdx + 1);
+        if (line) return line;
+        continue;
+      }
+      const { done, value } = await reader.read();
+      if (done) throw new Error("stdio server closed unexpectedly");
+      readBuffer += decoder3.decode(value, { stream: true });
+    }
+  }
+  async function send(msg) {
+    const writer = proc.stdin.getWriter();
+    try {
+      await writer.write(encoder2.encode(`${msg}
+`));
+    } finally {
+      writer.releaseLock();
+    }
+  }
+  async function request(method, params) {
+    const id = nextId2++;
+    const meta = {
+      protocolVersion: negotiatedVersion ?? PROTOCOL_VERSION,
+      clientInfo: { name: "mcpcat", version }
+    };
+    const cleanParams = { ...params };
+    if (cleanParams._inputResponses) {
+      meta.inputResponses = cleanParams._inputResponses;
+      delete cleanParams._inputResponses;
+    }
+    const body = JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method,
+      params: { ...cleanParams, _meta: meta }
+    });
+    if (verbose?.enabled) verbose.request(method, body);
+    await send(body);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const remaining = deadline - Date.now();
+      if (externalSignal?.aborted) throw new McpTimeoutError2(method, timeoutMs);
+      const linePromise = readLine2();
+      const timeoutPromise = new Promise(
+        (_, reject) => setTimeout(() => reject(new McpTimeoutError2(method, timeoutMs)), remaining)
+      );
+      const line = await Promise.race([linePromise, timeoutPromise]);
+      const parsed = JSON.parse(line);
+      if (verbose?.enabled) verbose.response(line);
+      if (parsed.id === id) {
+        if (parsed.error) {
+          throw new StatelessRpcError(parsed.error.code, parsed.error.message, parsed.error.data);
+        }
+        return parsed.result;
+      }
+    }
+    throw new McpTimeoutError2(method, timeoutMs);
+  }
+  return {
+    request,
+    close() {
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+  };
+}
+function buildServerInfo2(discoverResult2) {
+  return {
+    name: discoverResult2?.serverInfo?.name,
+    version: discoverResult2?.serverInfo?.version,
+    title: discoverResult2?.serverInfo?.title,
+    protocolVersion: PROTOCOL_VERSION,
+    capabilities: discoverResult2?.capabilities ?? {},
+    instructions: discoverResult2?.instructions
+  };
+}
+function buildConnectionMethods(rpc, discoverResult2, proc) {
+  return {
+    async info() {
+      return buildServerInfo2(discoverResult2);
+    },
+    async listTools() {
+      return (await rpc.request("tools/list", {}))?.tools ?? [];
+    },
+    async callTool(name, args, callOptions) {
+      const params = { name, arguments: args ?? {} };
+      if (callOptions?.inputResponses) {
+        params._inputResponses = callOptions.inputResponses;
+      }
+      const result = await rpc.request("tools/call", params);
+      if ((result.resultType ?? "complete") === "input_required") {
+        throw new InputRequiredError(
+          JSON.stringify({ name, arguments: args ?? {}, result }, null, 2)
+        );
+      }
+      return result;
+    },
+    async listResources() {
+      return (await rpc.request("resources/list", {}))?.resources ?? [];
+    },
+    async listResourceTemplates() {
+      return (await rpc.request("resources/templates/list", {}))?.resourceTemplates ?? [];
+    },
+    async readResource(uri) {
+      return await rpc.request("resources/read", { uri });
+    },
+    async listPrompts() {
+      return (await rpc.request("prompts/list", {}))?.prompts ?? [];
+    },
+    async getPrompt(name, args) {
+      return await rpc.request("prompts/get", { name, arguments: args ?? {} });
+    },
+    async close() {
+      rpc.close();
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+    }
+  };
+}
+async function createStdioStatelessConnection(options) {
+  const inheritedEnv = {
+    ...options.platform.env,
+    ...options.env
+  };
+  const proc = await options.platform.spawn({
+    argv: [options.command, ...options.args ?? []],
+    env: inheritedEnv,
+    cwd: options.cwd
+  });
+  void readStderr(proc, options.verbose);
+  const rpc = createStdioJsonRpc(proc, options.platform, {
+    version: options.version,
+    timeoutMs: options.timeoutMs,
+    signal: options.signal,
+    verbose: options.verbose
+  });
+  const discoverRaw = await rpc.request("server/discover", {
+    protocolVersion: PROTOCOL_VERSION
+  });
+  const discoverResult2 = discoverRaw;
+  const supported = (discoverResult2?.supportedVersions ?? []).filter(
+    (v) => typeof v === "string"
+  );
+  if (!supported.includes(PROTOCOL_VERSION)) {
+    proc.kill("SIGTERM");
+    throw new Error(
+      `Server does not support ${PROTOCOL_VERSION} (advertised: ${supported.join(", ") || "none"})`
+    );
+  }
+  return buildConnectionMethods(rpc, discoverResult2, proc);
+}
+async function readStderr(proc, verbose) {
+  if (!verbose?.enabled) return;
+  const reader = proc.stderr.getReader();
+  const decoder3 = new TextDecoder();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder3.decode(value, { stream: true });
+      for (const line of chunk.split("\n")) {
+        if (line.trim()) verbose.server(line);
+      }
+    }
+  } catch {
+  }
+}
+
 // src/client/connect.ts
 async function connect(platform2, options) {
   const shared = {
@@ -7735,11 +8157,32 @@ async function connect(platform2, options) {
     platform: platform2
   };
   if (options.command) {
+    if (!options.protocolVersion || options.protocolVersion.startsWith("2026")) {
+      try {
+        return await createStdioStatelessConnection({
+          command: options.command,
+          args: options.args,
+          env: options.env,
+          cwd: options.cwd,
+          platform: platform2,
+          version: options.version,
+          timeoutMs: options.timeoutMs,
+          signal: options.signal,
+          verbose: options.verbose
+        });
+      } catch (err) {
+        const isMethodNotFound = err instanceof StatelessRpcError && err.code === -32601;
+        const isUnsupported = err instanceof Error && err.message.includes("does not support");
+        if (options.protocolVersion?.startsWith("2026")) throw err;
+        if (!isMethodNotFound && !isUnsupported) throw err;
+      }
+    }
     return createPiConnection({
       command: options.command,
       args: options.args,
       env: options.env,
       cwd: options.cwd,
+      roots: options.roots,
       ...shared
     });
   }
@@ -7782,27 +8225,123 @@ async function connect(platform2, options) {
   }
 }
 
-// src/client/targets.ts
-function splitShellStyle(input) {
-  const result = [];
-  let current = "";
-  let inSingle = false;
-  let inDouble = false;
-  for (let i = 0; i < input.length; i++) {
-    const c = input[i];
-    if (inSingle) {
-      if (c === "'") {
-        inSingle = false;
-      } else {
-        current += c;
-      }
-    } else if (inDouble) {
-      if (c === '"') {
-        inDouble = false;
-      } else if (c === "\\" && i + 1 < input.length) {
-        current += input[++i];
-      } else {
-        current += c;
+// src/client/elicit.ts
+function readLine(platform2) {
+  return new Promise((resolve2, reject) => {
+    const reader = platform2.stdin.getReader();
+    const chunks = [];
+    function pump() {
+      reader.read().then(({ done, value }) => {
+        if (done) {
+          reader.releaseLock();
+          resolve2(new TextDecoder().decode(concatChunks(chunks)).split("\n")[0] ?? "");
+          return;
+        }
+        chunks.push(value);
+        const text = new TextDecoder().decode(concatChunks(chunks));
+        if (text.includes("\n")) {
+          reader.releaseLock();
+          resolve2(text.split("\n")[0]);
+          return;
+        }
+        pump();
+      }, reject);
+    }
+    pump();
+  });
+}
+function concatChunks(chunks) {
+  const total = chunks.reduce((s, c) => s + c.length, 0);
+  const merged = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    merged.set(c, offset);
+    offset += c.length;
+  }
+  return merged;
+}
+function coerceValue(raw, type) {
+  if (!type || type === "string") return raw;
+  if (type === "integer") return Number.parseInt(raw, 10);
+  if (type === "number") return Number.parseFloat(raw);
+  if (type === "boolean") return raw === "true" || raw === "1" || raw === "yes";
+  return raw;
+}
+async function promptForSchema(platform2, schema) {
+  const answers = {};
+  const properties = schema.properties ?? {};
+  const required = new Set(schema.required ?? []);
+  for (const [key, prop] of Object.entries(properties)) {
+    const req = required.has(key) ? " (required)" : "";
+    const desc = prop.description ? ` - ${prop.description}` : "";
+    const def = prop.default !== void 0 ? ` [${String(prop.default)}]` : "";
+    const choices = prop.enum ? ` (${prop.enum.join("|")})` : "";
+    await platform2.write(2, `${key}${req}${desc}${choices}${def}: `);
+    const line = await readLine(platform2);
+    const value = line.trim();
+    if (value === "" && prop.default !== void 0) {
+      answers[key] = prop.default;
+    } else if (value !== "") {
+      answers[key] = coerceValue(value, prop.type);
+    }
+  }
+  return answers;
+}
+function parseInputRequest(result) {
+  const ir = result.inputRequest;
+  if (!ir && !result.inputRequests) return void 0;
+  if (ir) return ir;
+  const reqs = result.inputRequests;
+  if (Array.isArray(reqs) && reqs.length > 0) return reqs[0];
+  return void 0;
+}
+async function handleElicitation(platform2, inputRequest, isTty, respondData) {
+  if (inputRequest.url) {
+    if (isTty) {
+      await platform2.write(2, `Open this URL to continue: ${inputRequest.url}
+`);
+      await platform2.write(2, "Press Enter when done...");
+      await readLine(platform2);
+      return { answers: {} };
+    }
+    return { exitCode: 6 };
+  }
+  if (respondData) {
+    return { answers: respondData };
+  }
+  if (!isTty) {
+    return { exitCode: 6 };
+  }
+  const schema = inputRequest.schema ?? { type: "object", properties: {} };
+  if (inputRequest.message) {
+    await platform2.write(2, `${inputRequest.message}
+`);
+  }
+  const answers = await promptForSchema(platform2, schema);
+  return { answers };
+}
+
+// src/client/targets.ts
+function splitShellStyle(input) {
+  const result = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+    if (inSingle) {
+      if (c === "'") {
+        inSingle = false;
+      } else {
+        current += c;
+      }
+    } else if (inDouble) {
+      if (c === '"') {
+        inDouble = false;
+      } else if (c === "\\" && i + 1 < input.length) {
+        current += input[++i];
+      } else {
+        current += c;
       }
     } else if (c === "'") {
       inSingle = true;
@@ -8191,10 +8730,19 @@ function buildShellGlobal(platform2) {
     }
   };
 }
+var DEFAULT_MEMORY_LIMIT_MIB = 256;
+var MAX_MEMORY_LIMIT_MIB = 1024;
 async function runCode(targets, source, options) {
   const { platform: platform2, json } = options;
   const { code, options: sourceOptions } = parseCodemodeSource(source);
-  const timeoutMs = sourceOptions.timeoutMs ?? options.timeoutMs ?? 3e5;
+  const callerTimeoutMs = options.timeoutMs ?? 3e5;
+  const scriptTimeoutMs = sourceOptions.timeoutMs;
+  const timeoutMs = scriptTimeoutMs !== void 0 ? Math.min(callerTimeoutMs, scriptTimeoutMs) : callerTimeoutMs;
+  const memoryLimitMiB = Math.min(
+    options.memoryLimitMiB ?? DEFAULT_MEMORY_LIMIT_MIB,
+    MAX_MEMORY_LIMIT_MIB
+  );
+  const memoryLimitBytes = memoryLimitMiB * 1024 * 1024;
   const { connections, allDeclaredTools, namespaces } = await collectTools(targets);
   const searchDocs = buildSearchDocs(allDeclaredTools, namespaces);
   const stateDir2 = options.stateDir ?? `${platform2.env.XDG_STATE_HOME ?? `${platform2.env.HOME ?? "."}/.local/state`}/mcpcat`;
@@ -8204,7 +8752,7 @@ async function runCode(targets, source, options) {
     ...buildDiscoveryGlobals(allDeclaredTools, namespaces, searchDocs),
     ...options.allowShell ? [buildShellGlobal(platform2)] : []
   ];
-  const sandbox = await createSandbox(platform2, toolImpls, globals, timeoutMs);
+  const sandbox = await createSandbox(platform2, toolImpls, globals, timeoutMs, memoryLimitBytes);
   try {
     const result = await sandbox.execute(code, { store });
     if (result.ok) {
@@ -8248,12 +8796,12 @@ async function formatOutput(platform2, result, json) {
   const isTimeout = !result.ok && result.error && result.error.kind === "timeout";
   return result.ok ? 0 : isTimeout ? 124 : 1;
 }
-async function createSandbox(platform2, tools, globals, timeoutMs) {
+async function createSandbox(platform2, tools, globals, timeoutMs, memoryLimitBytes) {
   const isKernel2 = platform2.packageDir !== void 0;
   if (isKernel2) {
     const { InlineCodemodeSandbox: InlineCodemodeSandbox2 } = await Promise.resolve().then(() => (init_portable(), portable_exports));
     const wasm = await loadWasmKernel(platform2);
-    return new InlineCodemodeSandbox2({ tools, globals, timeoutMs, wasm });
+    return new InlineCodemodeSandbox2({ tools, globals, timeoutMs, wasm, memoryLimitBytes });
   }
   const { CodemodeSandbox: CodemodeSandbox2, loadQuickJSWasm: loadQuickJSWasm2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
   const getSeaDir = globalThis.__mcpcat_get_sea_asset_dir;
@@ -8264,6 +8812,7 @@ async function createSandbox(platform2, tools, globals, timeoutMs) {
     tools,
     globals,
     timeoutMs,
+    memoryLimitBytes,
     wasm: loadQuickJSWasm2(wasmPath),
     workerUrl
   });
@@ -8339,6 +8888,14 @@ function containsPlaceholders(value) {
 function expandPlaceholders(value, env2) {
   return value.replace(PLACEHOLDER, (_, name) => env2[name] ?? "");
 }
+function missingPlaceholders(value, env2) {
+  const missing = [];
+  for (const m of value.matchAll(PLACEHOLDER)) {
+    const name = m[1];
+    if (env2[name] === void 0 && !missing.includes(name)) missing.push(name);
+  }
+  return missing;
+}
 function expandPlaceholdersStrict(value, env2) {
   let hasUndefined = false;
   const result = value.replace(PLACEHOLDER, (_, name) => {
@@ -8351,6 +8908,20 @@ function expandPlaceholdersStrict(value, env2) {
   if (hasUndefined) return void 0;
   return result;
 }
+function expandHeaders(headers, env2, warn) {
+  if (!headers) return void 0;
+  const result = {};
+  for (const [k, v] of Object.entries(headers)) {
+    const missing = missingPlaceholders(v, env2);
+    if (missing.length > 0) {
+      if (warn)
+        warn(`header "${k}": unset variable${missing.length > 1 ? "s" : ""} ${missing.join(", ")}`);
+      continue;
+    }
+    result[k] = expandPlaceholders(v, env2);
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
 
 // src/config/parse.ts
 var SERVER_NAME = /^[A-Za-z0-9_-]+$/;
@@ -8541,7 +9112,12 @@ async function readFile2(fs, path) {
   try {
     const data = await fs.readFile(path);
     return new TextDecoder().decode(data);
-  } catch {
+  } catch (err) {
+    if (err.code === "EACCES") {
+      const e = new Error(`permission denied: ${path}`);
+      e.code = "EACCES";
+      throw e;
+    }
     return void 0;
   }
 }
@@ -8706,6 +9282,13 @@ async function removeStaleLock(fs, lockPath) {
 async function acquireLock(fs, configPath) {
   const lockPath = `${configPath}.lock`;
   const start = Date.now();
+  const parentDir = lockPath.slice(0, lockPath.lastIndexOf("/"));
+  if (parentDir) {
+    try {
+      await fs.mkdir(parentDir);
+    } catch {
+    }
+  }
   while (true) {
     try {
       await fs.mkdirExclusive(lockPath);
@@ -8767,7 +9350,15 @@ async function editMcpServers(fs, path, edit) {
     }
     const tmpPath = `${path}.tmp.${Date.now()}`;
     await fs.writeFile(tmpPath, output);
-    await fs.rename(tmpPath, path);
+    try {
+      await fs.rename(tmpPath, path);
+    } catch (renameErr) {
+      try {
+        if (fs.unlink) await fs.unlink(tmpPath);
+      } catch {
+      }
+      throw renameErr;
+    }
     return { changed: true };
   } finally {
     await release();
@@ -9144,6 +9735,31 @@ async function getCandidate(fs, stateDir2, id) {
 }
 
 // src/discovery/probe.ts
+var LOOPBACK_RE = /^(127\.\d+\.\d+\.\d+|\[?::1\]?|localhost)$/i;
+var LINK_LOCAL_RE = /^(169\.254\.|fe80:)/i;
+var PRIVATE_RE = /^(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.|fc|fd)/i;
+var LOCALHOST_SUFFIX_RE = /\.localhost$/i;
+var SLICC_INTERNAL_RE = /^host\.slicc\.internal$/i;
+function isPrivateOrLoopback(hostname) {
+  const bare = hostname.replace(/^\[|\]$/g, "");
+  return LOOPBACK_RE.test(bare) || LINK_LOCAL_RE.test(bare) || PRIVATE_RE.test(bare) || LOCALHOST_SUFFIX_RE.test(bare) || SLICC_INTERNAL_RE.test(bare);
+}
+function isSameOrigin(base, candidate) {
+  try {
+    const a = new URL(base);
+    const b = new URL(candidate);
+    return a.origin === b.origin;
+  } catch {
+    return false;
+  }
+}
+function isUserUrlPrivate(userUrl) {
+  try {
+    return isPrivateOrLoopback(new URL(userUrl).hostname);
+  } catch {
+    return false;
+  }
+}
 function isJsonContentType(ct) {
   if (!ct) return false;
   const lower = ct.toLowerCase();
@@ -9278,13 +9894,44 @@ async function probeWellKnown(fetcher, origin, page) {
   }
   return events;
 }
-async function probeLinkHeaders(fetcher, targetUrl, origin, page) {
+async function probeLinkHeaders(fetcher, targetUrl, origin, page, userUrlIsPrivate) {
   const events = [];
   const targetResult = await probeUrl(fetcher, targetUrl);
   if (!targetResult) return events;
   const links = parseLinkHeaders(targetResult.headers);
   for (const link of links) {
     const resolved = new URL(link.url, targetUrl).href;
+    if (!isSameOrigin(targetUrl, resolved)) {
+      events.push(
+        makeEvent(
+          link.rel,
+          origin,
+          resolved,
+          "link-header",
+          page,
+          "invalid",
+          null,
+          `skipped: cross-origin Link target (${new URL(resolved).origin})`
+        )
+      );
+      continue;
+    }
+    const resolvedHost = new URL(resolved).hostname;
+    if (!userUrlIsPrivate && isPrivateOrLoopback(resolvedHost)) {
+      events.push(
+        makeEvent(
+          link.rel,
+          origin,
+          resolved,
+          "link-header",
+          page,
+          "invalid",
+          null,
+          `skipped: private/loopback target (${resolvedHost})`
+        )
+      );
+      continue;
+    }
     const classifier = link.rel === "ard" ? classifyArd : link.rel === "ai-catalog" ? classifyAiCatalog : null;
     if (!classifier) continue;
     const linkResult = await probeUrl(fetcher, resolved, "application/json");
@@ -9381,9 +10028,10 @@ async function probeDiscover(platform2, targetUrl) {
   }
   const page = targetUrl;
   const fetcher = platform2.fetch;
+  const userPrivate = isUserUrlPrivate(targetUrl);
   const events = [
     ...await probeWellKnown(fetcher, origin, page),
-    ...await probeLinkHeaders(fetcher, targetUrl, origin, page),
+    ...await probeLinkHeaders(fetcher, targetUrl, origin, page, userPrivate),
     ...await probeMcp(fetcher, origin, page, targetUrl)
   ];
   return { events };
@@ -9640,13 +10288,27 @@ function renderCallResultJson(result) {
   return JSON.stringify(result, null, 2);
 }
 async function renderCallResult(platform2, result, options) {
+  const r = options?.redact ?? ((s) => s);
+  if (options?.outputPath) {
+    const content = options.json ? renderCallResultJson(result) : renderCallResultText(result, options);
+    await platform2.fs.writeFile(options.outputPath, content);
+    if (result.isError) {
+      await platform2.write(
+        2,
+        r(`${result.isError ? "(tool reported error)" : ""}
+`)
+      );
+      return 1;
+    }
+    return 0;
+  }
   if (options?.json) {
     const json = renderCallResultJson(result);
     if (result.isError) {
       await platform2.write(
         2,
-        `${JSON.stringify({ error: { kind: "tool_error", message: json } }, null, 2)}
-`
+        r(`${JSON.stringify({ error: { kind: "tool_error", message: json } }, null, 2)}
+`)
       );
       return 1;
     }
@@ -9656,8 +10318,8 @@ async function renderCallResult(platform2, result, options) {
   }
   const text = renderCallResultText(result, options);
   if (result.isError) {
-    await platform2.write(2, `${text || "(tool reported error)"}
-`);
+    await platform2.write(2, r(`${text || "(tool reported error)"}
+`));
     return 1;
   }
   if (text) {
@@ -9674,13 +10336,33 @@ async function renderInfoJson(platform2, info) {
   await platform2.write(1, `${JSON.stringify(info, null, 2)}
 `);
 }
-async function renderErrorJson(platform2, kind, message, code, data) {
-  const errorObj = { kind, message };
+async function renderErrorJson(platform2, kind, message, code, data, redact2) {
+  const r = redact2 ?? ((s) => s);
+  const errorObj = { kind, message: r(message) };
   if (code !== void 0) errorObj.code = code;
   if (data !== void 0) errorObj.data = data;
   await platform2.write(2, `${JSON.stringify({ error: errorObj }, null, 2)}
 `);
 }
+async function renderResourcesJson(platform2, resources, templates) {
+  await platform2.write(
+    1,
+    `${JSON.stringify({ resources, resourceTemplates: templates }, null, 2)}
+`
+  );
+}
+async function renderPromptsJson(platform2, prompts) {
+  await platform2.write(1, `${JSON.stringify({ prompts }, null, 2)}
+`);
+}
+async function renderPromptResultJson(platform2, result) {
+  await platform2.write(1, `${JSON.stringify(result, null, 2)}
+`);
+}
+async function renderReadResourceJson(platform2, result) {
+  await platform2.write(1, `${JSON.stringify(result, null, 2)}
+`);
+}
 
 // src/serve/catalog.ts
 var NAME_RE = /^[A-Za-z][\w-]*$/;
@@ -10448,38 +11130,46 @@ function hasOwn(value, key) {
 }
 
 // src/serve/origin.ts
-var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
-function isLoopbackOrigin(origin) {
-  try {
-    const url = new URL(origin);
-    const hostname = url.hostname;
-    if (LOOPBACK_HOSTS.has(hostname)) return true;
-    if (hostname === "::1") return true;
-    if (hostname.endsWith(".localhost")) return true;
-    return false;
-  } catch {
-    return false;
-  }
+function isLoopbackBind(host) {
+  return host === "127.0.0.1" || host === "localhost" || host === "::1" || host === "[::1]";
 }
-function isLoopbackHost(host) {
-  const hostname = host.replace(/:\d+$/, "");
-  if (LOOPBACK_HOSTS.has(hostname)) return true;
-  if (hostname === "::1") return true;
-  if (hostname.endsWith(".localhost")) return true;
-  return false;
+function buildServerOrigins(host, port) {
+  const origins = /* @__PURE__ */ new Set();
+  origins.add(`http://${host}:${port}`);
+  origins.add(`http://${port}.kernel.localhost`);
+  if (isLoopbackBind(host)) {
+    origins.add(`http://localhost:${port}`);
+    origins.add(`http://127.0.0.1:${port}`);
+    origins.add(`http://[::1]:${port}`);
+  }
+  return origins;
 }
-function checkOrigin(origin, allowedOrigins, boundLoopback) {
+function checkOrigin(origin, serverOrigins, allowedOrigins) {
   if (origin === void 0) return { ok: true };
+  if (serverOrigins.has(origin)) return { ok: true };
   if (allowedOrigins.has(origin)) return { ok: true };
-  if (isLoopbackOrigin(origin)) return { ok: true };
-  if (!boundLoopback) return { ok: true };
   return { ok: false, reason: `origin ${origin} is not allowed` };
 }
-function checkHost(host, boundLoopback) {
-  if (!boundLoopback) return { ok: true };
+function buildAllowedHosts(host, port, extraHosts) {
+  const hosts = /* @__PURE__ */ new Set();
+  hosts.add(`${host}:${port}`);
+  hosts.add(host);
+  hosts.add(`${port}.kernel.localhost`);
+  const loopback2 = ["localhost", "127.0.0.1", "[::1]"];
+  for (const h of loopback2) {
+    hosts.add(h);
+    hosts.add(`${h}:${port}`);
+  }
+  for (const h of extraHosts) hosts.add(h);
+  return hosts;
+}
+function checkHost(host, allowedHosts) {
   if (!host) return { ok: false, reason: "missing Host header" };
-  if (isLoopbackHost(host)) return { ok: true };
-  return { ok: false, reason: `host ${host} is not loopback` };
+  if (allowedHosts.has(host)) return { ok: true };
+  const hostname = host.replace(/:\d+$/, "");
+  if (allowedHosts.has(hostname)) return { ok: true };
+  if (hostname.endsWith(".localhost")) return { ok: true };
+  return { ok: false, reason: `host ${host} is not allowed` };
 }
 
 // src/serve/proxy.ts
@@ -10716,6 +11406,8 @@ function parseSingleFlag(args, i, opts) {
     return parsed.next;
   } else if (arg === "--json") {
     opts.json = true;
+  } else if (arg === "--no-auth") {
+    opts.noAuth = true;
   } else if (!arg.startsWith("-")) {
     opts.commands.push(parseCommandTarget(arg));
   } else {
@@ -10736,6 +11428,9 @@ function parseValueFlag(args, i, opts) {
     case "--allow-origin":
       opts.allowOrigins.push(args[++i]);
       break;
+    case "--allow-host":
+      opts.allowHosts.push(args[++i]);
+      break;
     case "--env":
       opts.envAllow.push(args[++i]);
       break;
@@ -10774,7 +11469,9 @@ function parseServeFlags(args) {
     host: "127.0.0.1",
     port: 0,
     bearer: void 0,
+    noAuth: false,
     allowOrigins: [],
+    allowHosts: [],
     envAllow: [],
     toolTemplates: [],
     callTimeout: CALL_TIMEOUT_MS,
@@ -10803,6 +11500,20 @@ function constantTimeEqual(a, b) {
   }
   return mismatch === 0;
 }
+function generateToken() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function checkContentType(ct) {
+  if (!ct) return false;
+  return ct.toLowerCase().startsWith("application/json");
+}
+function checkAcceptHeader(accept) {
+  if (!accept) return false;
+  const lower = accept.toLowerCase();
+  return lower.includes("application/json") || lower.includes("text/event-stream") || lower.includes("*/*");
+}
 function buildChildEnv(platform2, envAllow) {
   const env2 = {};
   for (const key of ALLOWED_ENV_KEYS) {
@@ -10851,7 +11562,7 @@ async function runCommand(platform2, cmdPath, argv, childEnv, stdin, timeoutMs,
   }
   const stdoutChunks = [];
   const stderrChunks = [];
-  const readStream2 = async (stream, into) => {
+  const readStream3 = async (stream, into) => {
     const r = stream.getReader();
     try {
       for (; ; ) {
@@ -10867,8 +11578,8 @@ async function runCommand(platform2, cmdPath, argv, childEnv, stdin, timeoutMs,
     (resolve2) => setTimeout(() => resolve2("timeout"), timeoutMs)
   );
   const work = Promise.all([
-    readStream2(proc.stdout, stdoutChunks),
-    readStream2(proc.stderr, stderrChunks),
+    readStream3(proc.stdout, stdoutChunks),
+    readStream3(proc.stderr, stderrChunks),
     proc.wait()
   ]);
   const result = await Promise.race([work, timer]);
@@ -11100,7 +11811,10 @@ function createToolExecutor(platform2, clis, allTools, childEnv, options, serveC
 }
 async function runServe(platform2, options, version) {
   let resolvedBearer;
-  if (options.bearer) {
+  let generatedBearer = false;
+  if (options._resolvedBearer) {
+    resolvedBearer = options._resolvedBearer;
+  } else if (options.bearer) {
     const expanded = expandBearerToken(options.bearer, platform2.env);
     if (!expanded) {
       await platform2.write(
@@ -11110,9 +11824,31 @@ async function runServe(platform2, options, version) {
       return 2;
     }
     resolvedBearer = expanded;
+  } else 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;
+    }
+    if (options.transport === "http") {
+      await platform2.write(
+        2,
+        "mcpcat serve: warning: running without authentication on loopback\n"
+      );
+    }
+    resolvedBearer = void 0;
+  } else 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;
+    }
+    resolvedBearer = generateToken();
+    generatedBearer = true;
   }
   if (options.proxy) {
-    return runProxyServe(platform2, options, version, resolvedBearer);
+    return runProxyServe(platform2, options, version, resolvedBearer, generatedBearer);
   }
   const serveCwd = options.cwd ?? platform2.cwd;
   const childEnv = buildChildEnv(platform2, options.envAllow);
@@ -11149,12 +11885,35 @@ async function runServe(platform2, options, version) {
     executor.invoke,
     serverName,
     version,
-    resolvedBearer
+    resolvedBearer,
+    generatedBearer
   );
 }
+async function publishBearer(platform2, token, port, listenUrl, json) {
+  if (!json && platform2.isatty(2)) {
+    await platform2.write(2, `mcpcat serve: bearer ${token}
+`);
+    return void 0;
+  }
+  const dir = stateDir(platform2);
+  await platform2.fs.mkdir(dir, { mode: 448 });
+  const tokenPath = `${dir}/serve-${port}.token`;
+  try {
+    await platform2.fs.unlink?.(tokenPath);
+  } catch {
+  }
+  await platform2.fs.writeFile(tokenPath, token, { mode: 384 });
+  await platform2.write(2, `mcpcat serve: bearer saved to ${tokenPath}
+`);
+  if (json) {
+    await platform2.write(1, `${JSON.stringify({ url: listenUrl, bearerFile: tokenPath })}
+`);
+  }
+  return tokenPath;
+}
 function resolveProxyStdio(target, version) {
   const rest = target.slice(6);
-  const parts = rest.split(/\s+/).filter(Boolean);
+  const parts = splitShellStyle(rest);
   return { command: parts[0], args: parts.slice(1), version };
 }
 function resolveProxyUrl(target, headers, version) {
@@ -11224,7 +11983,7 @@ async function buildProxyConnectOpts(platform2, options, version) {
   }
   return { connectOpts, hiddenValues };
 }
-async function runProxyServe(platform2, options, version, resolvedBearer) {
+async function runProxyServe(platform2, options, version, resolvedBearer, generatedBearer) {
   const built = await buildProxyConnectOpts(platform2, options, version);
   if ("error" in built) {
     await platform2.write(2, `mcpcat serve --proxy: ${built.error}
@@ -11242,7 +12001,7 @@ async function runProxyServe(platform2, options, version, resolvedBearer) {
   if (options.transport === "stdio") {
     return runProxyStdio(platform2, proxy);
   }
-  return runProxyHttp(platform2, options, proxy, resolvedBearer);
+  return runProxyHttp(platform2, options, proxy, resolvedBearer, generatedBearer);
 }
 async function runProxyStdio(platform2, proxy) {
   const reader = platform2.stdin.getReader();
@@ -11273,12 +12032,12 @@ async function runProxyStdio(platform2, proxy) {
   }
   return 0;
 }
-async function runProxyHttp(platform2, options, proxy, resolvedBearer) {
+async function runProxyHttp(platform2, options, proxy, resolvedBearer, generatedBearer) {
   if (!platform2.listen) {
     await platform2.write(2, "mcpcat serve --proxy: HTTP transport requires platform.listen\n");
     return 3;
   }
-  const boundLoopback = options.host === "127.0.0.1" || options.host === "localhost" || options.host === "::1";
+  const boundLoopback = isLoopbackBind(options.host);
   if (!boundLoopback && !resolvedBearer) {
     await platform2.write(
       2,
@@ -11292,10 +12051,23 @@ async function runProxyHttp(platform2, options, proxy, resolvedBearer) {
     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`;
-  if (options.json) {
-    await platform2.write(1, `${JSON.stringify({ url: listenUrl })}
+  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 --proxy: listening on ${listenUrl}
 `);
@@ -11308,12 +12080,23 @@ async function runProxyHttp(platform2, options, proxy, resolvedBearer) {
     shutdownRequested = true;
     listener.close();
     void proxy.shutdown();
+    if (tokenFilePath) {
+      platform2.fs.unlink?.(tokenFilePath).catch(() => {
+      });
+    }
   };
   if (platform2.onSignal) {
     platform2.onSignal("SIGINT", shutdown);
     platform2.onSignal("SIGTERM", shutdown);
   }
-  const handler = (request) => handleProxyMcpRequest(request, proxy, allowedOrigins, boundLoopback, resolvedBearer);
+  const handler = (request) => handleProxyMcpRequest(
+    request,
+    proxy,
+    serverOrigins,
+    allowedOrigins,
+    allowedHosts,
+    resolvedBearer
+  );
   try {
     for await (const connection of listener) {
       if (shutdownRequested) break;
@@ -11331,20 +12114,40 @@ async function runProxyHttp(platform2, options, proxy, resolvedBearer) {
   }
   return 0;
 }
-async function handleProxyMcpRequest(request, proxy, allowedOrigins, boundLoopback, resolvedBearer) {
-  if (resolvedBearer) {
-    const authHeader = request.headers.authorization;
-    const provided = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : "";
-    if (!provided || !constantTimeEqual(provided, resolvedBearer)) {
-      return {
-        status: 401,
-        reason: "Unauthorized",
-        headers: { "content-type": "text/plain" },
-        body: "Unauthorized"
-      };
-    }
+async function handleProxyMcpRequest(request, proxy, serverOrigins, allowedOrigins, allowedHosts, resolvedBearer) {
+  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, allowedOrigins, boundLoopback);
+  const originCheck = checkOrigin(request.headers.origin, serverOrigins, allowedOrigins);
   if (!originCheck.ok) {
     return {
       status: 403,
@@ -11353,7 +12156,7 @@ async function handleProxyMcpRequest(request, proxy, allowedOrigins, boundLoopba
       body: originCheck.reason ?? "Forbidden"
     };
   }
-  const hostCheck = checkHost(request.headers.host, boundLoopback);
+  const hostCheck = checkHost(request.headers.host, allowedHosts);
   if (!hostCheck.ok) {
     return {
       status: 403,
@@ -11362,21 +12165,17 @@ async function handleProxyMcpRequest(request, proxy, allowedOrigins, boundLoopba
       body: hostCheck.reason ?? "Forbidden"
     };
   }
-  if (request.target !== "/mcp") {
-    return {
-      status: 404,
-      reason: "Not Found",
-      headers: { "content-type": "text/plain" },
-      body: "Not Found"
-    };
-  }
-  if (request.method !== "POST") {
-    return {
-      status: 405,
-      reason: "Method Not Allowed",
-      headers: { "content-type": "text/plain", allow: "POST" },
-      body: "Method Not Allowed"
-    };
+  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 outcome = await proxy.handle(request.body);
   return {
@@ -11414,12 +12213,12 @@ async function runStdioServer(platform2, tools, call, serverName, version) {
   }
   return 0;
 }
-async function runHttpServer(platform2, options, tools, call, serverName, version, resolvedBearer) {
+async function runHttpServer(platform2, options, tools, call, serverName, version, resolvedBearer, generatedBearer) {
   if (!platform2.listen) {
     await platform2.write(2, "mcpcat serve: HTTP transport requires platform.listen\n");
     return 3;
   }
-  const boundLoopback = options.host === "127.0.0.1" || options.host === "localhost" || options.host === "::1";
+  const boundLoopback = isLoopbackBind(options.host);
   if (!boundLoopback && !resolvedBearer) {
     await platform2.write(2, "mcpcat serve: --bearer is required when binding off loopback\n");
     return 2;
@@ -11427,10 +12226,23 @@ async function runHttpServer(platform2, options, tools, call, serverName, versio
   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`;
-  if (options.json) {
-    await platform2.write(1, `${JSON.stringify({ url: listenUrl })}
+  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: listening on ${listenUrl}
 `);
@@ -11440,6 +12252,10 @@ async function runHttpServer(platform2, options, tools, call, serverName, versio
     shutdownRequested = true;
     listener.close();
     void killInflight();
+    if (tokenFilePath) {
+      platform2.fs.unlink?.(tokenFilePath).catch(() => {
+      });
+    }
   };
   if (platform2.onSignal) {
     platform2.onSignal("SIGINT", shutdown);
@@ -11451,8 +12267,9 @@ async function runHttpServer(platform2, options, tools, call, serverName, versio
     call,
     serverName,
     version,
+    serverOrigins,
     allowedOrigins,
-    boundLoopback,
+    allowedHosts,
     resolvedBearer
   );
   try {
@@ -11472,37 +12289,7 @@ async function runHttpServer(platform2, options, tools, call, serverName, versio
   }
   return 0;
 }
-async function handleMcpRequest(request, tools, call, serverName, version, allowedOrigins, boundLoopback, resolvedBearer) {
-  if (resolvedBearer) {
-    const authHeader = request.headers.authorization;
-    const provided = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : "";
-    if (!provided || !constantTimeEqual(provided, resolvedBearer)) {
-      return {
-        status: 401,
-        reason: "Unauthorized",
-        headers: { "content-type": "text/plain" },
-        body: "Unauthorized"
-      };
-    }
-  }
-  const originCheck = checkOrigin(request.headers.origin, allowedOrigins, boundLoopback);
-  if (!originCheck.ok) {
-    return {
-      status: 403,
-      reason: "Forbidden",
-      headers: { "content-type": "text/plain" },
-      body: originCheck.reason ?? "Forbidden"
-    };
-  }
-  const hostCheck = checkHost(request.headers.host, boundLoopback);
-  if (!hostCheck.ok) {
-    return {
-      status: 403,
-      reason: "Forbidden",
-      headers: { "content-type": "text/plain" },
-      body: hostCheck.reason ?? "Forbidden"
-    };
-  }
+async function handleMcpRequest(request, tools, call, serverName, version, serverOrigins, allowedOrigins, allowedHosts, resolvedBearer) {
   if (request.target !== "/mcp") {
     return {
       status: 404,
@@ -11519,8 +12306,54 @@ async function handleMcpRequest(request, tools, call, serverName, version, allow
       body: "Method Not Allowed"
     };
   }
-  const outcome = await handleJsonRpc(request.body, tools, call, serverName, version);
-  return {
+  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 outcome = await handleJsonRpc(request.body, tools, call, serverName, version);
+  return {
     status: outcome.status,
     reason: outcome.status === 200 ? "OK" : "Accepted",
     headers: { "content-type": outcome.contentType },
@@ -11844,8 +12677,16 @@ var PiFileTokenSource = class {
 };
 
 // src/cli/auth-verbs.ts
-function createTokenSource(platform2) {
-  return new PiFileTokenSource(platform2);
+var resolvedSource;
+async function createTokenSource(platform2) {
+  if (isKernel(platform2)) return new PiFileTokenSource(platform2);
+  if (resolvedSource) return resolvedSource;
+  if (await jerkAvailable(platform2)) {
+    resolvedSource = new JerkTokenSource(platform2);
+  } else {
+    resolvedSource = new PiFileTokenSource(platform2);
+  }
+  return resolvedSource;
 }
 function resolveServerName(target) {
   try {
@@ -11875,6 +12716,79 @@ async function resolveLoginTarget(platform2, target) {
   }
   throw new Error(`unknown target '${target}': not a URL and not found in mcp.json`);
 }
+function jerkMcpId(name) {
+  if (name.startsWith("mcp:")) return name;
+  if (name.startsWith("url:")) return `mcp:${name}`;
+  return `mcp:${name}`;
+}
+async function readStream2(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  const total = chunks.reduce((s, c) => s + c.length, 0);
+  const buf = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    buf.set(c, off);
+    off += c.length;
+  }
+  return new TextDecoder().decode(buf);
+}
+async function jerkLogin(platform2, target, args) {
+  const resolved = await resolveLoginTarget(platform2, target);
+  const id = jerkMcpId(resolved.name);
+  const argv = ["jerk", id, "create"];
+  const scopeIdx = args.indexOf("--scope");
+  if (scopeIdx !== -1 && args[scopeIdx + 1]) {
+    argv.push("--scope", args[scopeIdx + 1]);
+  }
+  if (args.includes("--no-browser")) {
+    argv.push("--no-browser");
+  }
+  const proc = await platform2.spawn({ argv });
+  proc.stdin.close().catch(() => {
+  });
+  const [, errText, result] = await Promise.all([
+    readStream2(proc.stdout),
+    readStream2(proc.stderr),
+    proc.wait()
+  ]);
+  if (result.status === 0) {
+    await platform2.write(1, `Signed in to ${target}
+`);
+    return 0;
+  }
+  if (errText.trim()) {
+    await platform2.write(2, errText);
+  }
+  if (result.status === JERK_EXIT_SIGN_IN) return 4;
+  return result.status;
+}
+async function jerkLogout(platform2, target) {
+  const resolved = await resolveLoginTarget(platform2, target);
+  const id = jerkMcpId(resolved.name);
+  const argv = ["jerk", id, "drop", "--yes"];
+  const proc = await platform2.spawn({ argv });
+  proc.stdin.close().catch(() => {
+  });
+  const [, , result] = await Promise.all([
+    readStream2(proc.stdout),
+    readStream2(proc.stderr),
+    proc.wait()
+  ]);
+  if (result.status === 0) {
+    await platform2.write(1, `Signed out of ${target}
+`);
+  } else {
+    await platform2.write(1, `No credentials stored for ${target}
+`);
+  }
+  return 0;
+}
 async function runLogin(platform2, args, source) {
   if (isKernel(platform2)) {
     await platform2.write(
@@ -11883,13 +12797,22 @@ async function runLogin(platform2, args, source) {
     );
     return 4;
   }
-  const noBrowser = args.includes("--no-browser");
   const positional = args.filter((a) => !a.startsWith("-"));
   if (positional.length === 0) {
     await platform2.write(2, "mcpcat: login requires a target\n");
     return 2;
   }
   const target = positional[0];
+  if (source instanceof JerkTokenSource) {
+    try {
+      return await jerkLogin(platform2, target, args);
+    } catch (err) {
+      await platform2.write(2, `mcpcat: login failed: ${err.message}
+`);
+      return 4;
+    }
+  }
+  const noBrowser = args.includes("--no-browser");
   let resolved;
   try {
     resolved = await resolveLoginTarget(platform2, target);
@@ -11971,6 +12894,15 @@ async function runLogout(platform2, args, source) {
     return 2;
   }
   const target = positional[0];
+  if (source instanceof JerkTokenSource) {
+    try {
+      return await jerkLogout(platform2, target);
+    } catch (err) {
+      await platform2.write(2, `mcpcat: logout failed: ${err.message}
+`);
+      return 1;
+    }
+  }
   let resolved;
   try {
     resolved = await resolveLoginTarget(platform2, target);
@@ -12343,6 +13275,49 @@ function checkAgentWarnings(name, config) {
   return warnings;
 }
 
+// src/serve/seal.ts
+async function sealSecret(platform2, name, value, options) {
+  if (!platform2.seal) {
+    throw Object.assign(new Error("vault device not available"), { sealErrno: "ENOTCONN" });
+  }
+  const request = JSON.stringify({
+    v: 1,
+    op: "seal",
+    kind: "mcp",
+    name,
+    value,
+    server: options.server,
+    url: options.url
+  });
+  let responseText;
+  try {
+    responseText = await platform2.seal(request);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ENOTCONN") {
+      throw Object.assign(new Error("vault device not available"), { sealErrno: "ENOTCONN" });
+    }
+    throw Object.assign(new Error(`vault: ${err.message}`), {
+      sealErrno: code ?? "EACCES"
+    });
+  }
+  const response = JSON.parse(responseText);
+  if (response.error) {
+    throw Object.assign(new Error(response.error), { sealErrno: response.errno ?? "EACCES" });
+  }
+  return { placeholder: response.placeholder };
+}
+function sealExitCode(errno) {
+  if (errno === "EEXIST") return 2;
+  return 4;
+}
+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";
+  return `vault error: ${errno}`;
+}
+
 // src/cli/config-verbs.ts
 function parseHeader(hdr) {
   const colonIdx = hdr.indexOf(":");
@@ -12364,6 +13339,10 @@ function parseAddFlagAt(flagArgs, i, flags) {
     flags.noProbe = true;
     return { next: i + 1 };
   }
+  if (arg === "--no-auth") {
+    flags.noAuth = true;
+    return { next: i + 1 };
+  }
   if (arg === "--bridge") {
     flags.bridge = true;
     return { next: i + 1 };
@@ -12409,6 +13388,7 @@ function parseAddFlags(args) {
     local: false,
     noProbe: false,
     bridge: false,
+    noAuth: false,
     headers: [],
     envPairs: [],
     positional: [],
@@ -12771,6 +13751,11 @@ async function runImport(platform2, args) {
   }
   return 0;
 }
+function generateBridgeToken() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
 async function runBridge(platform2, args, version) {
   if (platform2.kind === "host") {
     await platform2.write(
@@ -12797,16 +13782,56 @@ async function runBridge(platform2, args, version) {
   if (flags.bearer) {
     await platform2.write(
       2,
-      "mcpcat add --bridge: --bearer is not needed on the kernel loopback.\nThe kernel loopback is only reachable from inside the kernel and the agent.\n"
+      "mcpcat add --bridge: --bearer is not supported for bridge; authentication is automatic via the vault\n"
     );
     return 2;
   }
   const serveOptions = parseServeFlags(["--proxy", "__bridge__", "--http", "0", "--json"]);
   serveOptions.proxyCommand = flags.cmdArgs;
   const path = flags.configFile ?? (flags.local ? projectConfigPath(platform2) : userConfigPath(platform2));
+  if (flags.noAuth) {
+    await platform2.write(
+      2,
+      "mcpcat add --bridge: warning: running without authentication on loopback\n"
+    );
+    serveOptions.noAuth = true;
+    serveOptions.onListening = async (actualPort) => {
+      const bridgeUrl = `http://${actualPort}.kernel.localhost/mcp`;
+      const httpConfig = { url: bridgeUrl };
+      if (flags.description) httpConfig.description = flags.description;
+      if (flags.exposure) httpConfig.exposure = flags.exposure;
+      const { replaced } = await addServer(platform2.fs, path, name, httpConfig);
+      await platform2.write(
+        1,
+        `${replaced ? "replaced" : "added"} ${name} in ${path}
+bridge does not survive a reload; runs in the foreground (start with &)
+`
+      );
+    };
+    return runServe(platform2, serveOptions, version);
+  }
+  const token = generateBridgeToken();
+  const secretName = `MCP_${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_TOKEN`;
+  serveOptions._resolvedBearer = token;
   serveOptions.onListening = async (actualPort) => {
+    if (actualPort === 9222) {
+      await platform2.write(2, "mcpcat add --bridge: port 9222 is reserved; please retry\n");
+      return;
+    }
     const bridgeUrl = `http://${actualPort}.kernel.localhost/mcp`;
-    const httpConfig = { url: bridgeUrl };
+    try {
+      await sealSecret(platform2, secretName, token, { server: name, url: bridgeUrl });
+    } catch (err) {
+      const errno = err.sealErrno ?? "EACCES";
+      const code = sealExitCode(errno);
+      await platform2.write(2, `mcpcat add --bridge: ${sealErrorMessage(errno, secretName)}
+`);
+      platform2.exit(code);
+    }
+    const httpConfig = {
+      url: bridgeUrl,
+      headers: { Authorization: "Bearer ${" + secretName + "}" }
+    };
     if (flags.description) httpConfig.description = flags.description;
     if (flags.exposure) httpConfig.exposure = flags.exposure;
     const { replaced } = await addServer(platform2.fs, path, name, httpConfig);
@@ -12943,8 +13968,18 @@ var CONFIG_VERBS = {
   exposure: true,
   import: true
 };
-var UNIMPLEMENTED_VERBS = /* @__PURE__ */ new Set(["resources", "read", "prompts", "prompt", "complete", "task"]);
-var CLIENT_VERBS = /* @__PURE__ */ new Set(["info", "tools", "call", "describe", "serve"]);
+var UNIMPLEMENTED_VERBS = /* @__PURE__ */ new Set(["complete", "task"]);
+var CLIENT_VERBS = /* @__PURE__ */ new Set([
+  "info",
+  "tools",
+  "call",
+  "describe",
+  "serve",
+  "resources",
+  "read",
+  "prompts",
+  "prompt"
+]);
 function helpText(version) {
   return `mcpcat ${version} \u2013 a curl for the Model Context Protocol
 
@@ -12983,6 +14018,7 @@ Options:
   -H, --header 'N: V'       Extra header
   -d <json>                  Tool arguments as JSON (or @file, @- for stdin)
   -m, --timeout <s>          Request timeout (default 60)
+  --memory <MiB>             Code mode memory limit (default 256, max 1024)
   --protocol-version <v>     Pin protocol version
   --schema                   Print raw JSON Schema (describe)
   --ts                       TypeScript declarations (describe)
@@ -12999,6 +14035,31 @@ Options:
   -h, --help                 Show this help
 `;
 }
+var VERBS_WITH_TOOL = /* @__PURE__ */ new Set(["call", "prompt", "describe", "read"]);
+var VERBS_WITH_TARGET = /* @__PURE__ */ new Set([
+  "info",
+  "tools",
+  "call",
+  "describe",
+  "serve",
+  "grep",
+  "code",
+  "discover",
+  "login",
+  "logout",
+  "resources",
+  "read",
+  "prompts",
+  "prompt"
+]);
+function resolveMaxPositional(positional) {
+  if (positional.length === 0) return 3;
+  const first = positional[0];
+  if (!VERBS.includes(first)) return 2;
+  if (VERBS_WITH_TOOL.has(first)) return 3;
+  if (VERBS_WITH_TARGET.has(first)) return 2;
+  return 2;
+}
 function parseFlags(args) {
   const headers = {};
   let dataArg;
@@ -13013,10 +14074,16 @@ function parseFlags(args) {
   const serverTargets = [];
   let allowShell = false;
   let timeoutMs;
+  let memoryLimitMiB;
   let verbose = false;
   let silent = false;
   const positional = [];
   let trailingCommand;
+  let respondArg;
+  const roots = [];
+  let outputPath;
+  let noValidate = false;
+  const rest = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--") {
@@ -13057,8 +14124,41 @@ function parseFlags(args) {
       silent = true;
     } else if ((arg === "-m" || arg === "--timeout") && args[i + 1]) {
       timeoutMs = Number(args[++i]) * 1e3;
+    } else if (arg === "--respond" && args[i + 1]) {
+      respondArg = args[++i];
+    } else if (arg === "--root" && args[i + 1]) {
+      roots.push(args[++i]);
+    } else if ((arg === "-o" || arg === "--output") && args[i + 1]) {
+      outputPath = args[++i];
+    } else if (arg === "--memory" && args[i + 1]) {
+      memoryLimitMiB = Number(args[++i]);
+    } else if (arg === "--no-validate") {
+      noValidate = true;
     } else if (!arg.startsWith("-")) {
       positional.push(arg);
+      const maxPositional = resolveMaxPositional(positional);
+      if (positional.length >= maxPositional) {
+        rest.push(...args.slice(i + 1));
+        break;
+      }
+    }
+  }
+  const toolArgs = [];
+  for (let j = 0; j < rest.length; j++) {
+    const ra = rest[j];
+    if (ra === "-d" && rest[j + 1] !== void 0) {
+      dataArg = rest[++j];
+    } else if (ra === "--json") {
+      jsonOutput = true;
+    } else if (ra === "--no-validate") {
+      noValidate = true;
+    } else if ((ra === "-o" || ra === "--output") && rest[j + 1] !== void 0) {
+      outputPath = rest[++j];
+    } else if (ra === "--help" || ra === "-h") {
+      toolArgs.length = 0;
+      break;
+    } else {
+      toolArgs.push(ra);
     }
   }
   return {
@@ -13075,10 +14175,16 @@ function parseFlags(args) {
     serverTargets,
     allowShell,
     timeoutMs,
+    memoryLimitMiB,
     verbose,
     silent,
     positional,
-    trailingCommand
+    trailingCommand,
+    respondArg,
+    roots,
+    outputPath,
+    noValidate,
+    rest: toolArgs
   };
 }
 function resolveVerb(positional, trailingCommand) {
@@ -13113,6 +14219,7 @@ function parseArgs(args) {
   const resolved = resolveVerb(flags.positional, flags.trailingCommand);
   return {
     ...resolved,
+    toolArgs: flags.rest,
     headers: flags.headers,
     dataArg: flags.dataArg,
     protocolVersion: flags.protocolVersion,
@@ -13126,8 +14233,13 @@ function parseArgs(args) {
     serverTargets: flags.serverTargets,
     allowShell: flags.allowShell,
     timeoutMs: flags.timeoutMs,
+    memoryLimitMiB: flags.memoryLimitMiB,
     verbose: flags.verbose,
-    silent: flags.silent
+    silent: flags.silent,
+    noValidate: flags.noValidate,
+    respondArg: flags.respondArg,
+    roots: flags.roots,
+    outputPath: flags.outputPath
   };
 }
 function formatToolLine(tool) {
@@ -13250,7 +14362,8 @@ async function runCall(platform2, conn, toolName, dataArg, toolArgs, opts) {
     const tools = await conn.listTools();
     const tool = tools.find((t) => t.name === toolName);
     const schema = tool?.inputSchema ?? { type: "object", properties: {} };
-    const c = coerceArgsBySchema(toolArgs, schema, { noValidate: opts.noValidate });
+    const skipRequired = opts.noValidate || !!dataArg;
+    const c = coerceArgsBySchema(toolArgs, schema, { noValidate: skipRequired });
     if (!c.ok) {
       await writeErr(platform2, opts.json ?? false, "usage", c.error);
       return EXIT_USAGE;
@@ -13259,8 +14372,11 @@ async function runCall(platform2, conn, toolName, dataArg, toolArgs, opts) {
   }
   return renderCallResult(
     platform2,
-    await conn.callTool(toolName, fin, { onProgress: opts.onProgress }),
-    { json: opts.json }
+    await conn.callTool(toolName, fin, {
+      onProgress: opts.onProgress,
+      inputResponses: opts.inputResponses
+    }),
+    { json: opts.json, outputPath: opts.outputPath }
   );
 }
 async function runDescribe(platform2, conn, toolName, showSchema, json) {
@@ -13297,19 +14413,168 @@ async function runDescribe(platform2, conn, toolName, showSchema, json) {
   }
   return EXIT_OK;
 }
-async function runVerb(platform2, parsed, conn, onProgress) {
+async function runResources(platform2, conn, json) {
+  const resources = await conn.listResources();
+  const templates = await conn.listResourceTemplates();
+  if (json) {
+    await renderResourcesJson(platform2, resources, templates);
+    return EXIT_OK;
+  }
+  if (resources.length === 0 && templates.length === 0) {
+    await platform2.write(1, "(no resources)\n");
+    return EXIT_OK;
+  }
+  for (const r of resources) {
+    const desc = r.description ? `  ${r.description}` : "";
+    const mime = r.mimeType ? ` [${r.mimeType}]` : "";
+    await platform2.write(1, `${r.uri}  ${r.name}${mime}${desc}
+`);
+  }
+  if (templates.length > 0) {
+    if (resources.length > 0) await platform2.write(1, "\n");
+    await platform2.write(1, "Templates:\n");
+    for (const t of templates) {
+      const desc = t.description ? `  ${t.description}` : "";
+      await platform2.write(1, `  ${t.uriTemplate}  ${t.name}${desc}
+`);
+    }
+  }
+  return EXIT_OK;
+}
+async function runRead(platform2, conn, uri, json, outputPath) {
+  const result = await conn.readResource(uri);
+  if (json) {
+    await renderReadResourceJson(platform2, result);
+    return EXIT_OK;
+  }
+  for (const content of result.contents) {
+    if ("text" in content) {
+      if (outputPath) {
+        await platform2.fs.writeFile(outputPath, content.text);
+        await platform2.write(1, `${outputPath}
+`);
+      } else {
+        await platform2.write(1, `${content.text}
+`);
+      }
+    } else if ("blob" in content) {
+      if (outputPath) {
+        const bytes = Uint8Array.from(atob(content.blob), (c) => c.charCodeAt(0));
+        await platform2.fs.writeFile(outputPath, bytes);
+        await platform2.write(1, `${outputPath}
+`);
+      } else {
+        await platform2.write(1, `${content.blob}
+`);
+      }
+    }
+  }
+  return EXIT_OK;
+}
+async function runPrompts(platform2, conn, json) {
+  const prompts = await conn.listPrompts();
+  if (json) {
+    await renderPromptsJson(platform2, prompts);
+    return EXIT_OK;
+  }
+  if (prompts.length === 0) {
+    await platform2.write(1, "(no prompts)\n");
+    return EXIT_OK;
+  }
+  for (const p of prompts) {
+    const desc = p.description ? `  ${p.description}` : "";
+    await platform2.write(1, `${p.name}${desc}
+`);
+  }
+  return EXIT_OK;
+}
+async function runPrompt(platform2, conn, name, dataArg, toolArgs, json) {
+  let args = {};
+  if (dataArg) {
+    args = await readDataArg(platform2, dataArg);
+  }
+  const prompts = await conn.listPrompts();
+  const prompt = prompts.find((p) => p.name === name);
+  const schema = {
+    type: "object",
+    properties: {},
+    required: []
+  };
+  if (prompt?.arguments) {
+    const props = {};
+    const req = [];
+    for (const a of prompt.arguments) {
+      props[a.name] = { type: "string", description: a.description };
+      if (a.required) req.push(a.name);
+    }
+    schema.properties = props;
+    schema.required = req;
+  }
+  if (toolArgs.length > 0) {
+    const skipRequired = !!dataArg;
+    const c = coerceArgsBySchema(toolArgs, schema, { noValidate: skipRequired });
+    if (!c.ok) {
+      await writeErr(platform2, json, "usage", c.error);
+      return EXIT_USAGE;
+    }
+    args = mergeArgs(args, c.value);
+  } else if (!dataArg) {
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    for (const r of required) {
+      if (!Object.hasOwn(args, r)) {
+        await writeErr(platform2, json, "usage", `missing required flag --${r}`);
+        return EXIT_USAGE;
+      }
+    }
+  }
+  const result = await conn.getPrompt(name, args);
+  if (json) {
+    await renderPromptResultJson(platform2, result);
+    return EXIT_OK;
+  }
+  if (result.description) {
+    await platform2.write(1, `${result.description}
+
+`);
+  }
+  for (const msg of result.messages) {
+    const text = msg.content?.text ?? (msg.content?.data ? `[${msg.content.mimeType ?? "binary"}]` : "");
+    await platform2.write(1, `[${msg.role}] ${text}
+`);
+  }
+  return EXIT_OK;
+}
+async function runVerb(platform2, parsed, conn, onProgress, respondData) {
   switch (parsed.verb) {
     case "info":
       return runInfo(platform2, conn, parsed.jsonOutput);
     case "tools":
       return runTools(platform2, conn, parsed.jsonOutput);
     case "call":
-      return runCall(platform2, conn, parsed.toolName, parsed.dataArg, [], {
+      return runCall(platform2, conn, parsed.toolName, parsed.dataArg, parsed.toolArgs, {
         json: parsed.jsonOutput,
-        onProgress
+        noValidate: parsed.noValidate,
+        outputPath: parsed.outputPath,
+        onProgress,
+        inputResponses: respondData
       });
     case "describe":
       return runDescribe(platform2, conn, parsed.toolName, parsed.showSchema, parsed.jsonOutput);
+    case "resources":
+      return runResources(platform2, conn, parsed.jsonOutput);
+    case "read":
+      return runRead(platform2, conn, parsed.toolName, parsed.jsonOutput, parsed.outputPath);
+    case "prompts":
+      return runPrompts(platform2, conn, parsed.jsonOutput);
+    case "prompt":
+      return runPrompt(
+        platform2,
+        conn,
+        parsed.toolName,
+        parsed.dataArg,
+        parsed.toolArgs,
+        parsed.jsonOutput
+      );
     default:
       await platform2.write(2, `mcpcat: unknown command '${parsed.verb}'
 `);
@@ -13447,6 +14712,18 @@ async function resolveTargetNames(platform2, parsed) {
   return config.list().filter((e) => e.config.enabled !== false).map((e) => e.name);
 }
 async function dispatchMultiTarget(platform2, parsed, version) {
+  let activeCleanup;
+  async function killTreeAndExit(exitCode) {
+    if (activeCleanup) {
+      try {
+        await Promise.race([activeCleanup(), new Promise((r) => setTimeout(r, 3e3))]);
+      } catch {
+      }
+    }
+    platform2.exit(exitCode);
+  }
+  platform2.onSignal?.("SIGTERM", () => void killTreeAndExit(143));
+  platform2.onSignal?.("SIGHUP", () => void killTreeAndExit(129));
   const config = await MergedConfigSource.load(platform2);
   if (parsed.verb === "code") {
     let source;
@@ -13478,10 +14755,12 @@ async function dispatchMultiTarget(platform2, parsed, version) {
       parsed,
       version
     );
+    activeCleanup = cleanup;
     try {
       return await runCode(targets, source, {
         json: parsed.jsonOutput,
         timeoutMs: parsed.timeoutMs,
+        memoryLimitMiB: parsed.memoryLimitMiB,
         allowShell: parsed.allowShell,
         platform: platform2
       });
@@ -13507,6 +14786,7 @@ async function dispatchMultiTarget(platform2, parsed, version) {
       parsed,
       version
     );
+    activeCleanup = cleanup;
     try {
       return await runGrep(platform2, pattern, targets, {
         rank: parsed.rank,
@@ -13525,6 +14805,7 @@ async function dispatchMultiTarget(platform2, parsed, version) {
       parsed,
       version
     );
+    activeCleanup = cleanup;
     try {
       return await runDescribeTs(platform2, targets, parsed.tsBudget);
     } finally {
@@ -13534,6 +14815,18 @@ async function dispatchMultiTarget(platform2, parsed, version) {
   return 2;
 }
 async function run(platform2, version, args) {
+  try {
+    return await runInner(platform2, version, args);
+  } catch (err) {
+    if (err.code === "EACCES") {
+      await platform2.write(2, `mcpcat: ${err.message}
+`);
+      return EXIT_USAGE;
+    }
+    throw err;
+  }
+}
+async function runInner(platform2, version, args) {
   if (args.includes("--version") || args.includes("-V")) {
     await platform2.write(1, `${version}
 `);
@@ -13560,11 +14853,11 @@ async function run(platform2, version, args) {
   const discResult = await dispatchDiscoveryVerb(platform2, parsed, args);
   if (discResult !== void 0) return discResult;
   if (parsed.verb === "login") {
-    const source = createTokenSource(platform2);
+    const source = await createTokenSource(platform2);
     return runLogin(platform2, args.slice(1), source);
   }
   if (parsed.verb === "logout") {
-    const source = createTokenSource(platform2);
+    const source = await createTokenSource(platform2);
     return runLogout(platform2, args.slice(1), source);
   }
   if (UNIMPLEMENTED_VERBS.has(parsed.verb)) {
@@ -13587,6 +14880,14 @@ async function run(platform2, version, args) {
     await platform2.write(2, "mcpcat: call requires a tool name\n");
     return 2;
   }
+  if (parsed.verb === "read" && !parsed.toolName) {
+    await platform2.write(2, "mcpcat: read requires a URI\n");
+    return 2;
+  }
+  if (parsed.verb === "prompt" && !parsed.toolName) {
+    await platform2.write(2, "mcpcat: prompt requires a name\n");
+    return 2;
+  }
   if (!parsed.target) {
     await platform2.write(2, `mcpcat: ${parsed.verb} requires a target
 `);
@@ -13597,13 +14898,19 @@ async function run(platform2, version, args) {
 function expandAndCollect(headers, env2) {
   const secrets = [];
   const result = {};
+  const unset = [];
   for (const [k, v] of Object.entries(headers)) {
+    const missing = missingPlaceholders(v, env2);
+    if (missing.length > 0) {
+      unset.push(...missing);
+      continue;
+    }
     const e = expandPlaceholders(v, env2);
     result[k] = e;
     if (e !== v) secrets.push(e);
     if (v.length > 0) secrets.push(v);
   }
-  return { expanded: result, secrets };
+  return { expanded: result, secrets, unset };
 }
 function classifyError(err) {
   if (err instanceof InputRequiredError) {
@@ -13615,6 +14922,9 @@ function classifyError(err) {
   if (err instanceof McpAuthError) {
     return { code: EXIT_AUTH, kind: "auth", msg: err.message };
   }
+  if (err instanceof JerkSignInRequiredError) {
+    return { code: EXIT_AUTH, kind: "auth", msg: err.message };
+  }
   if (err instanceof AuthStepUpError) {
     const scopeHint = err.scope ? ` --scope ${err.scope}` : "";
     return {
@@ -13636,25 +14946,112 @@ function classifyError(err) {
   }
   return { code: EXIT_RPC_ERROR, kind: "rpc_error", msg };
 }
-function resolveAuthProvider(platform2, hasAuthHeader, url, target, config) {
+async function resolveAuthProvider(platform2, hasAuthHeader, url, target, config) {
   if (hasAuthHeader || !url) return void 0;
-  const source = createTokenSource(platform2);
+  const source = await createTokenSource(platform2);
   const entry = config.entry(target);
   const oauth = entry && "url" in entry.config ? entry.config.oauth : void 0;
   const name = entry ? target : `url:${new URL(url).origin}${new URL(url).pathname}`;
   return createMcpAuthProvider({ name, serverUrl: url, source, oauth, platform: platform2 });
 }
+function classifyConnectionError(err, target, interrupted) {
+  if (err instanceof McpAuthError || err instanceof AuthStepUpError || err instanceof JerkSignInRequiredError) {
+    return classifyError(err);
+  }
+  if (err.name === "McpOAuthAuthorizationRequiredError" || err.name === "McpAuthRequiredError") {
+    return { code: EXIT_AUTH, kind: "auth", msg: `unauthorized. Run: mcpcat login ${target}` };
+  }
+  if (interrupted) {
+    return { code: EXIT_INTERRUPTED, kind: "interrupted", msg: "interrupted" };
+  }
+  const msg = transportHint(err) ?? `connection failed: ${err.message}`;
+  return { code: EXIT_CONNECTION, kind: "connection", msg };
+}
+function buildRoots(rootArgs, isStdio, cwd) {
+  const roots = rootArgs.map((r) => ({
+    uri: r.startsWith("file://") ? r : `file://${r}`
+  }));
+  if (roots.length === 0 && isStdio) {
+    roots.push({ uri: `file://${cwd}` });
+  }
+  return roots.length > 0 ? roots : void 0;
+}
+async function loadRespondData(platform2, respondArg, json) {
+  if (!respondArg) return { data: void 0 };
+  try {
+    return { data: await readDataArg(platform2, respondArg) };
+  } catch (err) {
+    await writeErr(
+      platform2,
+      json,
+      "usage",
+      `invalid --respond argument: ${err.message}`
+    );
+    return { exitCode: EXIT_USAGE };
+  }
+}
+async function handleInputRequired(platform2, conn, err, respondData, json) {
+  const parsed2 = JSON.parse(err.requestJson);
+  const inputReq = parseInputRequest(parsed2.result ?? parsed2);
+  if (!inputReq) {
+    await platform2.write(2, `${err.requestJson}
+`);
+    return EXIT_INPUT_REQUIRED;
+  }
+  const isTty = platform2.isatty(0);
+  const elicitResult = await handleElicitation(platform2, inputReq, isTty, respondData);
+  if ("exitCode" in elicitResult) {
+    await platform2.write(2, `${err.requestJson}
+`);
+    return EXIT_INPUT_REQUIRED;
+  }
+  try {
+    const retryResult = await conn.callTool(parsed2.name, {
+      ...parsed2.arguments,
+      _meta: { inputResponses: elicitResult.answers }
+    });
+    return renderCallResult(platform2, retryResult, { json });
+  } catch (retryErr) {
+    const e2 = classifyError(retryErr);
+    await writeErr(platform2, json, e2.kind, e2.msg);
+    return e2.code;
+  }
+}
 async function runClientVerb(platform2, version, parsed) {
-  const { expanded, secrets } = expandAndCollect(parsed.headers, platform2.env);
+  const { expanded, secrets, unset } = expandAndCollect(parsed.headers, platform2.env);
+  if (unset.length > 0) {
+    await platform2.write(
+      2,
+      `mcpcat: unset variable${unset.length > 1 ? "s" : ""} in -H: ${unset.join(", ")}
+`
+    );
+    return EXIT_USAGE;
+  }
   const verbose = createVerboseLogger(platform2, parsed.verbose);
   for (const s of secrets) verbose.secrets.add(s);
   const timeoutMs = parsed.timeoutMs;
   const sigintController = new AbortController();
   let interrupted = false;
+  let termExitCode = EXIT_INTERRUPTED;
+  let activeConn;
+  async function killTreeAndExit(exitCode) {
+    interrupted = true;
+    termExitCode = exitCode;
+    sigintController.abort();
+    if (activeConn) {
+      try {
+        await Promise.race([activeConn.close(), new Promise((r) => setTimeout(r, 3e3))]);
+      } catch {
+      }
+    }
+    platform2.exit(exitCode);
+  }
   platform2.onSignal?.("SIGINT", () => {
     interrupted = true;
     sigintController.abort();
   });
+  platform2.onSignal?.("SIGTERM", () => void killTreeAndExit(143));
+  platform2.onSignal?.("SIGHUP", () => void killTreeAndExit(129));
   const showProgress = !parsed.silent && (parsed.verbose || platform2.isatty(2));
   const onProgress = (progress, total, message) => {
     if (!showProgress) return;
@@ -13673,59 +15070,91 @@ async function runClientVerb(platform2, version, parsed) {
     await writeErr(platform2, parsed.jsonOutput, "usage", err.message);
     return EXIT_USAGE;
   }
-  const hasAuthHeader = "Authorization" in expanded;
-  const authProvider = resolveAuthProvider(platform2, hasAuthHeader, resolved.url, target, config);
+  const configHeaders = expandHeaders(resolved.headers, platform2.env, (msg) => {
+    platform2.write(2, `mcpcat: warning: ${msg}
+`).catch(() => {
+    });
+  });
+  const configSecrets = collectConfigSecrets(resolved.headers, platform2.env);
+  for (const s of configSecrets) verbose.secrets.add(s);
+  const allSecrets = /* @__PURE__ */ new Set([...secrets, ...configSecrets]);
+  const redact2 = (text) => {
+    let result = text;
+    for (const secret of allSecrets) {
+      if (secret.length > 0) {
+        while (result.includes(secret)) {
+          result = result.replace(secret, "[REDACTED]");
+        }
+      }
+    }
+    return result;
+  };
+  const mergedHeaders = { ...configHeaders, ...expanded };
+  const hasAuthHeader = "Authorization" in mergedHeaders;
+  const authProvider = await resolveAuthProvider(
+    platform2,
+    hasAuthHeader,
+    resolved.url,
+    target,
+    config
+  );
+  const roots = buildRoots(parsed.roots, !!resolved.command, platform2.cwd);
+  let respondData;
+  if (parsed.respondArg) {
+    const loaded = await loadRespondData(platform2, parsed.respondArg, parsed.jsonOutput);
+    if ("exitCode" in loaded) return loaded.exitCode;
+    respondData = loaded.data;
+  }
   let conn;
   try {
     conn = await connect(platform2, {
       ...resolved,
-      headers: { ...resolved.headers, ...expanded },
+      headers: mergedHeaders,
       protocolVersion: parsed.protocolVersion,
       version,
       timeoutMs,
       signal: sigintController.signal,
       verbose,
-      authProvider
+      authProvider,
+      roots
     });
+    activeConn = conn;
   } catch (err) {
-    if (err instanceof McpAuthError || err instanceof AuthStepUpError) {
-      const e = classifyError(err);
-      await writeErr(platform2, parsed.jsonOutput, e.kind, e.msg);
-      return EXIT_AUTH;
-    }
-    if (err.name === "McpOAuthAuthorizationRequiredError" || err.name === "McpAuthRequiredError") {
-      await writeErr(
+    if (isSpawnNotFound(err)) {
+      await writeErrRedacted(
         platform2,
         parsed.jsonOutput,
-        "auth",
-        `unauthorized. Run: mcpcat login ${target}`
+        "connection",
+        `command not found: ${resolved.command}`,
+        redact2
       );
-      return EXIT_AUTH;
+      return EXIT_CONNECTION;
     }
-    const msg = transportHint(err) ?? `connection failed: ${err.message}`;
-    if (interrupted) {
+    const e = classifyConnectionError(err, target, interrupted);
+    if (e.code === EXIT_INTERRUPTED) {
       await platform2.write(2, "mcpcat: interrupted\n");
-      return EXIT_INTERRUPTED;
+      return termExitCode;
     }
-    await writeErr(platform2, parsed.jsonOutput, "connection", msg);
-    return EXIT_CONNECTION;
+    await writeErrRedacted(platform2, parsed.jsonOutput, e.kind, e.msg, redact2);
+    return e.code;
   }
   try {
-    const code = await runVerb(platform2, parsed, conn, onProgress);
+    const code = await runVerb(platform2, parsed, conn, onProgress, respondData);
     if (interrupted) {
       await platform2.write(2, "mcpcat: interrupted\n");
-      return EXIT_INTERRUPTED;
+      return termExitCode;
     }
     return code;
   } catch (err) {
     if (interrupted) {
       await platform2.write(2, "mcpcat: interrupted\n");
-      return EXIT_INTERRUPTED;
+      return termExitCode;
+    }
+    if (err instanceof InputRequiredError) {
+      return handleInputRequired(platform2, conn, err, respondData, parsed.jsonOutput);
     }
     const e = classifyError(err);
-    if (err instanceof InputRequiredError) await platform2.write(2, `${e.msg}
-`);
-    else await writeErr(platform2, parsed.jsonOutput, e.kind, e.msg);
+    await writeErrRedacted(platform2, parsed.jsonOutput, e.kind, e.msg, redact2);
     return e.code;
   } finally {
     try {
@@ -13739,6 +15168,28 @@ async function writeErr(p, json, kind, msg) {
   else await p.write(2, `mcpcat: ${msg}
 `);
 }
+async function writeErrRedacted(p, json, kind, msg, redact2) {
+  if (json) await renderErrorJson(p, kind, msg, void 0, void 0, redact2);
+  else await p.write(2, `mcpcat: ${redact2(msg)}
+`);
+}
+function collectConfigSecrets(headers, env2) {
+  if (!headers) return [];
+  const secrets = [];
+  for (const [, v] of Object.entries(headers)) {
+    const expanded = expandPlaceholders(v, env2);
+    if (expanded !== v && expanded.length > 0) secrets.push(expanded);
+    if (v.length > 0 && v !== expanded) secrets.push(v);
+  }
+  return secrets;
+}
+function isSpawnNotFound(err) {
+  if (!(err instanceof Error)) return false;
+  const code = err.code;
+  if (code === "ENOENT" || code === "EACCES") return true;
+  const msg = err.message;
+  return msg.includes("ENOENT") || msg.includes("EACCES");
+}
 
 // src/platform/kernel.ts
 function kernelFs(ctx) {
@@ -13750,15 +15201,20 @@ function kernelFs(ctx) {
     stat: (path) => ctx.fs.stat(path),
     exists: (path) => ctx.fs.exists(path),
     async mkdirExclusive(path) {
-      const exists = await ctx.fs.exists(path);
-      if (exists) {
-        const err = new Error(`EEXIST: directory already exists, mkdir '${path}'`);
-        err.code = "EEXIST";
+      try {
+        await ctx.fs.mkdir(path);
+      } catch (err) {
+        const msg = err.message ?? "";
+        if (msg.includes("EEXIST") || msg.includes("already exists")) {
+          const wrapped = new Error(`EEXIST: directory already exists, mkdir '${path}'`);
+          wrapped.code = "EEXIST";
+          throw wrapped;
+        }
         throw err;
       }
-      await ctx.fs.mkdir(path);
     },
-    rmdir: (path) => ctx.fs.rm(path)
+    rmdir: (path) => ctx.fs.rm(path),
+    unlink: (path) => ctx.fs.unlink(path)
   };
 }
 async function kernelSpawn(ctx, options) {
@@ -13822,11 +15278,149 @@ async function kernelListen(ctx, options) {
     }
   };
 }
+var KERNEL_LOCALHOST_RE = /^(\d+)\.kernel\.localhost$/;
+function extractLoopbackPort(url) {
+  const m = KERNEL_LOCALHOST_RE.exec(url.hostname);
+  if (m) return Number(m[1]);
+  return null;
+}
+function collectHeaders(init) {
+  const entries = [];
+  if (!init?.headers) return entries;
+  if (init.headers instanceof Headers) {
+    for (const [k, v] of init.headers.entries()) entries.push([k, v]);
+  } else if (Array.isArray(init.headers)) {
+    for (const pair of init.headers) entries.push(pair);
+  } else {
+    for (const [k, v] of Object.entries(init.headers)) {
+      if (v != null) entries.push([k, String(v)]);
+    }
+  }
+  return entries;
+}
+function buildHttpRequest(method, url, headerEntries, bodyBytes) {
+  const enc = new TextEncoder();
+  const has = (n) => headerEntries.some(([k]) => k.toLowerCase() === n.toLowerCase());
+  if (!has("host")) headerEntries.push(["Host", url.host]);
+  if (!has("connection")) headerEntries.push(["Connection", "close"]);
+  if (bodyBytes.length > 0 && !has("content-length")) {
+    headerEntries.push(["Content-Length", String(bodyBytes.length)]);
+  }
+  const target = url.pathname + (url.search || "");
+  let reqText = `${method} ${target} HTTP/1.1\r
+`;
+  for (const [k, v] of headerEntries) reqText += `${k}: ${v}\r
+`;
+  reqText += "\r\n";
+  const headBytes = enc.encode(reqText);
+  if (bodyBytes.length === 0) return headBytes;
+  const full = new Uint8Array(headBytes.length + bodyBytes.length);
+  full.set(headBytes);
+  full.set(bodyBytes, headBytes.length);
+  return full;
+}
+function parseHttpResponse(buf, headerPos, bufLen) {
+  const dec = new TextDecoder();
+  const headerText = dec.decode(new Uint8Array(buf.buffer, buf.byteOffset, headerPos));
+  const lines = headerText.split("\r\n");
+  const statusMatch = /^HTTP\/1\.1\s+(\d+)\s*(.*)/.exec(lines[0] || "");
+  const status = statusMatch ? Number(statusMatch[1]) : 500;
+  const statusText = statusMatch ? statusMatch[2] : "Error";
+  const respHeaders = {};
+  for (let i = 1; i < lines.length; i++) {
+    const colonIdx = lines[i].indexOf(":");
+    if (colonIdx > 0) {
+      respHeaders[lines[i].slice(0, colonIdx).trim().toLowerCase()] = lines[i].slice(colonIdx + 1).trim();
+    }
+  }
+  const contentLength = Number(respHeaders["content-length"] ?? 0);
+  const headerEndByte = headerPos + 4;
+  const responseBody = dec.decode(buf.slice(headerEndByte, headerEndByte + contentLength));
+  return { status, statusText, headers: respHeaders, body: responseBody };
+}
+async function kernelLoopbackFetch(ctx, url, port, init) {
+  const method = (init?.method ?? "GET").toUpperCase();
+  const enc = new TextEncoder();
+  const dec = new TextDecoder();
+  let bodyStr = "";
+  if (init?.body != null) {
+    bodyStr = typeof init.body === "string" ? init.body : dec.decode(init.body);
+  }
+  const bodyBytes = enc.encode(bodyStr);
+  const headerEntries = collectHeaders(init);
+  const reqBytes = buildHttpRequest(method, url, headerEntries, bodyBytes);
+  const conn = await ctx.net.connect({ host: "127.0.0.1", port });
+  const writer = conn.writable.getWriter();
+  await writer.write(reqBytes);
+  const reader = conn.readable.getReader();
+  let buf = new Uint8Array(4096);
+  let bufLen = 0;
+  const headerResult = await readUntil(reader, buf, bufLen, "\r\n\r\n", 16384);
+  if (!headerResult) {
+    reader.releaseLock();
+    try {
+      await writer.close();
+    } catch {
+    }
+    conn.close();
+    throw new Error("incomplete HTTP response headers");
+  }
+  buf = headerResult.buf;
+  bufLen = headerResult.bufLen;
+  const contentLength = Number(
+    dec.decode(new Uint8Array(buf.buffer, buf.byteOffset, headerResult.pos)).split("\r\n").find((l) => l.toLowerCase().startsWith("content-length:"))?.split(":")[1]?.trim() ?? 0
+  );
+  const totalNeeded = headerResult.pos + 4 + contentLength;
+  if (bufLen < totalNeeded && contentLength > 0) {
+    const bodyResult = await readExact(reader, buf, bufLen, totalNeeded);
+    if (bodyResult) {
+      buf = bodyResult.buf;
+      bufLen = bodyResult.bufLen;
+    }
+  }
+  const parsed = parseHttpResponse(buf, headerResult.pos, bufLen);
+  reader.releaseLock();
+  try {
+    await writer.close();
+  } catch {
+  }
+  conn.close();
+  return new Response(parsed.body, {
+    status: parsed.status,
+    statusText: parsed.statusText,
+    headers: parsed.headers
+  });
+}
+function createKernelFetch(ctx) {
+  return async (input, init) => {
+    const urlStr = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    let url;
+    try {
+      url = new URL(urlStr);
+    } catch {
+      return ctx.fetch(input, init);
+    }
+    const port = extractLoopbackPort(url);
+    if (port !== null) return kernelLoopbackFetch(ctx, url, port, init);
+    return ctx.fetch(input, init);
+  };
+}
+async function kernelSeal(ctx, request) {
+  const f = await ctx.open("/dev/sealed", { read: true, write: true });
+  try {
+    const enc = new TextEncoder();
+    await f.write(0, enc.encode(request));
+    const responseBytes = await f.read(0, 65536);
+    return new TextDecoder().decode(responseBytes);
+  } finally {
+    await f.close();
+  }
+}
 function createKernelPlatform(ctx, options) {
   const encoder2 = new TextEncoder();
   return {
     kind: "kernel",
-    fetch: ctx.fetch,
+    fetch: createKernelFetch(ctx),
     spawn: (options2) => kernelSpawn(ctx, options2),
     listen: (options2) => kernelListen(ctx, options2),
     fs: kernelFs(ctx),
@@ -13845,17 +15439,26 @@ function createKernelPlatform(ctx, options) {
     onSignal(signal, handler) {
       ctx.signals.on(signal, handler);
     },
+    async seal(request) {
+      return kernelSeal(ctx, request);
+    },
     packageDir: options?.packageDir
   };
 }
 
 // src/kernel.ts
 async function main(ctx) {
+  if (ctx.signals?.ignore) {
+    try {
+      ctx.signals.ignore("SIGPIPE");
+    } catch {
+    }
+  }
   const platform2 = createKernelPlatform(ctx, {
     packageDir: "/node_modules/@ai-ecoverse/mcpcat"
   });
   const args = ctx.argv.slice(1);
-  return run(platform2, "0.12.0", args);
+  return run(platform2, "0.13.0", args);
 }
 export {
   main as default