@ai-ecoverse/mcpcat 0.0.0 → 0.2.0

package/dist/kernel/mcpcat.mjs

@@ -0,0 +1,2038 @@
+// node_modules/@earendil-works/pi-mcp/dist/protocol/jsonrpc.js
+var JSON_RPC_ERROR_CODES = {
+  parseError: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internalError: -32603
+};
+var McpError = class extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "McpError";
+    this.code = code;
+    this.data = data;
+  }
+};
+var McpConnectionClosedError = class extends Error {
+  constructor(message = "MCP connection closed") {
+    super(message);
+    this.name = "McpConnectionClosedError";
+  }
+};
+var McpTimeoutError = class extends Error {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`MCP request timed out after ${timeoutMs}ms`);
+    this.name = "McpTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var McpAbortError = class extends Error {
+  constructor(message = "MCP request aborted") {
+    super(message);
+    this.name = "AbortError";
+  }
+};
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function isJsonRpcId(value) {
+  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function isJsonRpcRequest(message) {
+  return isObject(message) && message.jsonrpc === "2.0" && isJsonRpcId(message.id) && typeof message.method === "string";
+}
+function isJsonRpcNotification(message) {
+  return isObject(message) && message.jsonrpc === "2.0" && !("id" in message) && typeof message.method === "string";
+}
+function isJsonRpcResponse(message) {
+  if (!isObject(message) || message.jsonrpc !== "2.0" || !isJsonRpcId(message.id))
+    return false;
+  if ("result" in message)
+    return !("error" in message);
+  if (!("error" in message) || !isObject(message.error))
+    return false;
+  return typeof message.error.code === "number" && typeof message.error.message === "string";
+}
+function parseJsonRpcMessage(value) {
+  if (isJsonRpcRequest(value) || isJsonRpcNotification(value) || isJsonRpcResponse(value))
+    return value;
+  throw new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid JSON-RPC message");
+}
+
+// node_modules/@earendil-works/pi-mcp/dist/protocol/types.js
+var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05"];
+
+// node_modules/@earendil-works/pi-mcp/dist/client.js
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var MAX_LIST_PAGES = 1e3;
+function validateInitializeResult(value) {
+  if (!isObject(value) || typeof value.protocolVersion !== "string" || !isObject(value.capabilities) || !isObject(value.serverInfo) || typeof value.serverInfo.name !== "string" || typeof value.serverInfo.version !== "string" || value.instructions !== void 0 && typeof value.instructions !== "string") {
+    throw new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid MCP initialize result");
+  }
+  return value;
+}
+function invalid(message) {
+  return new McpError(JSON_RPC_ERROR_CODES.invalidRequest, message);
+}
+function validateListPage(method, key, value, isItem) {
+  const items = isObject(value) ? value[key] : void 0;
+  if (!isObject(value) || !Array.isArray(items))
+    throw invalid(`Invalid MCP ${method} result`);
+  for (const item of items) {
+    if (!isObject(item) || !isItem(item))
+      throw invalid(`Invalid entry in MCP ${method} result`);
+  }
+  const nextCursor = value.nextCursor === null || value.nextCursor === "" ? void 0 : value.nextCursor;
+  if (nextCursor !== void 0 && typeof nextCursor !== "string")
+    throw invalid(`Invalid MCP ${method} cursor`);
+  return { items, ...nextCursor === void 0 ? {} : { nextCursor } };
+}
+var isTool = (tool) => typeof tool.name === "string" && isObject(tool.inputSchema);
+var isResource = (resource) => typeof resource.uri === "string" && (resource.name === void 0 || typeof resource.name === "string");
+var isResourceTemplate = (template) => typeof template.uriTemplate === "string" && (template.name === void 0 || typeof template.name === "string");
+function toResource(item) {
+  return { ...item, name: item.name ?? item.uri };
+}
+function toResourceTemplate(item) {
+  return { ...item, name: item.name ?? item.uriTemplate };
+}
+function pageCursor(page) {
+  return page.nextCursor === void 0 ? {} : { nextCursor: page.nextCursor };
+}
+function validateReadResourceResult(value) {
+  if (!isObject(value) || !Array.isArray(value.contents))
+    throw invalid("Invalid MCP resources/read result");
+  for (const contents of value.contents) {
+    if (!isObject(contents) || typeof contents.uri !== "string" || typeof contents.text !== "string" && typeof contents.blob !== "string") {
+      throw invalid("Invalid contents in MCP resources/read result");
+    }
+  }
+  return value;
+}
+function validateCallToolResult(value) {
+  if (!isObject(value) || value.content !== void 0 && !Array.isArray(value.content)) {
+    throw new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid MCP tools/call result");
+  }
+  return value.content === void 0 ? { ...value, content: [] } : value;
+}
+var McpClient = class {
+  options;
+  state = "idle";
+  transport;
+  nextRequestId = 1;
+  serverInfoValue;
+  serverCapabilitiesValue;
+  instructionsValue;
+  protocolVersionValue;
+  pending = /* @__PURE__ */ new Map();
+  progressRequests = /* @__PURE__ */ new Map();
+  incoming = /* @__PURE__ */ new Map();
+  requestHandlers = /* @__PURE__ */ new Map();
+  notificationListeners = /* @__PURE__ */ new Map();
+  errorListeners = /* @__PURE__ */ new Set();
+  closeListeners = /* @__PURE__ */ new Set();
+  disposers = [];
+  constructor(options) {
+    this.options = Object.freeze({ ...options });
+    this.requestHandlers.set("ping", () => ({}));
+    const roots = options.roots;
+    if (roots) {
+      this.requestHandlers.set("roots/list", async () => ({
+        roots: [...typeof roots === "function" ? await roots() : roots]
+      }));
+    }
+  }
+  get connectionState() {
+    return this.state;
+  }
+  get serverInfo() {
+    return this.serverInfoValue;
+  }
+  get serverCapabilities() {
+    return this.serverCapabilitiesValue;
+  }
+  get instructions() {
+    return this.instructionsValue;
+  }
+  get protocolVersion() {
+    return this.protocolVersionValue;
+  }
+  async connect(transport) {
+    if (this.state !== "idle")
+      throw new Error(`Cannot connect MCP client in ${this.state} state`);
+    this.state = "connecting";
+    this.transport = transport;
+    this.disposers = [
+      transport.onMessage((message) => this.handleMessage(message)),
+      // Transport errors are reported only. Pending requests fail when the transport closes.
+      transport.onError((error) => this.emitError(error)),
+      transport.onClose(() => this.handleTransportClose())
+    ];
+    try {
+      await transport.start();
+      const capabilities = { ...this.options.capabilities };
+      if (this.options.roots && capabilities.roots === void 0)
+        capabilities.roots = {};
+      const result = validateInitializeResult(await this.requestInternal("initialize", {
+        protocolVersion: this.options.protocolVersion ?? LATEST_PROTOCOL_VERSION,
+        capabilities,
+        clientInfo: {
+          name: this.options.name,
+          version: this.options.version,
+          ...this.options.title === void 0 ? {} : { title: this.options.title }
+        }
+      }, {}, true));
+      if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) {
+        throw new Error(`MCP server selected unsupported protocol version ${result.protocolVersion}`);
+      }
+      this.protocolVersionValue = result.protocolVersion;
+      this.serverInfoValue = result.serverInfo;
+      this.serverCapabilitiesValue = result.capabilities;
+      this.instructionsValue = result.instructions;
+      transport.setProtocolVersion?.(result.protocolVersion);
+      await this.notifyInternal("notifications/initialized", void 0, true);
+      this.state = "connected";
+      return result;
+    } catch (error) {
+      await this.close().catch(() => {
+      });
+      throw error;
+    }
+  }
+  request(method, params, options = {}) {
+    return this.requestInternal(method, params, options, false);
+  }
+  notify(method, params) {
+    return this.notifyInternal(method, params, false);
+  }
+  setRequestHandler(method, handler) {
+    this.requestHandlers.set(method, handler);
+    return () => {
+      if (this.requestHandlers.get(method) === handler)
+        this.requestHandlers.delete(method);
+    };
+  }
+  onNotification(method, listener) {
+    const listeners = this.notificationListeners.get(method) ?? /* @__PURE__ */ new Set();
+    this.notificationListeners.set(method, listeners);
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0)
+        this.notificationListeners.delete(method);
+    };
+  }
+  onError(listener) {
+    this.errorListeners.add(listener);
+    return () => this.errorListeners.delete(listener);
+  }
+  /** Called once when the connection closes, whether the transport dropped or `close()` was called. */
+  onClose(listener) {
+    this.closeListeners.add(listener);
+    return () => this.closeListeners.delete(listener);
+  }
+  async ping(options = {}) {
+    await this.request("ping", void 0, options);
+  }
+  async listTools(options = {}) {
+    return await this.listAll("tools/list", "tools", isTool, options);
+  }
+  /** Every resource, following `nextCursor` through all pages. */
+  async listResources(options = {}) {
+    return (await this.listAll("resources/list", "resources", isResource, options)).map(toResource);
+  }
+  /** One page of resources, starting at `cursor`. */
+  async listResourcesPage(cursor, options = {}) {
+    const page = await this.listPage("resources/list", "resources", isResource, cursor, options);
+    return { resources: page.items.map(toResource), ...pageCursor(page) };
+  }
+  /** Every resource template, following `nextCursor` through all pages. */
+  async listResourceTemplates(options = {}) {
+    const templates = await this.listAll("resources/templates/list", "resourceTemplates", isResourceTemplate, options);
+    return templates.map(toResourceTemplate);
+  }
+  /** One page of resource templates, starting at `cursor`. */
+  async listResourceTemplatesPage(cursor, options = {}) {
+    const page = await this.listPage("resources/templates/list", "resourceTemplates", isResourceTemplate, cursor, options);
+    return { resourceTemplates: page.items.map(toResourceTemplate), ...pageCursor(page) };
+  }
+  async readResource(uri, options = {}) {
+    return validateReadResourceResult(await this.request("resources/read", { uri }, options));
+  }
+  async listPage(method, key, isItem, cursor, options) {
+    return validateListPage(method, key, await this.request(method, cursor === void 0 ? void 0 : { cursor }, options), isItem);
+  }
+  /** Every item of a paginated list method. */
+  async listAll(method, key, isItem, options) {
+    const items = [];
+    const cursors = /* @__PURE__ */ new Set();
+    let cursor;
+    for (let pageNumber = 0; pageNumber < MAX_LIST_PAGES; pageNumber++) {
+      const page = await this.listPage(method, key, isItem, cursor, options);
+      items.push(...page.items);
+      if (page.nextCursor === void 0)
+        return items;
+      if (cursors.has(page.nextCursor))
+        throw new Error(`MCP ${method} returned duplicate cursor: ${page.nextCursor}`);
+      cursors.add(page.nextCursor);
+      cursor = page.nextCursor;
+    }
+    throw new Error(`MCP ${method} exceeded ${MAX_LIST_PAGES} pages`);
+  }
+  async callTool(name, args, options = {}) {
+    return validateCallToolResult(await this.request("tools/call", { name, ...args === void 0 ? {} : { arguments: args } }, options));
+  }
+  async close() {
+    const transport = this.transport;
+    this.transport = void 0;
+    this.disposeTransportListeners();
+    this.markClosed(new McpConnectionClosedError());
+    await transport?.close();
+  }
+  async requestInternal(method, params, options, allowConnecting) {
+    const transport = this.requireTransport(allowConnecting);
+    if (options.signal?.aborted)
+      throw new McpAbortError();
+    const id = this.nextRequestId++;
+    const progressToken = options.onProgress ? id : void 0;
+    const requestParams = progressToken === void 0 ? params : { ...params, _meta: { ...isObject(params?._meta) ? params._meta : {}, progressToken } };
+    const message = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      ...requestParams === void 0 ? {} : { params: requestParams }
+    };
+    return new Promise((resolve, reject) => {
+      const entry = {
+        resolve,
+        reject,
+        timeoutMs: options.timeoutMs ?? this.options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+        timer: void 0,
+        signal: options.signal,
+        // The spec forbids cancelling `initialize`.
+        onAbort: () => this.cancelPending(id, new McpAbortError(), method !== "initialize", String(options.signal?.reason ?? "Aborted")),
+        sendController: new AbortController(),
+        cancellable: method !== "initialize",
+        onProgress: options.onProgress,
+        progressToken
+      };
+      this.pending.set(id, entry);
+      if (progressToken !== void 0)
+        this.progressRequests.set(progressToken, id);
+      options.signal?.addEventListener("abort", entry.onAbort, { once: true });
+      this.armTimeout(id, entry);
+      transport.send(message, { signal: entry.sendController.signal }).catch((error) => this.cancelPending(id, error, false));
+    });
+  }
+  async notifyInternal(method, params, allowConnecting) {
+    await this.requireTransport(allowConnecting).send({
+      jsonrpc: "2.0",
+      method,
+      ...params === void 0 ? {} : { params }
+    });
+  }
+  requireTransport(allowConnecting) {
+    if (this.transport && (this.state === "connected" || allowConnecting && this.state === "connecting")) {
+      return this.transport;
+    }
+    throw new McpConnectionClosedError(`MCP client is ${this.state}`);
+  }
+  handleMessage(message) {
+    if (isJsonRpcResponse(message)) {
+      this.handleResponse(message);
+      return;
+    }
+    if (isJsonRpcRequest(message)) {
+      void this.handleRequest(message);
+      return;
+    }
+    if (isJsonRpcNotification(message)) {
+      this.handleNotification(message.method, message.params);
+      return;
+    }
+    this.emitError(new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Received invalid JSON-RPC message"));
+  }
+  handleResponse(message) {
+    const entry = this.pending.get(message.id);
+    if (!entry) {
+      this.emitError(new Error(`Received response for unknown MCP request ${String(message.id)}`));
+      return;
+    }
+    this.removePending(message.id, entry);
+    if ("error" in message)
+      entry.reject(new McpError(message.error.code, message.error.message, message.error.data));
+    else
+      entry.resolve(message.result);
+  }
+  async handleRequest(message) {
+    const transport = this.transport;
+    if (!transport)
+      return;
+    const handler = this.requestHandlers.get(message.method);
+    if (!handler) {
+      await transport.send({
+        jsonrpc: "2.0",
+        id: message.id,
+        error: { code: JSON_RPC_ERROR_CODES.methodNotFound, message: `Method not found: ${message.method}` }
+      }).catch((error) => this.emitError(error));
+      return;
+    }
+    const controller = new AbortController();
+    this.incoming.set(message.id, controller);
+    try {
+      const result = await handler(message.params, { signal: controller.signal });
+      await transport.send({ jsonrpc: "2.0", id: message.id, result: result ?? {} });
+    } catch (error) {
+      const responseError = error instanceof McpError ? { code: error.code, message: error.message, data: error.data } : { code: JSON_RPC_ERROR_CODES.internalError, message: toError(error).message };
+      await transport.send({ jsonrpc: "2.0", id: message.id, error: responseError }).catch((sendError) => this.emitError(sendError));
+    } finally {
+      this.incoming.delete(message.id);
+    }
+  }
+  handleNotification(method, params) {
+    if (method === "notifications/progress")
+      this.handleProgress(params);
+    else if (method === "notifications/cancelled")
+      this.handleCancelled(params);
+    for (const listener of this.notificationListeners.get(method) ?? []) {
+      try {
+        listener(params);
+      } catch (error) {
+        this.emitError(error);
+      }
+    }
+  }
+  handleProgress(params) {
+    if (!isObject(params) || !isJsonRpcId(params.progressToken) || typeof params.progress !== "number")
+      return;
+    const requestId = this.progressRequests.get(params.progressToken);
+    const entry = requestId === void 0 ? void 0 : this.pending.get(requestId);
+    if (requestId === void 0 || !entry)
+      return;
+    this.armTimeout(requestId, entry);
+    try {
+      entry.onProgress?.(params);
+    } catch (error) {
+      this.emitError(error);
+    }
+  }
+  handleCancelled(params) {
+    if (isObject(params) && isJsonRpcId(params.requestId))
+      this.incoming.get(params.requestId)?.abort(params.reason);
+  }
+  armTimeout(id, entry) {
+    if (entry.timer)
+      clearTimeout(entry.timer);
+    if (!Number.isFinite(entry.timeoutMs) || entry.timeoutMs <= 0)
+      return;
+    entry.timer = setTimeout(() => {
+      this.cancelPending(id, new McpTimeoutError(entry.timeoutMs), entry.cancellable, "Request timed out");
+    }, entry.timeoutMs);
+  }
+  cancelPending(id, error, notifyServer, reason) {
+    const entry = this.pending.get(id);
+    if (!entry)
+      return;
+    this.removePending(id, entry);
+    entry.reject(error);
+    if (notifyServer && this.transport) {
+      void this.transport.send({
+        jsonrpc: "2.0",
+        method: "notifications/cancelled",
+        params: { requestId: id, ...reason ? { reason } : {} }
+      }).catch((sendError) => this.emitError(sendError));
+    }
+  }
+  removePending(id, entry) {
+    this.pending.delete(id);
+    if (entry.timer)
+      clearTimeout(entry.timer);
+    if (entry.progressToken !== void 0)
+      this.progressRequests.delete(entry.progressToken);
+    entry.signal?.removeEventListener("abort", entry.onAbort);
+    entry.sendController.abort();
+  }
+  rejectPending(error) {
+    for (const [id, entry] of this.pending) {
+      this.removePending(id, entry);
+      entry.reject(error);
+    }
+  }
+  handleTransportClose() {
+    this.markClosed(new McpConnectionClosedError());
+  }
+  /** Idempotent: rejects in-flight requests, aborts server requests we are serving, and flips the state. */
+  markClosed(error) {
+    const wasClosed = this.state === "closed";
+    this.state = "closed";
+    this.rejectPending(error);
+    for (const controller of this.incoming.values())
+      controller.abort(error);
+    this.incoming.clear();
+    if (wasClosed)
+      return;
+    for (const listener of [...this.closeListeners]) {
+      try {
+        listener();
+      } catch (listenerError) {
+        this.emitError(listenerError);
+      }
+    }
+  }
+  emitError(error) {
+    const normalized = toError(error);
+    for (const listener of this.errorListeners)
+      listener(normalized);
+  }
+  disposeTransportListeners() {
+    for (const dispose of this.disposers.splice(0))
+      dispose();
+  }
+};
+
+// src/stubs/node-stub.ts
+var node_stub_default = {};
+function spawn() {
+  throw new Error("not available in kernel");
+}
+
+// node_modules/@earendil-works/pi-mcp/dist/transports/transport.js
+var DEFAULT_MAX_MESSAGE_BYTES = 16 * 1024 * 1024;
+var TransportEvents = class {
+  messageListeners = /* @__PURE__ */ new Set();
+  errorListeners = /* @__PURE__ */ new Set();
+  closeListeners = /* @__PURE__ */ new Set();
+  closeEmitted = false;
+  onMessage(listener) {
+    this.messageListeners.add(listener);
+    return () => this.messageListeners.delete(listener);
+  }
+  onError(listener) {
+    this.errorListeners.add(listener);
+    return () => this.errorListeners.delete(listener);
+  }
+  onClose(listener) {
+    this.closeListeners.add(listener);
+    return () => this.closeListeners.delete(listener);
+  }
+  emitMessage(message) {
+    for (const listener of this.messageListeners)
+      listener(message);
+  }
+  emitError(error) {
+    const normalized = toError(error);
+    for (const listener of this.errorListeners)
+      listener(normalized);
+  }
+  emitClose() {
+    if (this.closeEmitted)
+      return;
+    this.closeEmitted = true;
+    for (const listener of this.closeListeners)
+      listener();
+  }
+};
+
+// node_modules/@earendil-works/pi-mcp/dist/transports/stdio.js
+var DEFAULT_MAX_STDERR_BYTES = 64 * 1024;
+var DEFAULT_CLOSE_TIMEOUT_MS = 2e3;
+var STDIN_CLOSE_GRACE_MS = 500;
+var USE_PROCESS_GROUPS = node_stub_default.platform !== "win32";
+var liveProcessGroups = /* @__PURE__ */ new Set();
+var exitHookInstalled = false;
+function killProcessTree(child, signal) {
+  const pid = child.pid;
+  if (node_stub_default.platform === "win32" && pid !== void 0) {
+    if (child.exitCode !== null)
+      return;
+    spawn("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true }).on("error", () => {
+    });
+    return;
+  }
+  if (USE_PROCESS_GROUPS && pid !== void 0) {
+    try {
+      node_stub_default.kill(-pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+function installExitHook() {
+  if (exitHookInstalled)
+    return;
+  exitHookInstalled = true;
+  node_stub_default.once("exit", () => {
+    for (const pid of liveProcessGroups) {
+      try {
+        node_stub_default.kill(-pid, "SIGTERM");
+      } catch {
+      }
+    }
+  });
+}
+var StdioTransport = class extends TransportEvents {
+  options;
+  child;
+  stdoutBuffer = Buffer.alloc(0);
+  stderrBuffer = Buffer.alloc(0);
+  started = false;
+  closed = false;
+  constructor(options) {
+    super();
+    this.options = Object.freeze({ ...options, args: options.args ? [...options.args] : void 0 });
+  }
+  get pid() {
+    return this.child?.pid;
+  }
+  get stderr() {
+    return this.stderrBuffer.toString("utf8");
+  }
+  async start() {
+    if (this.started)
+      throw new Error("MCP stdio transport already started");
+    if (this.closed)
+      throw new McpConnectionClosedError();
+    this.started = true;
+    const env = this.options.inheritEnv === false ? { ...this.options.env } : { ...node_stub_default.env, ...this.options.env };
+    const child = node_stub_default(this.options.command, this.options.args ?? [], {
+      cwd: this.options.cwd,
+      env,
+      stdio: ["pipe", "pipe", this.options.stderr === "inherit" ? "inherit" : "pipe"],
+      windowsHide: true,
+      // Own process group, so closing the transport can terminate the server's children too.
+      detached: USE_PROCESS_GROUPS
+    });
+    this.child = child;
+    const pid = child.pid;
+    if (USE_PROCESS_GROUPS && pid !== void 0) {
+      installExitHook();
+      liveProcessGroups.add(pid);
+      child.once("exit", () => liveProcessGroups.delete(pid));
+    }
+    child.stdout?.on("data", (chunk) => this.handleStdout(chunk));
+    child.stdout?.on("error", (error) => this.emitError(error));
+    child.stdin?.on("error", (error) => {
+      if (!this.closed)
+        this.emitError(error);
+    });
+    child.stderr?.on("data", (chunk) => this.handleStderr(chunk));
+    child.stderr?.on("error", (error) => this.emitError(error));
+    child.on("close", () => {
+      this.child = void 0;
+      if (this.stdoutBuffer.toString("utf8").trim()) {
+        this.emitError(new Error("MCP stdio server closed with an incomplete JSON-RPC message"));
+      }
+      this.stdoutBuffer = Buffer.alloc(0);
+      this.emitClose();
+    });
+    await new Promise((resolve, reject) => {
+      const onSpawn = () => {
+        child.off("error", onError);
+        resolve();
+      };
+      const onError = (error) => {
+        child.off("spawn", onSpawn);
+        reject(error);
+      };
+      child.once("spawn", onSpawn);
+      child.once("error", onError);
+    });
+    child.on("error", (error) => {
+      if (!this.closed)
+        this.emitError(error);
+    });
+  }
+  async send(message) {
+    const stdin = this.child?.stdin;
+    if (!this.started || this.closed || !stdin?.writable)
+      throw new McpConnectionClosedError();
+    const payload = `${JSON.stringify(message)}
+`;
+    await new Promise((resolve, reject) => {
+      stdin.write(payload, (error) => error ? reject(error) : resolve());
+    });
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    const child = this.child;
+    if (!child) {
+      this.emitClose();
+      return;
+    }
+    if (child.exitCode !== null || child.signalCode !== null) {
+      child.stdin?.end();
+      return;
+    }
+    const closeTimeoutMs = this.options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
+    await new Promise((resolve) => {
+      const timers = [];
+      child.once("close", () => {
+        for (const timer of timers)
+          clearTimeout(timer);
+        killProcessTree(child, "SIGTERM");
+        resolve();
+      });
+      const grace = Math.min(STDIN_CLOSE_GRACE_MS, closeTimeoutMs);
+      timers.push(setTimeout(() => killProcessTree(child, "SIGTERM"), grace));
+      timers.push(setTimeout(() => killProcessTree(child, "SIGKILL"), grace + closeTimeoutMs));
+      child.stdin?.end();
+    });
+  }
+  handleStdout(chunk) {
+    this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+    const maxMessageBytes = this.options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES;
+    while (true) {
+      const newline = this.stdoutBuffer.indexOf(10);
+      if (newline < 0) {
+        if (this.stdoutBuffer.length > maxMessageBytes) {
+          this.stdoutBuffer = Buffer.alloc(0);
+          this.emitError(new Error(`MCP stdio message exceeds ${maxMessageBytes} bytes`));
+        }
+        return;
+      }
+      const line = this.stdoutBuffer.subarray(0, newline);
+      this.stdoutBuffer = this.stdoutBuffer.subarray(newline + 1);
+      if (line.length > maxMessageBytes) {
+        this.emitError(new Error(`MCP stdio message exceeds ${maxMessageBytes} bytes`));
+        continue;
+      }
+      const text = line.toString("utf8").replace(/\r$/, "");
+      if (!text.trim())
+        continue;
+      try {
+        this.emitMessage(parseJsonRpcMessage(JSON.parse(text)));
+      } catch (error) {
+        this.emitError(error);
+      }
+    }
+  }
+  handleStderr(chunk) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const maxStderrBytes = this.options.maxStderrBytes ?? DEFAULT_MAX_STDERR_BYTES;
+    this.stderrBuffer = Buffer.concat([this.stderrBuffer, buffer]);
+    if (this.stderrBuffer.length > maxStderrBytes)
+      this.stderrBuffer = this.stderrBuffer.subarray(-maxStderrBytes);
+    this.options.onStderr?.(buffer.toString("utf8"));
+  }
+};
+
+// node_modules/@earendil-works/pi-mcp/dist/transports/streamable-http.js
+var MAX_ERROR_BODY_BYTES = 8 * 1024;
+var ERROR_MESSAGE_BODY_CHARS = 500;
+var DEFAULT_RECONNECT_INITIAL_DELAY_MS = 1e3;
+var DEFAULT_RECONNECT_MAX_DELAY_MS = 3e4;
+var DEFAULT_RECONNECT_MAX_RETRIES = 5;
+async function consumeSseStream(stream, options) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  let eventName;
+  let eventId;
+  let dataLines = [];
+  let dataBytes = 0;
+  const maxEventBytes = options.maxEventBytes ?? DEFAULT_MAX_MESSAGE_BYTES;
+  const dispatch = () => {
+    if (dataLines.length === 0) {
+      eventName = void 0;
+      eventId = void 0;
+      return;
+    }
+    const data = dataLines.join("\n");
+    options.onEvent({ ...eventName ? { event: eventName } : {}, data, ...eventId ? { id: eventId } : {} });
+    eventName = void 0;
+    eventId = void 0;
+    dataLines = [];
+    dataBytes = 0;
+  };
+  const processLine = (rawLine) => {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (line === "") {
+      dispatch();
+      return;
+    }
+    if (line.startsWith(":"))
+      return;
+    const colon = line.indexOf(":");
+    const field = colon < 0 ? line : line.slice(0, colon);
+    let value = colon < 0 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" "))
+      value = value.slice(1);
+    if (field === "data") {
+      dataBytes += Buffer.byteLength(value) + (dataLines.length > 0 ? 1 : 0);
+      if (dataBytes > maxEventBytes)
+        throw new Error(`MCP SSE event exceeds ${maxEventBytes} bytes`);
+      dataLines.push(value);
+    } else if (field === "event")
+      eventName = value;
+    else if (field === "id" && !value.includes("\0")) {
+      eventId = value;
+      options.onId?.(value);
+    } else if (field === "retry" && /^\d+$/.test(value))
+      options.onRetry?.(Number(value));
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffered += decoder.decode(value, { stream: true });
+      let newline = buffered.indexOf("\n");
+      while (newline >= 0) {
+        processLine(buffered.slice(0, newline));
+        buffered = buffered.slice(newline + 1);
+        newline = buffered.indexOf("\n");
+      }
+      if (Buffer.byteLength(buffered) > maxEventBytes)
+        throw new Error(`MCP SSE event exceeds ${maxEventBytes} bytes`);
+    }
+    buffered += decoder.decode();
+    if (buffered)
+      processLine(buffered);
+    dispatch();
+  } finally {
+    reader.releaseLock();
+  }
+}
+var McpHttpError = class extends Error {
+  status;
+  body;
+  constructor(status, message, body = "") {
+    super(message);
+    this.name = "McpHttpError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var McpAuthRequiredError = class extends McpHttpError {
+  wwwAuthenticate;
+  constructor(response, body = "") {
+    super(401, "MCP server requires authentication", body);
+    this.name = "McpAuthRequiredError";
+    this.wwwAuthenticate = response.headers.get("www-authenticate");
+  }
+};
+var McpSessionExpiredError = class extends McpHttpError {
+  constructor(body = "") {
+    super(404, "MCP session expired", body);
+    this.name = "McpSessionExpiredError";
+  }
+};
+function contentType(response) {
+  return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+}
+function needsAuthorization(response) {
+  if (response.status === 401)
+    return true;
+  if (response.status !== 403)
+    return false;
+  return /(?:^|[\s,])error="?insufficient_scope"?/i.test(response.headers.get("www-authenticate") ?? "");
+}
+function isTransientStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+function discard(response) {
+  return response.body?.cancel().catch(() => {
+  }) ?? Promise.resolve();
+}
+function describeHttpFailure(status, body) {
+  const text = body.trim();
+  const snippet = text.length > ERROR_MESSAGE_BODY_CHARS ? `${text.slice(0, ERROR_MESSAGE_BODY_CHARS - 3)}...` : text;
+  return `MCP HTTP request failed with status ${status}${snippet ? `: ${snippet}` : ""}`;
+}
+var StreamableHttpTransport = class extends TransportEvents {
+  url;
+  options;
+  fetch;
+  controller = new AbortController();
+  started = false;
+  closed = false;
+  sessionIdValue;
+  protocolVersion;
+  getStreamStarted = false;
+  /** Access token of the latest request, which `close()` reuses instead of asking the auth provider. */
+  lastToken;
+  constructor(options) {
+    super();
+    this.options = Object.freeze({ ...options, headers: options.headers ? { ...options.headers } : void 0 });
+    this.url = new URL(options.url);
+    const fetch = options.fetch ?? globalThis.fetch;
+    this.fetch = (input, init) => fetch(input, init);
+  }
+  get sessionId() {
+    return this.sessionIdValue;
+  }
+  async start() {
+    if (this.started)
+      throw new Error("MCP Streamable HTTP transport already started");
+    if (this.closed)
+      throw new McpConnectionClosedError();
+    this.started = true;
+  }
+  setProtocolVersion(version) {
+    this.protocolVersion = version;
+  }
+  async send(message, { signal } = {}) {
+    if (!this.started || this.closed)
+      throw new McpConnectionClosedError();
+    const response = await this.authorizedFetch("POST", {
+      headers: { accept: "application/json, text/event-stream", "content-type": "application/json" },
+      body: JSON.stringify(message)
+    }, signal);
+    await this.checkResponse(response);
+    this.captureSession(response);
+    if (!isJsonRpcRequest(message)) {
+      await discard(response);
+      if ("method" in message && message.method === "notifications/initialized")
+        this.startGetStream();
+      return;
+    }
+    if (response.status === 202 || response.status === 204) {
+      throw new McpHttpError(response.status, `MCP server accepted request ${message.method} without a response`);
+    }
+    const type = contentType(response);
+    if (type === "application/json") {
+      const body = await response.json();
+      for (const item of Array.isArray(body) ? body : [body])
+        this.emitMessage(parseJsonRpcMessage(item));
+      return;
+    }
+    if (type === "text/event-stream" && response.body) {
+      void this.consumeResponseStream(response.body, message.id);
+      return;
+    }
+    await discard(response);
+    throw new McpHttpError(response.status, `Unsupported MCP response content type: ${type ?? "missing"}`);
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.controller.abort();
+    if (this.started && this.sessionIdValue) {
+      try {
+        const response = await this.fetch(this.url, {
+          method: "DELETE",
+          headers: this.buildHeaders({}, this.lastToken),
+          signal: AbortSignal.timeout(1e3)
+        });
+        await discard(response);
+      } catch {
+      }
+    }
+    this.emitClose();
+  }
+  /**
+   * Fetch with auth headers. A 401 (or a 403 asking for more scope) is handed to the auth provider
+   * once, and the request is retried with whatever credentials it left behind.
+   *
+   * `signal` only stops dispatch: getting a token or the authorization recovery can take a while, and a
+   * request its sender gave up on in the meantime must not reach the server. It does not abort the shared
+   * recovery, which other requests may wait for.
+   */
+  async authorizedFetch(method, init, signal) {
+    const onUnauthorized = this.options.authProvider?.onUnauthorized?.bind(this.options.authProvider);
+    for (let attempt = 0; ; attempt++) {
+      const { headers, token } = await this.headers(init.headers);
+      if (signal?.aborted)
+        throw new McpAbortError();
+      const response = await this.fetch(this.url, {
+        method,
+        headers,
+        body: init.body,
+        signal: this.controller.signal
+      });
+      if (attempt > 0 || !onUnauthorized || !needsAuthorization(response))
+        return response;
+      try {
+        await onUnauthorized({ response, serverUrl: this.url, fetch: this.fetch, token });
+      } finally {
+        await discard(response);
+      }
+    }
+  }
+  async headers(extra = {}) {
+    const token = await this.options.authProvider?.token();
+    this.lastToken = token;
+    return { headers: this.buildHeaders(extra, token), ...token ? { token } : {} };
+  }
+  buildHeaders(extra, token) {
+    const headers = new Headers(this.options.headers);
+    for (const [name, value] of Object.entries(extra))
+      headers.set(name, value);
+    if (this.sessionIdValue)
+      headers.set("Mcp-Session-Id", this.sessionIdValue);
+    if (this.protocolVersion)
+      headers.set("MCP-Protocol-Version", this.protocolVersion);
+    if (token)
+      headers.set("Authorization", `Bearer ${token}`);
+    return headers;
+  }
+  captureSession(response) {
+    const sessionId = response.headers.get("mcp-session-id");
+    if (sessionId)
+      this.sessionIdValue = sessionId;
+  }
+  async checkResponse(response) {
+    if (response.ok)
+      return;
+    const body = (await response.text().catch(() => "")).slice(0, MAX_ERROR_BODY_BYTES);
+    if (response.status === 401)
+      throw new McpAuthRequiredError(response, body);
+    if (response.status === 404 && this.sessionIdValue)
+      throw new McpSessionExpiredError(body);
+    throw new McpHttpError(response.status, describeHttpFailure(response.status, body), body);
+  }
+  async consumeSse(stream, cursor, onMessage) {
+    await consumeSseStream(stream, {
+      maxEventBytes: this.options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES,
+      onId: (id) => {
+        cursor.lastEventId = id;
+      },
+      onRetry: (delayMs) => {
+        cursor.retryMs = delayMs;
+      },
+      onEvent: (event) => {
+        cursor.received = true;
+        if (!event.data.trim() || event.event !== void 0 && event.event !== "message")
+          return;
+        let message;
+        try {
+          message = parseJsonRpcMessage(JSON.parse(event.data));
+        } catch (error) {
+          this.emitError(error);
+          return;
+        }
+        onMessage?.(message);
+        this.emitMessage(message);
+      }
+    });
+  }
+  /**
+   * Read the SSE stream answering one request. When the stream ends or breaks before the response
+   * arrives and the server assigned event IDs, resume it with GET and `Last-Event-ID`, as the
+   * server may close response streams at will. Otherwise only this request fails.
+   */
+  async consumeResponseStream(body, requestId) {
+    const cursor = { lastEventId: void 0, retryMs: void 0, received: false };
+    let answered = false;
+    const onMessage = (message) => {
+      if (isJsonRpcResponse(message) && message.id === requestId)
+        answered = true;
+    };
+    let stream = body;
+    let failure;
+    for (let attempt = 0; ; ) {
+      if (stream) {
+        try {
+          await this.consumeSse(stream, cursor, onMessage);
+          failure = void 0;
+        } catch (error) {
+          failure = error;
+        }
+      }
+      if (answered || this.closed)
+        return;
+      if (failure !== void 0 && !this.isRetryable(failure))
+        break;
+      if (cursor.lastEventId === void 0 || attempt >= this.maxRetries())
+        break;
+      if (cursor.received)
+        attempt = 0;
+      cursor.received = false;
+      if (!await this.sleep(this.reconnectDelay(attempt++, cursor.retryMs)))
+        return;
+      try {
+        stream = await this.openSseStream(cursor.lastEventId);
+      } catch (error) {
+        failure = error;
+        if (!this.isRetryable(error))
+          break;
+        stream = void 0;
+      }
+    }
+    if (this.closed)
+      return;
+    const reason = failure === void 0 ? "stream ended without a response" : toError(failure).message;
+    this.emitMessage({
+      jsonrpc: "2.0",
+      id: requestId,
+      error: { code: JSON_RPC_ERROR_CODES.internalError, message: `MCP response stream failed: ${reason}` }
+    });
+  }
+  startGetStream() {
+    if (this.options.openGetStream === false || this.getStreamStarted || this.closed)
+      return;
+    this.getStreamStarted = true;
+    void this.runGetStream();
+  }
+  /** Keep the server-to-client stream open, reconnecting with backoff when it drops. */
+  async runGetStream() {
+    const cursor = { lastEventId: void 0, retryMs: void 0, received: false };
+    for (let attempt = 0; !this.closed; ) {
+      try {
+        const stream = await this.openSseStream(cursor.lastEventId);
+        if (!stream)
+          return;
+        const openedAt = Date.now();
+        await this.consumeSse(stream, cursor);
+        if (cursor.received || Date.now() - openedAt > this.maxDelay())
+          attempt = 0;
+      } catch (error) {
+        if (this.closed)
+          return;
+        if (!this.isRetryable(error)) {
+          this.emitError(error);
+          return;
+        }
+      }
+      cursor.received = false;
+      if (attempt >= this.maxRetries()) {
+        this.emitError(new Error("MCP server-to-client stream dropped and could not be reopened"));
+        return;
+      }
+      if (!await this.sleep(this.reconnectDelay(attempt++, cursor.retryMs)))
+        return;
+    }
+  }
+  /** Open a GET SSE stream. Resolves to undefined when the server answers 405 (no GET stream). */
+  async openSseStream(lastEventId) {
+    const response = await this.authorizedFetch("GET", {
+      headers: {
+        accept: "text/event-stream",
+        ...lastEventId === void 0 ? {} : { "last-event-id": lastEventId }
+      }
+    });
+    if (response.status === 405) {
+      await discard(response);
+      return void 0;
+    }
+    await this.checkResponse(response);
+    this.captureSession(response);
+    const type = contentType(response);
+    if (type !== "text/event-stream" || !response.body) {
+      await discard(response);
+      throw new McpHttpError(response.status, `Unsupported MCP GET response content type: ${type ?? "missing"}`);
+    }
+    return response.body;
+  }
+  /**
+   * Network failures and transient statuses are retried; auth, session, and protocol errors are not.
+   * `fetch` reports network failures, including a connection dropped mid-body, as `TypeError`.
+   */
+  isRetryable(error) {
+    if (error instanceof McpHttpError)
+      return isTransientStatus(error.status);
+    if (error instanceof TypeError)
+      return true;
+    const code = error?.code;
+    return typeof code === "string" && (code.startsWith("E") || code.startsWith("UND_ERR"));
+  }
+  reconnectDelay(attempt, serverDelayMs) {
+    if (serverDelayMs !== void 0)
+      return serverDelayMs;
+    const initial = this.options.reconnect?.initialDelayMs ?? DEFAULT_RECONNECT_INITIAL_DELAY_MS;
+    return Math.min(initial * 2 ** attempt, this.maxDelay());
+  }
+  maxDelay() {
+    return this.options.reconnect?.maxDelayMs ?? DEFAULT_RECONNECT_MAX_DELAY_MS;
+  }
+  maxRetries() {
+    return this.options.reconnect?.maxRetries ?? DEFAULT_RECONNECT_MAX_RETRIES;
+  }
+  /** Resolves false when the transport closed while waiting. */
+  sleep(ms) {
+    const signal = this.controller.signal;
+    if (signal.aborted)
+      return Promise.resolve(false);
+    return new Promise((resolve) => {
+      const onAbort = () => {
+        clearTimeout(timer);
+        resolve(false);
+      };
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(true);
+      }, ms);
+      timer.unref?.();
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+};
+
+// src/client/pi-connection.ts
+async function createPiConnection(options) {
+  const clientOptions = {
+    name: "mcpcat",
+    version: options.version ?? "0.0.0"
+  };
+  const client = new McpClient(clientOptions);
+  let transport;
+  if (options.url) {
+    transport = new StreamableHttpTransport({
+      url: options.url,
+      headers: options.headers
+    });
+  } else if (options.command) {
+    transport = new StdioTransport({
+      command: options.command,
+      args: options.args,
+      env: options.env,
+      cwd: options.cwd,
+      inheritEnv: true,
+      stderr: "pipe"
+    });
+  } else {
+    throw new Error("PiConnection requires either a url or a command");
+  }
+  const initResult = await client.connect(transport);
+  return {
+    async info() {
+      return {
+        name: initResult.serverInfo?.name,
+        version: initResult.serverInfo?.version,
+        title: initResult.serverInfo?.title,
+        protocolVersion: initResult.protocolVersion,
+        capabilities: initResult.capabilities,
+        instructions: initResult.instructions
+      };
+    },
+    async listTools() {
+      return client.listTools();
+    },
+    async callTool(name, args) {
+      return client.callTool(name, args);
+    },
+    async close() {
+      await client.close();
+    }
+  };
+}
+
+// src/client/stateless-connection.ts
+var STATELESS_PROTOCOL_VERSION = "2026-07-28";
+var StatelessRpcError = class extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(`MCP RPC error ${code}: ${message}`);
+    this.name = "StatelessRpcError";
+    this.code = code;
+    this.data = data;
+  }
+};
+var StatelessHttpError = class extends Error {
+  status;
+  constructor(status, statusText, method, snippet) {
+    super(`MCP HTTP ${status} ${statusText} for ${method}: ${snippet || "(empty body)"}`);
+    this.name = "StatelessHttpError";
+    this.status = status;
+  }
+};
+var InputRequiredError = class extends Error {
+  requestJson;
+  constructor(requestJson) {
+    super("Server requires input (resultType: input_required)");
+    this.name = "InputRequiredError";
+    this.requestJson = requestJson;
+  }
+};
+function selectSseFrame(body, targetId) {
+  const text = new TextDecoder().decode(body);
+  const blocks = text.replace(/\r\n/g, "\n").split(/\n\n/);
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+    const dataLines = [];
+    for (const line of block.split("\n")) {
+      if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
+    }
+    if (dataLines.length === 0) continue;
+    try {
+      const parsed = JSON.parse(dataLines.join("\n"));
+      if (parsed.id === targetId) return parsed;
+    } catch {
+    }
+  }
+  throw new Error(`SSE stream ended without response for id ${targetId}`);
+}
+function mcpNameForMethod(method, params) {
+  if (method === "tools/call") return params.name;
+  if (method === "prompts/get") return params.name;
+  if (method === "resources/read") return params.uri;
+  return void 0;
+}
+async function createStatelessConnection(options) {
+  const {
+    url,
+    headers: extraHeaders,
+    fetchImpl,
+    timeoutMs = 6e4,
+    clientInfo = { name: "mcpcat", version: "0.0.0" }
+  } = options;
+  let nextId = 1;
+  let negotiatedVersion;
+  async function request(method, params) {
+    const id = nextId++;
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      "Mcp-Method": method,
+      ...extraHeaders
+    };
+    const mcpName = mcpNameForMethod(method, params);
+    if (mcpName) {
+      headers["Mcp-Name"] = mcpName;
+    }
+    if (negotiatedVersion) {
+      headers["Mcp-Protocol-Version"] = negotiatedVersion;
+    }
+    const meta = {
+      protocolVersion: negotiatedVersion ?? STATELESS_PROTOCOL_VERSION,
+      clientInfo
+    };
+    const body = JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method,
+      params: { ...params, _meta: meta }
+    });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let res;
+    try {
+      res = await fetchImpl(url, {
+        method: "POST",
+        headers,
+        body,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (res.status === 401) {
+      throw new StatelessHttpError(401, "Unauthorized", method, "");
+    }
+    if (res.status >= 400) {
+      const text = await res.text();
+      let rpcError;
+      try {
+        const parsed = JSON.parse(text);
+        if (parsed.error && typeof parsed.error.code === "number") {
+          rpcError = parsed.error;
+        }
+      } catch {
+      }
+      if (rpcError) {
+        throw new StatelessRpcError(rpcError.code, rpcError.message, rpcError.data);
+      }
+      throw new StatelessHttpError(res.status, res.statusText, method, text.slice(0, 512));
+    }
+    const ct = res.headers.get("content-type") ?? "";
+    let frame;
+    if (ct.toLowerCase().includes("text/event-stream")) {
+      const bytes = new Uint8Array(await res.arrayBuffer());
+      frame = selectSseFrame(bytes, id);
+    } else {
+      frame = await res.json();
+    }
+    if (frame.error) {
+      throw new StatelessRpcError(frame.error.code, frame.error.message, frame.error.data);
+    }
+    return frame.result;
+  }
+  const discoverResult = await request("server/discover", {
+    protocolVersion: STATELESS_PROTOCOL_VERSION
+  });
+  const supported = Array.isArray(discoverResult?.supportedVersions) ? discoverResult.supportedVersions.filter((v) => typeof v === "string") : [];
+  if (!supported.includes(STATELESS_PROTOCOL_VERSION)) {
+    throw new Error(
+      `Server does not support ${STATELESS_PROTOCOL_VERSION} (advertised: ${supported.join(", ") || "none"})`
+    );
+  }
+  negotiatedVersion = STATELESS_PROTOCOL_VERSION;
+  let serverInfoCache;
+  return {
+    async info() {
+      if (serverInfoCache) return serverInfoCache;
+      const result = discoverResult;
+      serverInfoCache = {
+        name: result?.serverInfo?.name,
+        version: result?.serverInfo?.version,
+        title: result?.serverInfo?.title,
+        protocolVersion: STATELESS_PROTOCOL_VERSION,
+        capabilities: result?.capabilities ?? {},
+        instructions: result?.instructions
+      };
+      return serverInfoCache;
+    },
+    async listTools() {
+      const result = await request("tools/list", {});
+      return result?.tools ?? [];
+    },
+    async callTool(name, args) {
+      const result = await request("tools/call", {
+        name,
+        arguments: args ?? {}
+      });
+      const resultType = result.resultType ?? "complete";
+      if (resultType === "input_required") {
+        throw new InputRequiredError(
+          JSON.stringify({ name, arguments: args ?? {}, result }, null, 2)
+        );
+      }
+      return result;
+    },
+    async close() {
+    }
+  };
+}
+
+// src/client/connect.ts
+async function connect(platform, options) {
+  if (options.command) {
+    return createPiConnection({
+      command: options.command,
+      args: options.args,
+      env: options.env,
+      cwd: options.cwd,
+      version: options.version
+    });
+  }
+  if (!options.url) {
+    throw new Error("connect requires either a url or a command");
+  }
+  if (options.protocolVersion && !options.protocolVersion.startsWith("2026")) {
+    return createPiConnection({
+      url: options.url,
+      headers: options.headers,
+      version: options.version
+    });
+  }
+  try {
+    return await createStatelessConnection({
+      url: options.url,
+      headers: options.headers,
+      fetchImpl: platform.fetch,
+      clientInfo: { name: "mcpcat", version: options.version ?? "0.0.0" }
+    });
+  } catch (err) {
+    const isMethodNotFound = err instanceof StatelessRpcError && err.code === -32601 || err instanceof StatelessHttpError && err.status >= 400 && err.status < 500;
+    if (options.protocolVersion?.startsWith("2026")) {
+      throw err;
+    }
+    if (isMethodNotFound) {
+      return createPiConnection({
+        url: options.url,
+        headers: options.headers,
+        version: options.version
+      });
+    }
+    throw err;
+  }
+}
+
+// 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;
+    } else if (c === '"') {
+      inDouble = true;
+    } else if (c === " " || c === "	") {
+      if (current.length > 0) {
+        result.push(current);
+        current = "";
+      }
+    } else if (c === "\\" && i + 1 < input.length) {
+      current += input[++i];
+    } else {
+      current += c;
+    }
+  }
+  if (current.length > 0) result.push(current);
+  return result;
+}
+function normalizeUrl(raw) {
+  if (raw.startsWith("http://") || raw.startsWith("https://")) return raw;
+  if (raw.startsWith("localhost") || raw.startsWith("127.0.0.1") || raw.startsWith("[::1]")) {
+    return `http://${raw}`;
+  }
+  return `https://${raw}`;
+}
+function looksLikeUrl(value) {
+  if (value.startsWith("http://") || value.startsWith("https://")) return true;
+  if (value.includes(".") && !value.includes(" ")) return true;
+  if (value.startsWith("localhost") || value.startsWith("127.0.0.1") || value.startsWith("[::1]"))
+    return true;
+  return false;
+}
+async function resolveTarget(target, trailingArgs, config) {
+  if (trailingArgs && trailingArgs.length > 0) {
+    return { command: trailingArgs[0], args: trailingArgs.slice(1) };
+  }
+  if (!target) {
+    throw new Error("no target given");
+  }
+  if (target.startsWith("stdio:")) {
+    const rest = target.slice(6);
+    const parts = splitShellStyle(rest);
+    if (parts.length === 0) throw new Error("stdio: target requires a command");
+    return { command: parts[0], args: parts.slice(1) };
+  }
+  if (looksLikeUrl(target)) {
+    return { url: normalizeUrl(target) };
+  }
+  const entry = await config.get(target);
+  if (entry) {
+    return configToTarget(entry);
+  }
+  throw new Error(`unknown target '${target}': not a URL and not found in mcp.json`);
+}
+function configToTarget(entry) {
+  if (entry.url) {
+    return {
+      url: entry.url,
+      headers: entry.headers
+    };
+  }
+  if (entry.command) {
+    return {
+      command: entry.command,
+      args: entry.args,
+      env: entry.env,
+      cwd: entry.cwd
+    };
+  }
+  throw new Error("config entry has neither url nor command");
+}
+
+// src/config/source.ts
+function createConfigSource(platform) {
+  const home = platform.env.HOME ?? platform.env.USERPROFILE ?? "";
+  const piDir = platform.env.PI_CODING_AGENT_DIR ?? `${home}/.pi/agent`;
+  const configPath = `${piDir}/mcp.json`;
+  return {
+    async get(name) {
+      try {
+        const exists = await platform.fs.exists(configPath);
+        if (!exists) return void 0;
+        const data = await platform.fs.readFile(configPath);
+        const text = new TextDecoder().decode(data);
+        const parsed = JSON.parse(text);
+        if (!parsed.mcpServers) return void 0;
+        const normalizedName = name.replace(/[-_]/g, "").toLowerCase();
+        for (const [key, value] of Object.entries(parsed.mcpServers)) {
+          if (key.replace(/[-_]/g, "").toLowerCase() === normalizedName) {
+            return value;
+          }
+        }
+        return void 0;
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+
+// src/cli/main.ts
+var VERBS = [
+  "info",
+  "tools",
+  "ls",
+  "call",
+  "describe",
+  "resources",
+  "read",
+  "prompts",
+  "prompt",
+  "grep",
+  "complete",
+  "task",
+  "add",
+  "rm",
+  "list",
+  "enable",
+  "disable",
+  "exposure",
+  "import",
+  "login",
+  "logout",
+  "serve",
+  "code",
+  "discover",
+  "inbox",
+  "help"
+];
+var UNIMPLEMENTED_VERBS = /* @__PURE__ */ new Set([
+  "resources",
+  "read",
+  "prompts",
+  "prompt",
+  "grep",
+  "complete",
+  "task",
+  "add",
+  "rm",
+  "list",
+  "enable",
+  "disable",
+  "exposure",
+  "import",
+  "login",
+  "logout",
+  "serve",
+  "code",
+  "discover",
+  "inbox"
+]);
+var CLIENT_VERBS = /* @__PURE__ */ new Set(["info", "tools", "call", "describe"]);
+function helpText(version) {
+  return `mcpcat ${version} \u2013 a curl for the Model Context Protocol
+
+Usage: mcpcat [options] <target> [<tool> [args\u2026]]
+       mcpcat [options] <verb> \u2026
+
+Client verbs:
+  info <target>              Server identity and capabilities
+  tools <target>             List tools
+  call <target> <tool>       Call a tool
+  describe <target> [tool]   Tool schema and help
+
+Configuration verbs:
+  add <name> <url>           Add a server to mcp.json (not implemented yet)
+  rm <name>                  Remove a server (not implemented yet)
+  list                       List configured servers (not implemented yet)
+  enable|disable <name>      Toggle a server (not implemented yet)
+  exposure <name> <mode>     Set exposure mode (not implemented yet)
+  import <file>              Import from other configs (not implemented yet)
+  login <target>             OAuth sign-in (not implemented yet)
+  logout <target>            Remove tokens (not implemented yet)
+
+Server and code verbs:
+  serve [--stdio|--http] \u2026   Expose commands as MCP server (not implemented yet)
+  code [-e src|file.js]      Run a codemode script (not implemented yet)
+  discover <url>             Find MCP servers (not implemented yet)
+  inbox                      Discovery inbox (not implemented yet)
+  help [verb]                Show help
+
+Options:
+  --json                     JSON output
+  -H, --header 'N: V'       Extra header
+  -d <json>                  Tool arguments as JSON (or @file, @- for stdin)
+  -m, --timeout <s>          Request timeout (default 60)
+  --protocol-version <v>     Pin protocol version
+  --schema                   Print raw JSON Schema (describe)
+  -v, --verbose              Trace on stderr
+  -s, --silent               Suppress progress
+  -o, --output <path>        Write result to file
+  -V, --version              Print version
+  -h, --help                 Show this help
+`;
+}
+function parseFlags(args) {
+  const headers = {};
+  let dataArg;
+  let protocolVersion;
+  let showSchema = false;
+  const positional = [];
+  let trailingCommand;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      trailingCommand = args.slice(i + 1);
+      break;
+    }
+    if ((arg === "-H" || arg === "--header") && args[i + 1]) {
+      const val = args[++i];
+      const colonIdx = val.indexOf(":");
+      if (colonIdx > 0) {
+        headers[val.slice(0, colonIdx).trim()] = val.slice(colonIdx + 1).trim();
+      }
+    } else if (arg === "-d" && args[i + 1]) {
+      dataArg = args[++i];
+    } else if (arg === "--protocol-version" && args[i + 1]) {
+      protocolVersion = args[++i];
+    } else if (arg === "--schema") {
+      showSchema = true;
+    } else if (!arg.startsWith("-")) {
+      positional.push(arg);
+    }
+  }
+  return { headers, dataArg, protocolVersion, showSchema, positional, trailingCommand };
+}
+function resolveVerb(positional, trailingCommand) {
+  let verb;
+  let target;
+  let toolName;
+  if (positional.length >= 1 && VERBS.includes(positional[0])) {
+    verb = positional[0];
+    if (verb === "ls") verb = "tools";
+    target = positional[1];
+    toolName = positional[2];
+  } else if (positional.length >= 2) {
+    target = positional[0];
+    toolName = positional[1];
+    verb = "call";
+  } else if (positional.length === 1) {
+    target = positional[0];
+    verb = "info";
+  }
+  if (!target && trailingCommand && trailingCommand.length > 0) {
+    target = "__trailing__";
+  }
+  return {
+    verb,
+    target,
+    toolName,
+    dataArg: void 0,
+    headers: {},
+    protocolVersion: void 0,
+    showSchema: false,
+    trailingCommand
+  };
+}
+function parseArgs(args) {
+  const flags = parseFlags(args);
+  const resolved = resolveVerb(flags.positional, flags.trailingCommand);
+  return {
+    ...resolved,
+    headers: flags.headers,
+    dataArg: flags.dataArg,
+    protocolVersion: flags.protocolVersion,
+    showSchema: flags.showSchema
+  };
+}
+function formatToolLine(tool) {
+  const desc = tool.description ? `  ${tool.description}` : "";
+  return `${tool.name}${desc}`;
+}
+function formatToolSchema(tool) {
+  const lines = [];
+  lines.push(`${tool.name}`);
+  if (tool.description) lines.push(`  ${tool.description}`);
+  if (tool.inputSchema) {
+    lines.push("  Input schema:");
+    lines.push(`    ${JSON.stringify(tool.inputSchema, null, 2).split("\n").join("\n    ")}`);
+  }
+  const annotations = tool.annotations;
+  if (annotations) {
+    lines.push("  Annotations:");
+    for (const [k, v] of Object.entries(annotations)) {
+      lines.push(`    ${k}: ${JSON.stringify(v)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function renderCallResult(result) {
+  const parts = [];
+  if (result.content) {
+    for (const block of result.content) {
+      if (block.type === "text") parts.push(block.text);
+      else if (block.type === "image")
+        parts.push(`[image: ${block.mimeType}, ${Math.ceil(block.data.length * 3 / 4)} bytes]`);
+      else if (block.type === "resource_link") parts.push(`[resource: ${block.uri}]`);
+      else if (block.type === "resource") {
+        parts.push(
+          "text" in block.resource ? block.resource.text : `[blob: ${block.resource.uri}]`
+        );
+      }
+    }
+  }
+  if (parts.length === 0 && result.structuredContent !== void 0) {
+    parts.push(JSON.stringify(result.structuredContent, null, 2));
+  }
+  return parts.join("\n");
+}
+async function readDataArg(platform, dataArg) {
+  let raw;
+  if (dataArg.startsWith("@-")) {
+    const reader = platform.stdin.getReader();
+    const chunks = [];
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    reader.releaseLock();
+    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;
+    }
+    raw = new TextDecoder().decode(merged);
+  } else if (dataArg.startsWith("@")) {
+    const data = await platform.fs.readFile(dataArg.slice(1));
+    raw = new TextDecoder().decode(data);
+  } else {
+    raw = dataArg;
+  }
+  return JSON.parse(raw);
+}
+async function runInfo(platform, conn) {
+  const info = await conn.info();
+  const lines = [];
+  if (info.name) lines.push(`Server: ${info.name}${info.version ? ` ${info.version}` : ""}`);
+  if (info.title) lines.push(`Title: ${info.title}`);
+  lines.push(`Protocol: ${info.protocolVersion}`);
+  if (info.instructions) lines.push(`Instructions: ${info.instructions}`);
+  const caps = Object.keys(info.capabilities).filter(
+    (k) => info.capabilities[k] != null && info.capabilities[k] !== false
+  );
+  if (caps.length > 0) lines.push(`Capabilities: ${caps.join(", ")}`);
+  try {
+    const tools = await conn.listTools();
+    lines.push(`Tools: ${tools.length}`);
+  } catch {
+  }
+  await platform.write(1, `${lines.join("\n")}
+`);
+  return 0;
+}
+async function runTools(platform, conn) {
+  const tools = await conn.listTools();
+  if (tools.length === 0) {
+    await platform.write(1, "(no tools)\n");
+  } else {
+    await platform.write(1, `${tools.map(formatToolLine).join("\n")}
+`);
+  }
+  return 0;
+}
+async function runCall(platform, conn, toolName, dataArg) {
+  let toolArgs = {};
+  if (dataArg) {
+    try {
+      toolArgs = await readDataArg(platform, dataArg);
+    } catch (err) {
+      await platform.write(2, `mcpcat: invalid -d argument: ${err.message}
+`);
+      return 2;
+    }
+  }
+  const result = await conn.callTool(toolName, toolArgs);
+  const output = renderCallResult(result);
+  if (result.isError) {
+    await platform.write(2, `${output}
+`);
+    return 1;
+  }
+  await platform.write(1, `${output}
+`);
+  return 0;
+}
+async function runDescribe(platform, conn, toolName, showSchema) {
+  const tools = await conn.listTools();
+  if (toolName) {
+    const tool = tools.find((t) => t.name === toolName);
+    if (!tool) {
+      await platform.write(2, `mcpcat: tool '${toolName}' not found
+`);
+      return 2;
+    }
+    if (showSchema && tool.inputSchema) {
+      await platform.write(1, `${JSON.stringify(tool.inputSchema, null, 2)}
+`);
+    } else {
+      await platform.write(1, `${formatToolSchema(tool)}
+`);
+    }
+  } else {
+    for (const tool of tools) {
+      await platform.write(1, `${formatToolSchema(tool)}
+
+`);
+    }
+  }
+  return 0;
+}
+async function runVerb(platform, parsed, conn) {
+  switch (parsed.verb) {
+    case "info":
+      return runInfo(platform, conn);
+    case "tools":
+      return runTools(platform, conn);
+    case "call":
+      return runCall(platform, conn, parsed.toolName, parsed.dataArg);
+    case "describe":
+      return runDescribe(platform, conn, parsed.toolName, parsed.showSchema);
+    default:
+      await platform.write(2, `mcpcat: unknown command '${parsed.verb}'
+`);
+      return 2;
+  }
+}
+async function run(platform, version, args) {
+  if (args.includes("--version") || args.includes("-V")) {
+    await platform.write(1, `${version}
+`);
+    return 0;
+  }
+  if (args.includes("--help") || args.includes("-h") || args[0] === "help") {
+    await platform.write(1, helpText(version));
+    return 0;
+  }
+  if (args.length === 0) {
+    await platform.write(1, helpText(version));
+    return 0;
+  }
+  const parsed = parseArgs(args);
+  if (!parsed.verb) {
+    await platform.write(2, "mcpcat: no verb or target given\n");
+    return 2;
+  }
+  if (UNIMPLEMENTED_VERBS.has(parsed.verb)) {
+    await platform.write(2, `mcpcat: '${parsed.verb}' is not implemented yet
+`);
+    return 1;
+  }
+  if (!CLIENT_VERBS.has(parsed.verb)) {
+    await platform.write(2, `mcpcat: unknown command '${parsed.verb}'
+`);
+    return 2;
+  }
+  if (parsed.verb === "call" && !parsed.toolName) {
+    await platform.write(2, "mcpcat: call requires a tool name\n");
+    return 2;
+  }
+  if (!parsed.target) {
+    await platform.write(2, `mcpcat: ${parsed.verb} requires a target
+`);
+    return 2;
+  }
+  const config = createConfigSource(platform);
+  let resolved;
+  try {
+    resolved = await resolveTarget(
+      parsed.target === "__trailing__" ? "" : parsed.target,
+      parsed.trailingCommand,
+      config
+    );
+  } catch (err) {
+    await platform.write(2, `mcpcat: ${err.message}
+`);
+    return 2;
+  }
+  let conn;
+  try {
+    conn = await connect(platform, {
+      ...resolved,
+      headers: { ...resolved.headers, ...parsed.headers },
+      protocolVersion: parsed.protocolVersion,
+      version
+    });
+  } catch (err) {
+    await platform.write(2, `mcpcat: connection failed: ${err.message}
+`);
+    return 3;
+  }
+  try {
+    return await runVerb(platform, parsed, conn);
+  } catch (err) {
+    if (err instanceof InputRequiredError) {
+      await platform.write(2, `${err.requestJson}
+`);
+      return 6;
+    }
+    await platform.write(2, `mcpcat: ${err.message}
+`);
+    return 5;
+  } finally {
+    try {
+      await conn.close();
+    } catch {
+    }
+  }
+}
+
+// src/platform/kernel.ts
+function kernelFs(ctx) {
+  return {
+    readFile: (path) => ctx.fs.readFile(path),
+    writeFile: (path, data) => ctx.fs.writeFile(path, data),
+    mkdir: (path) => ctx.fs.mkdir(path),
+    rename: (from, to) => ctx.fs.rename(from, to),
+    stat: (path) => ctx.fs.stat(path),
+    exists: (path) => ctx.fs.exists(path)
+  };
+}
+async function kernelSpawn(ctx, options) {
+  const result = await ctx.spawn({
+    argv: options.argv,
+    env: options.env,
+    cwd: options.cwd,
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  return {
+    stdin: result.stdin,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    wait: () => result.wait(),
+    kill: (signal) => result.kill(signal)
+  };
+}
+function createKernelPlatform(ctx) {
+  const encoder = new TextEncoder();
+  return {
+    fetch: ctx.fetch,
+    spawn: (options) => kernelSpawn(ctx, options),
+    fs: kernelFs(ctx),
+    env: ctx.env,
+    cwd: ctx.cwd,
+    isatty: (fd) => ctx.isatty(fd),
+    stdin: ctx.stdin,
+    stdout: ctx.stdout,
+    stderr: ctx.stderr,
+    async write(fd, data) {
+      await ctx.write(fd, typeof data === "string" ? encoder.encode(data) : data);
+    },
+    exit(code) {
+      ctx.exit(code);
+    }
+  };
+}
+
+// src/kernel.ts
+async function main(ctx) {
+  const platform = createKernelPlatform(ctx);
+  const args = ctx.argv.slice(1);
+  return run(platform, "0.2.0", args);
+}
+export {
+  main as default
+};