@ai-ecoverse/mcpcat 0.0.0 → 0.2.0

package/dist/host/mcpcat.mjs

@@ -0,0 +1,2626 @@
+#!/usr/bin/env node
+import { createRequire as __mcpcat_createRequire } from 'node:module';
+const require = __mcpcat_createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/isexe/windows.js
+var require_windows = __commonJS({
+  "node_modules/isexe/windows.js"(exports, module) {
+    module.exports = isexe;
+    isexe.sync = sync;
+    var fs = __require("fs");
+    function checkPathExt(path, options) {
+      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+      if (!pathext) {
+        return true;
+      }
+      pathext = pathext.split(";");
+      if (pathext.indexOf("") !== -1) {
+        return true;
+      }
+      for (var i = 0; i < pathext.length; i++) {
+        var p = pathext[i].toLowerCase();
+        if (p && path.substr(-p.length).toLowerCase() === p) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkStat(stat2, path, options) {
+      if (!stat2.isSymbolicLink() && !stat2.isFile()) {
+        return false;
+      }
+      return checkPathExt(path, options);
+    }
+    function isexe(path, options, cb) {
+      fs.stat(path, function(er, stat2) {
+        cb(er, er ? false : checkStat(stat2, path, options));
+      });
+    }
+    function sync(path, options) {
+      return checkStat(fs.statSync(path), path, options);
+    }
+  }
+});
+
+// node_modules/isexe/mode.js
+var require_mode = __commonJS({
+  "node_modules/isexe/mode.js"(exports, module) {
+    module.exports = isexe;
+    isexe.sync = sync;
+    var fs = __require("fs");
+    function isexe(path, options, cb) {
+      fs.stat(path, function(er, stat2) {
+        cb(er, er ? false : checkStat(stat2, options));
+      });
+    }
+    function sync(path, options) {
+      return checkStat(fs.statSync(path), options);
+    }
+    function checkStat(stat2, options) {
+      return stat2.isFile() && checkMode(stat2, options);
+    }
+    function checkMode(stat2, options) {
+      var mod = stat2.mode;
+      var uid = stat2.uid;
+      var gid = stat2.gid;
+      var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+      var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+      var u = parseInt("100", 8);
+      var g = parseInt("010", 8);
+      var o = parseInt("001", 8);
+      var ug = u | g;
+      var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+      return ret;
+    }
+  }
+});
+
+// node_modules/isexe/index.js
+var require_isexe = __commonJS({
+  "node_modules/isexe/index.js"(exports, module) {
+    var fs = __require("fs");
+    var core;
+    if (process.platform === "win32" || global.TESTING_WINDOWS) {
+      core = require_windows();
+    } else {
+      core = require_mode();
+    }
+    module.exports = isexe;
+    isexe.sync = sync;
+    function isexe(path, options, cb) {
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (!cb) {
+        if (typeof Promise !== "function") {
+          throw new TypeError("callback not provided");
+        }
+        return new Promise(function(resolve, reject) {
+          isexe(path, options || {}, function(er, is) {
+            if (er) {
+              reject(er);
+            } else {
+              resolve(is);
+            }
+          });
+        });
+      }
+      core(path, options || {}, function(er, is) {
+        if (er) {
+          if (er.code === "EACCES" || options && options.ignoreErrors) {
+            er = null;
+            is = false;
+          }
+        }
+        cb(er, is);
+      });
+    }
+    function sync(path, options) {
+      try {
+        return core.sync(path, options || {});
+      } catch (er) {
+        if (options && options.ignoreErrors || er.code === "EACCES") {
+          return false;
+        } else {
+          throw er;
+        }
+      }
+    }
+  }
+});
+
+// node_modules/which/which.js
+var require_which = __commonJS({
+  "node_modules/which/which.js"(exports, module) {
+    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+    var path = __require("path");
+    var COLON = isWindows ? ";" : ":";
+    var isexe = require_isexe();
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, opt) => {
+      const colon = opt.colon || COLON;
+      const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
+        "").split(colon)
+      ];
+      const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+      const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+      if (isWindows) {
+        if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+          pathExt.unshift("");
+      }
+      return {
+        pathEnv,
+        pathExt,
+        pathExtExe
+      };
+    };
+    var which = (cmd, opt, cb) => {
+      if (typeof opt === "function") {
+        cb = opt;
+        opt = {};
+      }
+      if (!opt)
+        opt = {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      const step = (i) => new Promise((resolve, reject) => {
+        if (i === pathEnv.length)
+          return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        resolve(subStep(p, i, 0));
+      });
+      const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+        if (ii === pathExt.length)
+          return resolve(step(i + 1));
+        const ext = pathExt[ii];
+        isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+          if (!er && is) {
+            if (opt.all)
+              found.push(p + ext);
+            else
+              return resolve(p + ext);
+          }
+          return resolve(subStep(p, i, ii + 1));
+        });
+      });
+      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+    };
+    var whichSync = (cmd, opt) => {
+      opt = opt || {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (let i = 0; i < pathEnv.length; i++) {
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        for (let j = 0; j < pathExt.length; j++) {
+          const cur = p + pathExt[j];
+          try {
+            const is = isexe.sync(cur, { pathExt: pathExtExe });
+            if (is) {
+              if (opt.all)
+                found.push(cur);
+              else
+                return cur;
+            }
+          } catch (ex) {
+          }
+        }
+      }
+      if (opt.all && found.length)
+        return found;
+      if (opt.nothrow)
+        return null;
+      throw getNotFoundError(cmd);
+    };
+    module.exports = which;
+    which.sync = whichSync;
+  }
+});
+
+// node_modules/path-key/index.js
+var require_path_key = __commonJS({
+  "node_modules/path-key/index.js"(exports, module) {
+    "use strict";
+    var pathKey = (options = {}) => {
+      const environment = options.env || process.env;
+      const platform2 = options.platform || process.platform;
+      if (platform2 !== "win32") {
+        return "PATH";
+      }
+      return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+    };
+    module.exports = pathKey;
+    module.exports.default = pathKey;
+  }
+});
+
+// node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS({
+  "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
+    "use strict";
+    var path = __require("path");
+    var which = require_which();
+    var getPathKey = require_path_key();
+    function resolveCommandAttempt(parsed, withoutPathExt) {
+      const env = parsed.options.env || process.env;
+      const cwd = process.cwd();
+      const hasCustomCwd = parsed.options.cwd != null;
+      const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+      if (shouldSwitchCwd) {
+        try {
+          process.chdir(parsed.options.cwd);
+        } catch (err) {
+        }
+      }
+      let resolved;
+      try {
+        resolved = which.sync(parsed.command, {
+          path: env[getPathKey({ env })],
+          pathExt: withoutPathExt ? path.delimiter : void 0
+        });
+      } catch (e) {
+      } finally {
+        if (shouldSwitchCwd) {
+          process.chdir(cwd);
+        }
+      }
+      if (resolved) {
+        resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      }
+      return resolved;
+    }
+    function resolveCommand(parsed) {
+      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+    }
+    module.exports = resolveCommand;
+  }
+});
+
+// node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS({
+  "node_modules/cross-spawn/lib/util/escape.js"(exports, module) {
+    "use strict";
+    var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+    function escapeCommand(arg) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      return arg;
+    }
+    function escapeArgument(arg, doubleEscapeMetaChars) {
+      arg = `${arg}`;
+      arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+      arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+      arg = `"${arg}"`;
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      if (doubleEscapeMetaChars) {
+        arg = arg.replace(metaCharsRegExp, "^$1");
+      }
+      return arg;
+    }
+    module.exports.command = escapeCommand;
+    module.exports.argument = escapeArgument;
+  }
+});
+
+// node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS({
+  "node_modules/shebang-regex/index.js"(exports, module) {
+    "use strict";
+    module.exports = /^#!(.*)/;
+  }
+});
+
+// node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS({
+  "node_modules/shebang-command/index.js"(exports, module) {
+    "use strict";
+    var shebangRegex = require_shebang_regex();
+    module.exports = (string = "") => {
+      const match = string.match(shebangRegex);
+      if (!match) {
+        return null;
+      }
+      const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path.split("/").pop();
+      if (binary === "env") {
+        return argument;
+      }
+      return argument ? `${binary} ${argument}` : binary;
+    };
+  }
+});
+
+// node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS({
+  "node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var shebangCommand = require_shebang_command();
+    function readShebang(command) {
+      const size = 150;
+      const buffer = Buffer.alloc(size);
+      let fd;
+      try {
+        fd = fs.openSync(command, "r");
+        fs.readSync(fd, buffer, 0, size, 0);
+        fs.closeSync(fd);
+      } catch (e) {
+      }
+      return shebangCommand(buffer.toString());
+    }
+    module.exports = readShebang;
+  }
+});
+
+// node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS({
+  "node_modules/cross-spawn/lib/parse.js"(exports, module) {
+    "use strict";
+    var path = __require("path");
+    var resolveCommand = require_resolveCommand();
+    var escape = require_escape();
+    var readShebang = require_readShebang();
+    var isWin = process.platform === "win32";
+    var isExecutableRegExp = /\.(?:com|exe)$/i;
+    var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+    function detectShebang(parsed) {
+      parsed.file = resolveCommand(parsed);
+      const shebang = parsed.file && readShebang(parsed.file);
+      if (shebang) {
+        parsed.args.unshift(parsed.file);
+        parsed.command = shebang;
+        return resolveCommand(parsed);
+      }
+      return parsed.file;
+    }
+    function parseNonShell(parsed) {
+      if (!isWin) {
+        return parsed;
+      }
+      const commandFile = detectShebang(parsed);
+      const needsShell = !isExecutableRegExp.test(commandFile);
+      if (parsed.options.forceShell || needsShell) {
+        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+        parsed.command = path.normalize(parsed.command);
+        parsed.command = escape.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+        const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+        parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+        parsed.command = process.env.comspec || "cmd.exe";
+        parsed.options.windowsVerbatimArguments = true;
+      }
+      return parsed;
+    }
+    function parse(command, args2, options) {
+      if (args2 && !Array.isArray(args2)) {
+        options = args2;
+        args2 = null;
+      }
+      args2 = args2 ? args2.slice(0) : [];
+      options = Object.assign({}, options);
+      const parsed = {
+        command,
+        args: args2,
+        options,
+        file: void 0,
+        original: {
+          command,
+          args: args2
+        }
+      };
+      return options.shell ? parsed : parseNonShell(parsed);
+    }
+    module.exports = parse;
+  }
+});
+
+// node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS({
+  "node_modules/cross-spawn/lib/enoent.js"(exports, module) {
+    "use strict";
+    var isWin = process.platform === "win32";
+    function notFoundError(original, syscall) {
+      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+        code: "ENOENT",
+        errno: "ENOENT",
+        syscall: `${syscall} ${original.command}`,
+        path: original.command,
+        spawnargs: original.args
+      });
+    }
+    function hookChildProcess(cp, parsed) {
+      if (!isWin) {
+        return;
+      }
+      const originalEmit = cp.emit;
+      cp.emit = function(name, arg1) {
+        if (name === "exit") {
+          const err = verifyENOENT(arg1, parsed);
+          if (err) {
+            return originalEmit.call(cp, "error", err);
+          }
+        }
+        return originalEmit.apply(cp, arguments);
+      };
+    }
+    function verifyENOENT(status, parsed) {
+      if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawn");
+      }
+      return null;
+    }
+    function verifyENOENTSync(status, parsed) {
+      if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawnSync");
+      }
+      return null;
+    }
+    module.exports = {
+      hookChildProcess,
+      verifyENOENT,
+      verifyENOENTSync,
+      notFoundError
+    };
+  }
+});
+
+// node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS({
+  "node_modules/cross-spawn/index.js"(exports, module) {
+    "use strict";
+    var cp = __require("child_process");
+    var parse = require_parse();
+    var enoent = require_enoent();
+    function spawn2(command, args2, options) {
+      const parsed = parse(command, args2, options);
+      const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+      enoent.hookChildProcess(spawned, parsed);
+      return spawned;
+    }
+    function spawnSync(command, args2, options) {
+      const parsed = parse(command, args2, options);
+      const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+      return result;
+    }
+    module.exports = spawn2;
+    module.exports.spawn = spawn2;
+    module.exports.sync = spawnSync;
+    module.exports._parse = parse;
+    module.exports._enoent = enoent;
+  }
+});
+
+// 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(code2, message, data) {
+    super(message);
+    this.name = "McpError";
+    this.code = code2;
+    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, args2, options = {}) {
+    return validateCallToolResult(await this.request("tools/call", { name, ...args2 === void 0 ? {} : { arguments: args2 } }, 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();
+  }
+};
+
+// node_modules/@earendil-works/pi-mcp/dist/transports/stdio.js
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+import { spawn } from "node:child_process";
+import process2 from "node:process";
+
+// 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 = process2.platform !== "win32";
+var liveProcessGroups = /* @__PURE__ */ new Set();
+var exitHookInstalled = false;
+function killProcessTree(child, signal) {
+  const pid = child.pid;
+  if (process2.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 {
+      process2.kill(-pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+function installExitHook() {
+  if (exitHookInstalled)
+    return;
+  exitHookInstalled = true;
+  process2.once("exit", () => {
+    for (const pid of liveProcessGroups) {
+      try {
+        process2.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 } : { ...process2.env, ...this.options.env };
+    const child = (0, import_cross_spawn.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 code2 = error?.code;
+    return typeof code2 === "string" && (code2.startsWith("E") || code2.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, args2) {
+      return client.callTool(name, args2);
+    },
+    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(code2, message, data) {
+    super(`MCP RPC error ${code2}: ${message}`);
+    this.name = "StatelessRpcError";
+    this.code = code2;
+    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, args2) {
+      const result = await request("tools/call", {
+        name,
+        arguments: args2 ?? {}
+      });
+      const resultType = result.resultType ?? "complete";
+      if (resultType === "input_required") {
+        throw new InputRequiredError(
+          JSON.stringify({ name, arguments: args2 ?? {}, result }, null, 2)
+        );
+      }
+      return result;
+    },
+    async close() {
+    }
+  };
+}
+
+// src/client/connect.ts
+async function connect(platform2, 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: platform2.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(platform2) {
+  const home = platform2.env.HOME ?? platform2.env.USERPROFILE ?? "";
+  const piDir = platform2.env.PI_CODING_AGENT_DIR ?? `${home}/.pi/agent`;
+  const configPath = `${piDir}/mcp.json`;
+  return {
+    async get(name) {
+      try {
+        const exists = await platform2.fs.exists(configPath);
+        if (!exists) return void 0;
+        const data = await platform2.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(args2) {
+  const headers = {};
+  let dataArg;
+  let protocolVersion;
+  let showSchema = false;
+  const positional = [];
+  let trailingCommand;
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--") {
+      trailingCommand = args2.slice(i + 1);
+      break;
+    }
+    if ((arg === "-H" || arg === "--header") && args2[i + 1]) {
+      const val = args2[++i];
+      const colonIdx = val.indexOf(":");
+      if (colonIdx > 0) {
+        headers[val.slice(0, colonIdx).trim()] = val.slice(colonIdx + 1).trim();
+      }
+    } else if (arg === "-d" && args2[i + 1]) {
+      dataArg = args2[++i];
+    } else if (arg === "--protocol-version" && args2[i + 1]) {
+      protocolVersion = args2[++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(args2) {
+  const flags = parseFlags(args2);
+  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(platform2, dataArg) {
+  let raw;
+  if (dataArg.startsWith("@-")) {
+    const reader = platform2.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 platform2.fs.readFile(dataArg.slice(1));
+    raw = new TextDecoder().decode(data);
+  } else {
+    raw = dataArg;
+  }
+  return JSON.parse(raw);
+}
+async function runInfo(platform2, 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 platform2.write(1, `${lines.join("\n")}
+`);
+  return 0;
+}
+async function runTools(platform2, conn) {
+  const tools = await conn.listTools();
+  if (tools.length === 0) {
+    await platform2.write(1, "(no tools)\n");
+  } else {
+    await platform2.write(1, `${tools.map(formatToolLine).join("\n")}
+`);
+  }
+  return 0;
+}
+async function runCall(platform2, conn, toolName, dataArg) {
+  let toolArgs = {};
+  if (dataArg) {
+    try {
+      toolArgs = await readDataArg(platform2, dataArg);
+    } catch (err) {
+      await platform2.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 platform2.write(2, `${output}
+`);
+    return 1;
+  }
+  await platform2.write(1, `${output}
+`);
+  return 0;
+}
+async function runDescribe(platform2, conn, toolName, showSchema) {
+  const tools = await conn.listTools();
+  if (toolName) {
+    const tool = tools.find((t) => t.name === toolName);
+    if (!tool) {
+      await platform2.write(2, `mcpcat: tool '${toolName}' not found
+`);
+      return 2;
+    }
+    if (showSchema && tool.inputSchema) {
+      await platform2.write(1, `${JSON.stringify(tool.inputSchema, null, 2)}
+`);
+    } else {
+      await platform2.write(1, `${formatToolSchema(tool)}
+`);
+    }
+  } else {
+    for (const tool of tools) {
+      await platform2.write(1, `${formatToolSchema(tool)}
+
+`);
+    }
+  }
+  return 0;
+}
+async function runVerb(platform2, parsed, conn) {
+  switch (parsed.verb) {
+    case "info":
+      return runInfo(platform2, conn);
+    case "tools":
+      return runTools(platform2, conn);
+    case "call":
+      return runCall(platform2, conn, parsed.toolName, parsed.dataArg);
+    case "describe":
+      return runDescribe(platform2, conn, parsed.toolName, parsed.showSchema);
+    default:
+      await platform2.write(2, `mcpcat: unknown command '${parsed.verb}'
+`);
+      return 2;
+  }
+}
+async function run(platform2, version, args2) {
+  if (args2.includes("--version") || args2.includes("-V")) {
+    await platform2.write(1, `${version}
+`);
+    return 0;
+  }
+  if (args2.includes("--help") || args2.includes("-h") || args2[0] === "help") {
+    await platform2.write(1, helpText(version));
+    return 0;
+  }
+  if (args2.length === 0) {
+    await platform2.write(1, helpText(version));
+    return 0;
+  }
+  const parsed = parseArgs(args2);
+  if (!parsed.verb) {
+    await platform2.write(2, "mcpcat: no verb or target given\n");
+    return 2;
+  }
+  if (UNIMPLEMENTED_VERBS.has(parsed.verb)) {
+    await platform2.write(2, `mcpcat: '${parsed.verb}' is not implemented yet
+`);
+    return 1;
+  }
+  if (!CLIENT_VERBS.has(parsed.verb)) {
+    await platform2.write(2, `mcpcat: unknown command '${parsed.verb}'
+`);
+    return 2;
+  }
+  if (parsed.verb === "call" && !parsed.toolName) {
+    await platform2.write(2, "mcpcat: call requires a tool name\n");
+    return 2;
+  }
+  if (!parsed.target) {
+    await platform2.write(2, `mcpcat: ${parsed.verb} requires a target
+`);
+    return 2;
+  }
+  const config = createConfigSource(platform2);
+  let resolved;
+  try {
+    resolved = await resolveTarget(
+      parsed.target === "__trailing__" ? "" : parsed.target,
+      parsed.trailingCommand,
+      config
+    );
+  } catch (err) {
+    await platform2.write(2, `mcpcat: ${err.message}
+`);
+    return 2;
+  }
+  let conn;
+  try {
+    conn = await connect(platform2, {
+      ...resolved,
+      headers: { ...resolved.headers, ...parsed.headers },
+      protocolVersion: parsed.protocolVersion,
+      version
+    });
+  } catch (err) {
+    await platform2.write(2, `mcpcat: connection failed: ${err.message}
+`);
+    return 3;
+  }
+  try {
+    return await runVerb(platform2, parsed, conn);
+  } catch (err) {
+    if (err instanceof InputRequiredError) {
+      await platform2.write(2, `${err.requestJson}
+`);
+      return 6;
+    }
+    await platform2.write(2, `mcpcat: ${err.message}
+`);
+    return 5;
+  } finally {
+    try {
+      await conn.close();
+    } catch {
+    }
+  }
+}
+
+// src/platform/host.ts
+import { spawn as cpSpawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { Readable, Writable } from "node:stream";
+import * as tty from "node:tty";
+function nodeSpawn(options) {
+  const child = cpSpawn(options.argv[0], options.argv.slice(1), {
+    env: options.env ?? process.env,
+    cwd: options.cwd,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const stdout = Readable.toWeb(child.stdout);
+  const stderr = Readable.toWeb(child.stderr);
+  const stdin = Writable.toWeb(child.stdin);
+  return Promise.resolve({
+    stdin,
+    stdout,
+    stderr,
+    wait() {
+      return new Promise((resolve) => {
+        child.on("close", (code2, signal) => {
+          resolve({
+            status: signal ? 128 + (signalNumber(signal) ?? 0) : code2 ?? 1,
+            signal: signal ?? void 0
+          });
+        });
+      });
+    },
+    kill(signal) {
+      child.kill(signal ?? "SIGTERM");
+    }
+  });
+}
+function signalNumber(sig) {
+  const map = {
+    SIGHUP: 1,
+    SIGINT: 2,
+    SIGQUIT: 3,
+    SIGTERM: 15,
+    SIGKILL: 9
+  };
+  return map[sig];
+}
+var hostFs = {
+  async readFile(path) {
+    return new Uint8Array(await readFile(path));
+  },
+  async writeFile(path, data) {
+    await writeFile(path, data);
+  },
+  async mkdir(path) {
+    await mkdir(path, { recursive: true });
+  },
+  async rename(from, to) {
+    await rename(from, to);
+  },
+  async stat(path) {
+    const s = await stat(path);
+    return { size: s.size, mtimeMs: s.mtimeMs };
+  },
+  async exists(path) {
+    try {
+      await access(path, constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function createStdinStream() {
+  return Readable.toWeb(process.stdin);
+}
+function createStdoutStream() {
+  return Writable.toWeb(process.stdout);
+}
+function createStderrStream() {
+  return Writable.toWeb(process.stderr);
+}
+function createHostPlatform() {
+  const encoder = new TextEncoder();
+  return {
+    fetch: globalThis.fetch,
+    spawn: nodeSpawn,
+    fs: hostFs,
+    env: process.env,
+    cwd: process.cwd(),
+    isatty(fd) {
+      return tty.isatty(fd);
+    },
+    stdin: createStdinStream(),
+    stdout: createStdoutStream(),
+    stderr: createStderrStream(),
+    async write(fd, data) {
+      const bytes = typeof data === "string" ? encoder.encode(data) : data;
+      const stream = fd === 1 ? process.stdout : process.stderr;
+      return new Promise((resolve, reject) => {
+        stream.write(bytes, (err) => err ? reject(err) : resolve());
+      });
+    },
+    exit(code2) {
+      process.exit(code2);
+    }
+  };
+}
+
+// src/host.ts
+var platform = createHostPlatform();
+var args = process.argv.slice(2);
+var code = await run(platform, "0.2.0", args);
+process.exit(code);