privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-E4Z3Y5B5.mjs

@@ -0,0 +1,3864 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  getShellConfig
+} from "./c-6ZO2SADQ.mjs";
+import {
+  getAgentDir,
+  getFileRevision,
+  normalizePath,
+  require_cross_spawn,
+  stripBom
+} from "./c-PTN4S6G2.mjs";
+import {
+  __commonJS,
+  __name,
+  __require,
+  __toESM
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS({
+  "node_modules/graceful-fs/polyfills.js"(exports, module) {
+    var constants = __require("constants");
+    var origCwd = process.cwd;
+    var cwd = null;
+    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    process.cwd = function() {
+      if (!cwd)
+        cwd = origCwd.call(process);
+      return cwd;
+    };
+    try {
+      process.cwd();
+    } catch (er) {
+    }
+    if (typeof process.chdir === "function") {
+      chdir = process.chdir;
+      process.chdir = function(d) {
+        cwd = null;
+        chdir.call(process, d);
+      };
+      if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+    }
+    var chdir;
+    module.exports = patch;
+    function patch(fs) {
+      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        patchLchmod(fs);
+      }
+      if (!fs.lutimes) {
+        patchLutimes(fs);
+      }
+      fs.chown = chownFix(fs.chown);
+      fs.fchown = chownFix(fs.fchown);
+      fs.lchown = chownFix(fs.lchown);
+      fs.chmod = chmodFix(fs.chmod);
+      fs.fchmod = chmodFix(fs.fchmod);
+      fs.lchmod = chmodFix(fs.lchmod);
+      fs.chownSync = chownFixSync(fs.chownSync);
+      fs.fchownSync = chownFixSync(fs.fchownSync);
+      fs.lchownSync = chownFixSync(fs.lchownSync);
+      fs.chmodSync = chmodFixSync(fs.chmodSync);
+      fs.fchmodSync = chmodFixSync(fs.fchmodSync);
+      fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+      fs.stat = statFix(fs.stat);
+      fs.fstat = statFix(fs.fstat);
+      fs.lstat = statFix(fs.lstat);
+      fs.statSync = statFixSync(fs.statSync);
+      fs.fstatSync = statFixSync(fs.fstatSync);
+      fs.lstatSync = statFixSync(fs.lstatSync);
+      if (fs.chmod && !fs.lchmod) {
+        fs.lchmod = function(path, mode, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs.lchmodSync = function() {
+        };
+      }
+      if (fs.chown && !fs.lchown) {
+        fs.lchown = function(path, uid, gid, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs.lchownSync = function() {
+        };
+      }
+      if (platform === "win32") {
+        fs.rename = typeof fs.rename !== "function" ? fs.rename : (function(fs$rename) {
+          function rename(from, to, cb) {
+            var start = Date.now();
+            var backoff = 0;
+            fs$rename(from, to, /* @__PURE__ */ __name(function CB(er) {
+              if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
+                setTimeout(function() {
+                  fs.stat(to, function(stater, st) {
+                    if (stater && stater.code === "ENOENT")
+                      fs$rename(from, to, CB);
+                    else
+                      cb(er);
+                  });
+                }, backoff);
+                if (backoff < 100)
+                  backoff += 10;
+                return;
+              }
+              if (cb) cb(er);
+            }, "CB"));
+          }
+          __name(rename, "rename");
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+          return rename;
+        })(fs.rename);
+      }
+      fs.read = typeof fs.read !== "function" ? fs.read : (function(fs$read) {
+        function read(fd, buffer, offset, length, position, callback_) {
+          var callback;
+          if (callback_ && typeof callback_ === "function") {
+            var eagCounter = 0;
+            callback = /* @__PURE__ */ __name(function(er, _, __) {
+              if (er && er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            }, "callback");
+          }
+          return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+        }
+        __name(read, "read");
+        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+        return read;
+      })(fs.read);
+      fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : /* @__PURE__ */ (function(fs$readSync) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      })(fs.readSync);
+      function patchLchmod(fs2) {
+        fs2.lchmod = function(path, mode, callback) {
+          fs2.open(
+            path,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback) callback(err);
+                return;
+              }
+              fs2.fchmod(fd, mode, function(err2) {
+                fs2.close(fd, function(err22) {
+                  if (callback) callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs2.lchmodSync = function(path, mode) {
+          var fd = fs2.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs2.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs2.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs2.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      __name(patchLchmod, "patchLchmod");
+      function patchLutimes(fs2) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
+          fs2.lutimes = function(path, at, mt, cb) {
+            fs2.open(path, constants.O_SYMLINK, function(er, fd) {
+              if (er) {
+                if (cb) cb(er);
+                return;
+              }
+              fs2.futimes(fd, at, mt, function(er2) {
+                fs2.close(fd, function(er22) {
+                  if (cb) cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs2.lutimesSync = function(path, at, mt) {
+            var fd = fs2.openSync(path, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs2.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs2.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs2.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs2.futimes) {
+          fs2.lutimes = function(_a, _b, _c, cb) {
+            if (cb) process.nextTick(cb);
+          };
+          fs2.lutimesSync = function() {
+          };
+        }
+      }
+      __name(patchLutimes, "patchLutimes");
+      function chmodFix(orig) {
+        if (!orig) return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs, target, mode, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
+      }
+      __name(chmodFix, "chmodFix");
+      function chmodFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, mode) {
+          try {
+            return orig.call(fs, target, mode);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      __name(chmodFixSync, "chmodFixSync");
+      function chownFix(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid, cb) {
+          return orig.call(fs, target, uid, gid, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
+      }
+      __name(chownFix, "chownFix");
+      function chownFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid) {
+          try {
+            return orig.call(fs, target, uid, gid);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      __name(chownFixSync, "chownFixSync");
+      function statFix(orig) {
+        if (!orig) return orig;
+        return function(target, options, cb) {
+          if (typeof options === "function") {
+            cb = options;
+            options = null;
+          }
+          function callback(er, stats) {
+            if (stats) {
+              if (stats.uid < 0) stats.uid += 4294967296;
+              if (stats.gid < 0) stats.gid += 4294967296;
+            }
+            if (cb) cb.apply(this, arguments);
+          }
+          __name(callback, "callback");
+          return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
+        };
+      }
+      __name(statFix, "statFix");
+      function statFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, options) {
+          var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
+          if (stats) {
+            if (stats.uid < 0) stats.uid += 4294967296;
+            if (stats.gid < 0) stats.gid += 4294967296;
+          }
+          return stats;
+        };
+      }
+      __name(statFixSync, "statFixSync");
+      function chownErOk(er) {
+        if (!er)
+          return true;
+        if (er.code === "ENOSYS")
+          return true;
+        var nonroot = !process.getuid || process.getuid() !== 0;
+        if (nonroot) {
+          if (er.code === "EINVAL" || er.code === "EPERM")
+            return true;
+        }
+        return false;
+      }
+      __name(chownErOk, "chownErOk");
+    }
+    __name(patch, "patch");
+  }
+});
+
+// node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS({
+  "node_modules/graceful-fs/legacy-streams.js"(exports, module) {
+    var Stream = __require("stream").Stream;
+    module.exports = legacy;
+    function legacy(fs) {
+      return {
+        ReadStream,
+        WriteStream
+      };
+      function ReadStream(path, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+        Stream.call(this);
+        var self = this;
+        this.path = path;
+        this.fd = null;
+        this.readable = true;
+        this.paused = false;
+        this.flags = "r";
+        this.mode = 438;
+        this.bufferSize = 64 * 1024;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.encoding) this.setEncoding(this.encoding);
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.end === void 0) {
+            this.end = Infinity;
+          } else if ("number" !== typeof this.end) {
+            throw TypeError("end must be a Number");
+          }
+          if (this.start > this.end) {
+            throw new Error("start must be <= end");
+          }
+          this.pos = this.start;
+        }
+        if (this.fd !== null) {
+          process.nextTick(function() {
+            self._read();
+          });
+          return;
+        }
+        fs.open(this.path, this.flags, this.mode, function(err, fd) {
+          if (err) {
+            self.emit("error", err);
+            self.readable = false;
+            return;
+          }
+          self.fd = fd;
+          self.emit("open", fd);
+          self._read();
+        });
+      }
+      __name(ReadStream, "ReadStream");
+      function WriteStream(path, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+        Stream.call(this);
+        this.path = path;
+        this.fd = null;
+        this.writable = true;
+        this.flags = "w";
+        this.encoding = "binary";
+        this.mode = 438;
+        this.bytesWritten = 0;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.start < 0) {
+            throw new Error("start must be >= zero");
+          }
+          this.pos = this.start;
+        }
+        this.busy = false;
+        this._queue = [];
+        if (this.fd === null) {
+          this._open = fs.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
+      }
+      __name(WriteStream, "WriteStream");
+    }
+    __name(legacy, "legacy");
+  }
+});
+
+// node_modules/graceful-fs/clone.js
+var require_clone = __commonJS({
+  "node_modules/graceful-fs/clone.js"(exports, module) {
+    "use strict";
+    module.exports = clone;
+    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
+    }
+    __name(clone, "clone");
+  }
+});
+
+// node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = __commonJS({
+  "node_modules/graceful-fs/graceful-fs.js"(exports, module) {
+    var fs = __require("fs");
+    var polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone = require_clone();
+    var util = __require("util");
+    var gracefulQueue;
+    var previousSymbol;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+      gracefulQueue = /* @__PURE__ */ Symbol.for("graceful-fs.queue");
+      previousSymbol = /* @__PURE__ */ Symbol.for("graceful-fs.previous");
+    } else {
+      gracefulQueue = "___graceful-fs.queue";
+      previousSymbol = "___graceful-fs.previous";
+    }
+    function noop() {
+    }
+    __name(noop, "noop");
+    function publishQueue(context, queue2) {
+      Object.defineProperty(context, gracefulQueue, {
+        get: /* @__PURE__ */ __name(function() {
+          return queue2;
+        }, "get")
+      });
+    }
+    __name(publishQueue, "publishQueue");
+    var debug = noop;
+    if (util.debuglog)
+      debug = util.debuglog("gfs4");
+    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+      debug = /* @__PURE__ */ __name(function() {
+        var m = util.format.apply(util, arguments);
+        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+        console.error(m);
+      }, "debug");
+    if (!fs[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs, queue);
+      fs.close = (function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        __name(close, "close");
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      })(fs.close);
+      fs.closeSync = (function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs, arguments);
+          resetQueue();
+        }
+        __name(closeSync, "closeSync");
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      })(fs.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug(fs[gracefulQueue]);
+          __require("assert").equal(fs[gracefulQueue].length, 0);
+        });
+      }
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      publishQueue(global, fs[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+      module.exports = patch(fs);
+      fs.__patched = true;
+    }
+    function patch(fs2) {
+      polyfills(fs2);
+      fs2.gracefulify = patch;
+      fs2.createReadStream = createReadStream;
+      fs2.createWriteStream = createWriteStream;
+      var fs$readFile = fs2.readFile;
+      fs2.readFile = readFile;
+      function readFile(path, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$readFile(path, options, cb);
+        function go$readFile(path2, options2, cb2, startTime) {
+          return fs$readFile(path2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$readFile, [path2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+        __name(go$readFile, "go$readFile");
+      }
+      __name(readFile, "readFile");
+      var fs$writeFile = fs2.writeFile;
+      fs2.writeFile = writeFile;
+      function writeFile(path, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$writeFile(path, data, options, cb);
+        function go$writeFile(path2, data2, options2, cb2, startTime) {
+          return fs$writeFile(path2, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$writeFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+        __name(go$writeFile, "go$writeFile");
+      }
+      __name(writeFile, "writeFile");
+      var fs$appendFile = fs2.appendFile;
+      if (fs$appendFile)
+        fs2.appendFile = appendFile;
+      function appendFile(path, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$appendFile(path, data, options, cb);
+        function go$appendFile(path2, data2, options2, cb2, startTime) {
+          return fs$appendFile(path2, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$appendFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+        __name(go$appendFile, "go$appendFile");
+      }
+      __name(appendFile, "appendFile");
+      var fs$copyFile = fs2.copyFile;
+      if (fs$copyFile)
+        fs2.copyFile = copyFile;
+      function copyFile(src, dest, flags, cb) {
+        if (typeof flags === "function") {
+          cb = flags;
+          flags = 0;
+        }
+        return go$copyFile(src, dest, flags, cb);
+        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
+          return fs$copyFile(src2, dest2, flags2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+        __name(go$copyFile, "go$copyFile");
+      }
+      __name(copyFile, "copyFile");
+      var fs$readdir = fs2.readdir;
+      fs2.readdir = readdir;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir(path, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? /* @__PURE__ */ __name(function go$readdir2(path2, options2, cb2, startTime) {
+          return fs$readdir(path2, fs$readdirCallback(
+            path2,
+            options2,
+            cb2,
+            startTime
+          ));
+        }, "go$readdir") : /* @__PURE__ */ __name(function go$readdir2(path2, options2, cb2, startTime) {
+          return fs$readdir(path2, options2, fs$readdirCallback(
+            path2,
+            options2,
+            cb2,
+            startTime
+          ));
+        }, "go$readdir");
+        return go$readdir(path, options, cb);
+        function fs$readdirCallback(path2, options2, cb2, startTime) {
+          return function(err, files) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([
+                go$readdir,
+                [path2, options2, cb2],
+                err,
+                startTime || Date.now(),
+                Date.now()
+              ]);
+            else {
+              if (files && files.sort)
+                files.sort();
+              if (typeof cb2 === "function")
+                cb2.call(this, err, files);
+            }
+          };
+        }
+        __name(fs$readdirCallback, "fs$readdirCallback");
+      }
+      __name(readdir, "readdir");
+      if (process.version.substr(0, 4) === "v0.8") {
+        var legStreams = legacy(fs2);
+        ReadStream = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs2.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs2.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs2, "ReadStream", {
+        get: /* @__PURE__ */ __name(function() {
+          return ReadStream;
+        }, "get"),
+        set: /* @__PURE__ */ __name(function(val) {
+          ReadStream = val;
+        }, "set"),
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs2, "WriteStream", {
+        get: /* @__PURE__ */ __name(function() {
+          return WriteStream;
+        }, "get"),
+        set: /* @__PURE__ */ __name(function(val) {
+          WriteStream = val;
+        }, "set"),
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream;
+      Object.defineProperty(fs2, "FileReadStream", {
+        get: /* @__PURE__ */ __name(function() {
+          return FileReadStream;
+        }, "get"),
+        set: /* @__PURE__ */ __name(function(val) {
+          FileReadStream = val;
+        }, "set"),
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs2, "FileWriteStream", {
+        get: /* @__PURE__ */ __name(function() {
+          return FileWriteStream;
+        }, "get"),
+        set: /* @__PURE__ */ __name(function(val) {
+          FileWriteStream = val;
+        }, "set"),
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream(path, options) {
+        if (this instanceof ReadStream)
+          return fs$ReadStream.apply(this, arguments), this;
+        else
+          return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+      }
+      __name(ReadStream, "ReadStream");
+      function ReadStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            if (that.autoClose)
+              that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+            that.read();
+          }
+        });
+      }
+      __name(ReadStream$open, "ReadStream$open");
+      function WriteStream(path, options) {
+        if (this instanceof WriteStream)
+          return fs$WriteStream.apply(this, arguments), this;
+        else
+          return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+      }
+      __name(WriteStream, "WriteStream");
+      function WriteStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+          }
+        });
+      }
+      __name(WriteStream$open, "WriteStream$open");
+      function createReadStream(path, options) {
+        return new fs2.ReadStream(path, options);
+      }
+      __name(createReadStream, "createReadStream");
+      function createWriteStream(path, options) {
+        return new fs2.WriteStream(path, options);
+      }
+      __name(createWriteStream, "createWriteStream");
+      var fs$open = fs2.open;
+      fs2.open = open;
+      function open(path, flags, mode, cb) {
+        if (typeof mode === "function")
+          cb = mode, mode = null;
+        return go$open(path, flags, mode, cb);
+        function go$open(path2, flags2, mode2, cb2, startTime) {
+          return fs$open(path2, flags2, mode2, function(err, fd) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$open, [path2, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+        __name(go$open, "go$open");
+      }
+      __name(open, "open");
+      return fs2;
+    }
+    __name(patch, "patch");
+    function enqueue(elem) {
+      debug("ENQUEUE", elem[0].name, elem[1]);
+      fs[gracefulQueue].push(elem);
+      retry();
+    }
+    __name(enqueue, "enqueue");
+    var retryTimer;
+    function resetQueue() {
+      var now = Date.now();
+      for (var i = 0; i < fs[gracefulQueue].length; ++i) {
+        if (fs[gracefulQueue][i].length > 2) {
+          fs[gracefulQueue][i][3] = now;
+          fs[gracefulQueue][i][4] = now;
+        }
+      }
+      retry();
+    }
+    __name(resetQueue, "resetQueue");
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs[gracefulQueue].length === 0)
+        return;
+      var elem = fs[gracefulQueue].shift();
+      var fn = elem[0];
+      var args = elem[1];
+      var err = elem[2];
+      var startTime = elem[3];
+      var lastTime = elem[4];
+      if (startTime === void 0) {
+        debug("RETRY", fn.name, args);
+        fn.apply(null, args);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug("TIMEOUT", fn.name, args);
+        var cb = args.pop();
+        if (typeof cb === "function")
+          cb.call(null, err);
+      } else {
+        var sinceAttempt = Date.now() - lastTime;
+        var sinceStart = Math.max(lastTime - startTime, 1);
+        var desiredDelay = Math.min(sinceStart * 1.2, 100);
+        if (sinceAttempt >= desiredDelay) {
+          debug("RETRY", fn.name, args);
+          fn.apply(null, args.concat([startTime]));
+        } else {
+          fs[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
+      }
+    }
+    __name(retry, "retry");
+  }
+});
+
+// node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS({
+  "node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/node_modules/retry/lib/retry_operation.js"(exports, module) {
+    function RetryOperation(timeouts, options) {
+      if (typeof options === "boolean") {
+        options = { forever: options };
+      }
+      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+      this._timeouts = timeouts;
+      this._options = options || {};
+      this._maxRetryTime = options && options.maxRetryTime || Infinity;
+      this._fn = null;
+      this._errors = [];
+      this._attempts = 1;
+      this._operationTimeout = null;
+      this._operationTimeoutCb = null;
+      this._timeout = null;
+      this._operationStart = null;
+      if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+      }
+    }
+    __name(RetryOperation, "RetryOperation");
+    module.exports = RetryOperation;
+    RetryOperation.prototype.reset = function() {
+      this._attempts = 1;
+      this._timeouts = this._originalTimeouts;
+    };
+    RetryOperation.prototype.stop = function() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      this._timeouts = [];
+      this._cachedTimeouts = null;
+    };
+    RetryOperation.prototype.retry = function(err) {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (!err) {
+        return false;
+      }
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout = this._timeouts.shift();
+      if (timeout === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(this._errors.length - 1, this._errors.length);
+          this._timeouts = this._cachedTimeouts.slice(0);
+          timeout = this._timeouts.shift();
+        } else {
+          return false;
+        }
+      }
+      var self = this;
+      var timer = setTimeout(function() {
+        self._attempts++;
+        if (self._operationTimeoutCb) {
+          self._timeout = setTimeout(function() {
+            self._operationTimeoutCb(self._attempts);
+          }, self._operationTimeout);
+          if (self._options.unref) {
+            self._timeout.unref();
+          }
+        }
+        self._fn(self._attempts);
+      }, timeout);
+      if (this._options.unref) {
+        timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self._operationTimeoutCb();
+        }, self._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
+  }
+});
+
+// node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/node_modules/retry/lib/retry.js
+var require_retry = __commonJS({
+  "node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/node_modules/retry/lib/retry.js"(exports) {
+    var RetryOperation = require_retry_operation();
+    exports.operation = function(options) {
+      var timeouts = exports.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && options.forever,
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a, b) {
+        return a - b;
+      });
+      return timeouts;
+    };
+    exports.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
+          }
+        }
+      }
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = (/* @__PURE__ */ __name(function retryWrapper(original2) {
+          var op = exports.operation(options);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }, "retryWrapper")).bind(obj, original);
+        obj[method].options = options;
+      }
+    };
+  }
+});
+
+// node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/node_modules/retry/index.js
+var require_retry2 = __commonJS({
+  "node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/node_modules/retry/index.js"(exports, module) {
+    module.exports = require_retry();
+  }
+});
+
+// node_modules/@earendil-works/pi-coding-agent/node_modules/signal-exit/signals.js
+var require_signals = __commonJS({
+  "node_modules/@earendil-works/pi-coding-agent/node_modules/signal-exit/signals.js"(exports, module) {
+    module.exports = [
+      "SIGABRT",
+      "SIGALRM",
+      "SIGHUP",
+      "SIGINT",
+      "SIGTERM"
+    ];
+    if (process.platform !== "win32") {
+      module.exports.push(
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (process.platform === "linux") {
+      module.exports.push(
+        "SIGIO",
+        "SIGPOLL",
+        "SIGPWR",
+        "SIGSTKFLT",
+        "SIGUNUSED"
+      );
+    }
+  }
+});
+
+// node_modules/@earendil-works/pi-coding-agent/node_modules/signal-exit/index.js
+var require_signal_exit = __commonJS({
+  "node_modules/@earendil-works/pi-coding-agent/node_modules/signal-exit/index.js"(exports, module) {
+    var process3 = global.process;
+    var processOk = /* @__PURE__ */ __name(function(process4) {
+      return process4 && typeof process4 === "object" && typeof process4.removeListener === "function" && typeof process4.emit === "function" && typeof process4.reallyExit === "function" && typeof process4.listeners === "function" && typeof process4.kill === "function" && typeof process4.pid === "number" && typeof process4.on === "function";
+    }, "processOk");
+    if (!processOk(process3)) {
+      module.exports = function() {
+        return function() {
+        };
+      };
+    } else {
+      assert = __require("assert");
+      signals = require_signals();
+      isWin = /^win/i.test(process3.platform);
+      EE = __require("events");
+      if (typeof EE !== "function") {
+        EE = EE.EventEmitter;
+      }
+      if (process3.__signal_exit_emitter__) {
+        emitter = process3.__signal_exit_emitter__;
+      } else {
+        emitter = process3.__signal_exit_emitter__ = new EE();
+        emitter.count = 0;
+        emitter.emitted = {};
+      }
+      if (!emitter.infinite) {
+        emitter.setMaxListeners(Infinity);
+        emitter.infinite = true;
+      }
+      module.exports = function(cb, opts) {
+        if (!processOk(global.process)) {
+          return function() {
+          };
+        }
+        assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
+        if (loaded === false) {
+          load();
+        }
+        var ev = "exit";
+        if (opts && opts.alwaysLast) {
+          ev = "afterexit";
+        }
+        var remove = /* @__PURE__ */ __name(function() {
+          emitter.removeListener(ev, cb);
+          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+            unload();
+          }
+        }, "remove");
+        emitter.on(ev, cb);
+        return remove;
+      };
+      unload = /* @__PURE__ */ __name(function unload2() {
+        if (!loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = false;
+        signals.forEach(function(sig) {
+          try {
+            process3.removeListener(sig, sigListeners[sig]);
+          } catch (er) {
+          }
+        });
+        process3.emit = originalProcessEmit;
+        process3.reallyExit = originalProcessReallyExit;
+        emitter.count -= 1;
+      }, "unload");
+      module.exports.unload = unload;
+      emit = /* @__PURE__ */ __name(function emit2(event, code, signal) {
+        if (emitter.emitted[event]) {
+          return;
+        }
+        emitter.emitted[event] = true;
+        emitter.emit(event, code, signal);
+      }, "emit");
+      sigListeners = {};
+      signals.forEach(function(sig) {
+        sigListeners[sig] = /* @__PURE__ */ __name(function listener() {
+          if (!processOk(global.process)) {
+            return;
+          }
+          var listeners = process3.listeners(sig);
+          if (listeners.length === emitter.count) {
+            unload();
+            emit("exit", null, sig);
+            emit("afterexit", null, sig);
+            if (isWin && sig === "SIGHUP") {
+              sig = "SIGINT";
+            }
+            process3.kill(process3.pid, sig);
+          }
+        }, "listener");
+      });
+      module.exports.signals = function() {
+        return signals;
+      };
+      loaded = false;
+      load = /* @__PURE__ */ __name(function load2() {
+        if (loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = true;
+        emitter.count += 1;
+        signals = signals.filter(function(sig) {
+          try {
+            process3.on(sig, sigListeners[sig]);
+            return true;
+          } catch (er) {
+            return false;
+          }
+        });
+        process3.emit = processEmit;
+        process3.reallyExit = processReallyExit;
+      }, "load");
+      module.exports.load = load;
+      originalProcessReallyExit = process3.reallyExit;
+      processReallyExit = /* @__PURE__ */ __name(function processReallyExit2(code) {
+        if (!processOk(global.process)) {
+          return;
+        }
+        process3.exitCode = code || /* istanbul ignore next */
+        0;
+        emit("exit", process3.exitCode, null);
+        emit("afterexit", process3.exitCode, null);
+        originalProcessReallyExit.call(process3, process3.exitCode);
+      }, "processReallyExit");
+      originalProcessEmit = process3.emit;
+      processEmit = /* @__PURE__ */ __name(function processEmit2(ev, arg) {
+        if (ev === "exit" && processOk(global.process)) {
+          if (arg !== void 0) {
+            process3.exitCode = arg;
+          }
+          var ret = originalProcessEmit.apply(this, arguments);
+          emit("exit", process3.exitCode, null);
+          emit("afterexit", process3.exitCode, null);
+          return ret;
+        } else {
+          return originalProcessEmit.apply(this, arguments);
+        }
+      }, "processEmit");
+    }
+    var assert;
+    var signals;
+    var isWin;
+    var EE;
+    var emitter;
+    var unload;
+    var emit;
+    var sigListeners;
+    var loaded;
+    var load;
+    var originalProcessReallyExit;
+    var processReallyExit;
+    var originalProcessEmit;
+    var processEmit;
+  }
+});
+
+// node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/lib/mtime-precision.js
+var require_mtime_precision = __commonJS({
+  "node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/lib/mtime-precision.js"(exports, module) {
+    "use strict";
+    var cacheSymbol = /* @__PURE__ */ Symbol();
+    function probe(file, fs, callback) {
+      const cachedPrecision = fs[cacheSymbol];
+      if (cachedPrecision) {
+        return fs.stat(file, (err, stat) => {
+          if (err) {
+            return callback(err);
+          }
+          callback(null, stat.mtime, cachedPrecision);
+        });
+      }
+      const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
+      fs.utimes(file, mtime, mtime, (err) => {
+        if (err) {
+          return callback(err);
+        }
+        fs.stat(file, (err2, stat) => {
+          if (err2) {
+            return callback(err2);
+          }
+          const precision = stat.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
+          Object.defineProperty(fs, cacheSymbol, { value: precision });
+          callback(null, stat.mtime, precision);
+        });
+      });
+    }
+    __name(probe, "probe");
+    function getMtime(precision) {
+      let now = Date.now();
+      if (precision === "s") {
+        now = Math.ceil(now / 1e3) * 1e3;
+      }
+      return new Date(now);
+    }
+    __name(getMtime, "getMtime");
+    module.exports.probe = probe;
+    module.exports.getMtime = getMtime;
+  }
+});
+
+// node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/lib/lockfile.js
+var require_lockfile = __commonJS({
+  "node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/lib/lockfile.js"(exports, module) {
+    "use strict";
+    var path = __require("path");
+    var fs = require_graceful_fs();
+    var retry = require_retry2();
+    var onExit = require_signal_exit();
+    var mtimePrecision = require_mtime_precision();
+    var locks = {};
+    function getLockFile(file, options) {
+      return options.lockfilePath || `${file}.lock`;
+    }
+    __name(getLockFile, "getLockFile");
+    function resolveCanonicalPath(file, options, callback) {
+      if (!options.realpath) {
+        return callback(null, path.resolve(file));
+      }
+      options.fs.realpath(file, callback);
+    }
+    __name(resolveCanonicalPath, "resolveCanonicalPath");
+    function acquireLock(file, options, callback) {
+      const lockfilePath = getLockFile(file, options);
+      options.fs.mkdir(lockfilePath, (err) => {
+        if (!err) {
+          return mtimePrecision.probe(lockfilePath, options.fs, (err2, mtime, mtimePrecision2) => {
+            if (err2) {
+              options.fs.rmdir(lockfilePath, () => {
+              });
+              return callback(err2);
+            }
+            callback(null, mtime, mtimePrecision2);
+          });
+        }
+        if (err.code !== "EEXIST") {
+          return callback(err);
+        }
+        if (options.stale <= 0) {
+          return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
+        }
+        options.fs.stat(lockfilePath, (err2, stat) => {
+          if (err2) {
+            if (err2.code === "ENOENT") {
+              return acquireLock(file, { ...options, stale: 0 }, callback);
+            }
+            return callback(err2);
+          }
+          if (!isLockStale(stat, options)) {
+            return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
+          }
+          removeLock(file, options, (err3) => {
+            if (err3) {
+              return callback(err3);
+            }
+            acquireLock(file, { ...options, stale: 0 }, callback);
+          });
+        });
+      });
+    }
+    __name(acquireLock, "acquireLock");
+    function isLockStale(stat, options) {
+      return stat.mtime.getTime() < Date.now() - options.stale;
+    }
+    __name(isLockStale, "isLockStale");
+    function removeLock(file, options, callback) {
+      options.fs.rmdir(getLockFile(file, options), (err) => {
+        if (err && err.code !== "ENOENT") {
+          return callback(err);
+        }
+        callback();
+      });
+    }
+    __name(removeLock, "removeLock");
+    function updateLock(file, options) {
+      const lock2 = locks[file];
+      if (lock2.updateTimeout) {
+        return;
+      }
+      lock2.updateDelay = lock2.updateDelay || options.update;
+      lock2.updateTimeout = setTimeout(() => {
+        lock2.updateTimeout = null;
+        options.fs.stat(lock2.lockfilePath, (err, stat) => {
+          const isOverThreshold = lock2.lastUpdate + options.stale < Date.now();
+          if (err) {
+            if (err.code === "ENOENT" || isOverThreshold) {
+              return setLockAsCompromised(file, lock2, Object.assign(err, { code: "ECOMPROMISED" }));
+            }
+            lock2.updateDelay = 1e3;
+            return updateLock(file, options);
+          }
+          const isMtimeOurs = lock2.mtime.getTime() === stat.mtime.getTime();
+          if (!isMtimeOurs) {
+            return setLockAsCompromised(
+              file,
+              lock2,
+              Object.assign(
+                new Error("Unable to update lock within the stale threshold"),
+                { code: "ECOMPROMISED" }
+              )
+            );
+          }
+          const mtime = mtimePrecision.getMtime(lock2.mtimePrecision);
+          options.fs.utimes(lock2.lockfilePath, mtime, mtime, (err2) => {
+            const isOverThreshold2 = lock2.lastUpdate + options.stale < Date.now();
+            if (lock2.released) {
+              return;
+            }
+            if (err2) {
+              if (err2.code === "ENOENT" || isOverThreshold2) {
+                return setLockAsCompromised(file, lock2, Object.assign(err2, { code: "ECOMPROMISED" }));
+              }
+              lock2.updateDelay = 1e3;
+              return updateLock(file, options);
+            }
+            lock2.mtime = mtime;
+            lock2.lastUpdate = Date.now();
+            lock2.updateDelay = null;
+            updateLock(file, options);
+          });
+        });
+      }, lock2.updateDelay);
+      if (lock2.updateTimeout.unref) {
+        lock2.updateTimeout.unref();
+      }
+    }
+    __name(updateLock, "updateLock");
+    function setLockAsCompromised(file, lock2, err) {
+      lock2.released = true;
+      if (lock2.updateTimeout) {
+        clearTimeout(lock2.updateTimeout);
+      }
+      if (locks[file] === lock2) {
+        delete locks[file];
+      }
+      lock2.options.onCompromised(err);
+    }
+    __name(setLockAsCompromised, "setLockAsCompromised");
+    function lock(file, options, callback) {
+      options = {
+        stale: 1e4,
+        update: null,
+        realpath: true,
+        retries: 0,
+        fs,
+        onCompromised: /* @__PURE__ */ __name((err) => {
+          throw err;
+        }, "onCompromised"),
+        ...options
+      };
+      options.retries = options.retries || 0;
+      options.retries = typeof options.retries === "number" ? { retries: options.retries } : options.retries;
+      options.stale = Math.max(options.stale || 0, 2e3);
+      options.update = options.update == null ? options.stale / 2 : options.update || 0;
+      options.update = Math.max(Math.min(options.update, options.stale / 2), 1e3);
+      resolveCanonicalPath(file, options, (err, file2) => {
+        if (err) {
+          return callback(err);
+        }
+        const operation = retry.operation(options.retries);
+        operation.attempt(() => {
+          acquireLock(file2, options, (err2, mtime, mtimePrecision2) => {
+            if (operation.retry(err2)) {
+              return;
+            }
+            if (err2) {
+              return callback(operation.mainError());
+            }
+            const lock2 = locks[file2] = {
+              lockfilePath: getLockFile(file2, options),
+              mtime,
+              mtimePrecision: mtimePrecision2,
+              options,
+              lastUpdate: Date.now()
+            };
+            updateLock(file2, options);
+            callback(null, (releasedCallback) => {
+              if (lock2.released) {
+                return releasedCallback && releasedCallback(Object.assign(new Error("Lock is already released"), { code: "ERELEASED" }));
+              }
+              unlock(file2, { ...options, realpath: false }, releasedCallback);
+            });
+          });
+        });
+      });
+    }
+    __name(lock, "lock");
+    function unlock(file, options, callback) {
+      options = {
+        fs,
+        realpath: true,
+        ...options
+      };
+      resolveCanonicalPath(file, options, (err, file2) => {
+        if (err) {
+          return callback(err);
+        }
+        const lock2 = locks[file2];
+        if (!lock2) {
+          return callback(Object.assign(new Error("Lock is not acquired/owned by you"), { code: "ENOTACQUIRED" }));
+        }
+        lock2.updateTimeout && clearTimeout(lock2.updateTimeout);
+        lock2.released = true;
+        delete locks[file2];
+        removeLock(file2, options, callback);
+      });
+    }
+    __name(unlock, "unlock");
+    function check(file, options, callback) {
+      options = {
+        stale: 1e4,
+        realpath: true,
+        fs,
+        ...options
+      };
+      options.stale = Math.max(options.stale || 0, 2e3);
+      resolveCanonicalPath(file, options, (err, file2) => {
+        if (err) {
+          return callback(err);
+        }
+        options.fs.stat(getLockFile(file2, options), (err2, stat) => {
+          if (err2) {
+            return err2.code === "ENOENT" ? callback(null, false) : callback(err2);
+          }
+          return callback(null, !isLockStale(stat, options));
+        });
+      });
+    }
+    __name(check, "check");
+    function getLocks() {
+      return locks;
+    }
+    __name(getLocks, "getLocks");
+    onExit(() => {
+      for (const file in locks) {
+        const options = locks[file].options;
+        try {
+          options.fs.rmdirSync(getLockFile(file, options));
+        } catch (e) {
+        }
+      }
+    });
+    module.exports.lock = lock;
+    module.exports.unlock = unlock;
+    module.exports.check = check;
+    module.exports.getLocks = getLocks;
+  }
+});
+
+// node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/lib/adapter.js
+var require_adapter = __commonJS({
+  "node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/lib/adapter.js"(exports, module) {
+    "use strict";
+    var fs = require_graceful_fs();
+    function createSyncFs(fs2) {
+      const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
+      const newFs = { ...fs2 };
+      methods.forEach((method) => {
+        newFs[method] = (...args) => {
+          const callback = args.pop();
+          let ret;
+          try {
+            ret = fs2[`${method}Sync`](...args);
+          } catch (err) {
+            return callback(err);
+          }
+          callback(null, ret);
+        };
+      });
+      return newFs;
+    }
+    __name(createSyncFs, "createSyncFs");
+    function toPromise(method) {
+      return (...args) => new Promise((resolve, reject) => {
+        args.push((err, result) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(result);
+          }
+        });
+        method(...args);
+      });
+    }
+    __name(toPromise, "toPromise");
+    function toSync(method) {
+      return (...args) => {
+        let err;
+        let result;
+        args.push((_err, _result) => {
+          err = _err;
+          result = _result;
+        });
+        method(...args);
+        if (err) {
+          throw err;
+        }
+        return result;
+      };
+    }
+    __name(toSync, "toSync");
+    function toSyncOptions(options) {
+      options = { ...options };
+      options.fs = createSyncFs(options.fs || fs);
+      if (typeof options.retries === "number" && options.retries > 0 || options.retries && typeof options.retries.retries === "number" && options.retries.retries > 0) {
+        throw Object.assign(new Error("Cannot use retries with the sync api"), { code: "ESYNC" });
+      }
+      return options;
+    }
+    __name(toSyncOptions, "toSyncOptions");
+    module.exports = {
+      toPromise,
+      toSync,
+      toSyncOptions
+    };
+  }
+});
+
+// node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/index.js
+var require_proper_lockfile = __commonJS({
+  "node_modules/@earendil-works/pi-coding-agent/node_modules/proper-lockfile/index.js"(exports, module) {
+    "use strict";
+    var lockfile2 = require_lockfile();
+    var { toPromise, toSync, toSyncOptions } = require_adapter();
+    async function lock(file, options) {
+      const release = await toPromise(lockfile2.lock)(file, options);
+      return toPromise(release);
+    }
+    __name(lock, "lock");
+    function lockSync(file, options) {
+      const release = toSync(lockfile2.lock)(file, toSyncOptions(options));
+      return toSync(release);
+    }
+    __name(lockSync, "lockSync");
+    function unlock(file, options) {
+      return toPromise(lockfile2.unlock)(file, options);
+    }
+    __name(unlock, "unlock");
+    function unlockSync(file, options) {
+      return toSync(lockfile2.unlock)(file, toSyncOptions(options));
+    }
+    __name(unlockSync, "unlockSync");
+    function check(file, options) {
+      return toPromise(lockfile2.check)(file, options);
+    }
+    __name(check, "check");
+    function checkSync(file, options) {
+      return toSync(lockfile2.check)(file, toSyncOptions(options));
+    }
+    __name(checkSync, "checkSync");
+    module.exports = lock;
+    module.exports.lock = lock;
+    module.exports.unlock = unlock;
+    module.exports.lockSync = lockSync;
+    module.exports.unlockSync = unlockSync;
+    module.exports.check = check;
+    module.exports.checkSync = checkSync;
+  }
+});
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/resolve-config-value.js
+import { execSync, spawnSync } from "child_process";
+var commandResultCache = /* @__PURE__ */ new Map();
+var ENV_VAR_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var ENV_VAR_NAME_PREFIX_RE = /^[A-Za-z_][A-Za-z0-9_]*/;
+function appendLiteral(parts, value) {
+  if (!value)
+    return;
+  const previousPart = parts[parts.length - 1];
+  if (previousPart?.type === "literal") {
+    previousPart.value += value;
+    return;
+  }
+  parts.push({ type: "literal", value });
+}
+__name(appendLiteral, "appendLiteral");
+function parseConfigValueTemplate(config) {
+  const parts = [];
+  let index = 0;
+  while (index < config.length) {
+    const dollarIndex = config.indexOf("$", index);
+    if (dollarIndex < 0) {
+      appendLiteral(parts, config.slice(index));
+      break;
+    }
+    appendLiteral(parts, config.slice(index, dollarIndex));
+    const nextChar = config[dollarIndex + 1];
+    if (nextChar === "$" || nextChar === "!") {
+      appendLiteral(parts, nextChar);
+      index = dollarIndex + 2;
+      continue;
+    }
+    if (nextChar === "{") {
+      const endIndex = config.indexOf("}", dollarIndex + 2);
+      if (endIndex < 0) {
+        appendLiteral(parts, "$");
+        index = dollarIndex + 1;
+        continue;
+      }
+      const name = config.slice(dollarIndex + 2, endIndex);
+      if (ENV_VAR_NAME_RE.test(name)) {
+        parts.push({ type: "env", name });
+      } else {
+        appendLiteral(parts, config.slice(dollarIndex, endIndex + 1));
+      }
+      index = endIndex + 1;
+      continue;
+    }
+    const match = config.slice(dollarIndex + 1).match(ENV_VAR_NAME_PREFIX_RE);
+    if (match) {
+      parts.push({ type: "env", name: match[0] });
+      index = dollarIndex + 1 + match[0].length;
+      continue;
+    }
+    appendLiteral(parts, "$");
+    index = dollarIndex + 1;
+  }
+  return parts;
+}
+__name(parseConfigValueTemplate, "parseConfigValueTemplate");
+function parseConfigValueReference(config) {
+  if (config.startsWith("!")) {
+    return { type: "command", config };
+  }
+  return { type: "template", parts: parseConfigValueTemplate(config) };
+}
+__name(parseConfigValueReference, "parseConfigValueReference");
+function resolveEnvConfigValue(name, env) {
+  return env?.[name] || process.env[name] || void 0;
+}
+__name(resolveEnvConfigValue, "resolveEnvConfigValue");
+function getTemplateEnvVarNames(parts) {
+  const names = [];
+  for (const part of parts) {
+    if (part.type !== "env" || names.includes(part.name))
+      continue;
+    names.push(part.name);
+  }
+  return names;
+}
+__name(getTemplateEnvVarNames, "getTemplateEnvVarNames");
+function resolveTemplate(parts, env) {
+  let resolved = "";
+  for (const part of parts) {
+    if (part.type === "literal") {
+      resolved += part.value;
+      continue;
+    }
+    const envValue = resolveEnvConfigValue(part.name, env);
+    if (envValue === void 0)
+      return void 0;
+    resolved += envValue;
+  }
+  return resolved;
+}
+__name(resolveTemplate, "resolveTemplate");
+function getConfigValueEnvVarNames(config) {
+  const reference = parseConfigValueReference(config);
+  return reference.type === "template" ? getTemplateEnvVarNames(reference.parts) : [];
+}
+__name(getConfigValueEnvVarNames, "getConfigValueEnvVarNames");
+function getMissingConfigValueEnvVarNames(config, env) {
+  return getConfigValueEnvVarNames(config).filter((name) => resolveEnvConfigValue(name, env) === void 0);
+}
+__name(getMissingConfigValueEnvVarNames, "getMissingConfigValueEnvVarNames");
+function isCommandConfigValue(config) {
+  return parseConfigValueReference(config).type === "command";
+}
+__name(isCommandConfigValue, "isCommandConfigValue");
+function isConfigValueConfigured(config, env) {
+  return getMissingConfigValueEnvVarNames(config, env).length === 0;
+}
+__name(isConfigValueConfigured, "isConfigValueConfigured");
+function resolveConfigValue(config, env) {
+  const reference = parseConfigValueReference(config);
+  if (reference.type === "command") {
+    return executeCommand(reference.config);
+  }
+  return resolveTemplate(reference.parts, env);
+}
+__name(resolveConfigValue, "resolveConfigValue");
+function executeWithConfiguredShell(command) {
+  try {
+    const { shell, args, commandTransport } = getShellConfig();
+    const commandFromStdin = commandTransport === "stdin";
+    const result = spawnSync(shell, commandFromStdin ? args : [...args, command], {
+      encoding: "utf-8",
+      input: commandFromStdin ? command : void 0,
+      timeout: 1e4,
+      stdio: [commandFromStdin ? "pipe" : "ignore", "pipe", "ignore"],
+      shell: false,
+      windowsHide: true
+    });
+    if (result.error) {
+      const error = result.error;
+      if (error.code === "ENOENT") {
+        return { executed: false, value: void 0 };
+      }
+      return { executed: true, value: void 0 };
+    }
+    if (result.status !== 0) {
+      return { executed: true, value: void 0 };
+    }
+    const value = (result.stdout ?? "").trim();
+    return { executed: true, value: value || void 0 };
+  } catch {
+    return { executed: false, value: void 0 };
+  }
+}
+__name(executeWithConfiguredShell, "executeWithConfiguredShell");
+function executeWithDefaultShell(command) {
+  try {
+    const output = execSync(command, {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return output.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(executeWithDefaultShell, "executeWithDefaultShell");
+function executeCommandUncached(commandConfig) {
+  const command = commandConfig.slice(1);
+  return process.platform === "win32" ? (() => {
+    const configuredResult = executeWithConfiguredShell(command);
+    return configuredResult.executed ? configuredResult.value : executeWithDefaultShell(command);
+  })() : executeWithDefaultShell(command);
+}
+__name(executeCommandUncached, "executeCommandUncached");
+function executeCommand(commandConfig) {
+  if (commandResultCache.has(commandConfig)) {
+    return commandResultCache.get(commandConfig);
+  }
+  const result = executeCommandUncached(commandConfig);
+  commandResultCache.set(commandConfig, result);
+  return result;
+}
+__name(executeCommand, "executeCommand");
+function resolveConfigValueUncached(config, env) {
+  const reference = parseConfigValueReference(config);
+  if (reference.type === "command") {
+    return executeCommandUncached(reference.config);
+  }
+  return resolveTemplate(reference.parts, env);
+}
+__name(resolveConfigValueUncached, "resolveConfigValueUncached");
+function resolveConfigValueOrThrow(config, description, env) {
+  const resolvedValue = resolveConfigValueUncached(config, env);
+  if (resolvedValue !== void 0) {
+    return resolvedValue;
+  }
+  const reference = parseConfigValueReference(config);
+  if (reference.type === "command") {
+    throw new Error(`Failed to resolve ${description} from shell command: ${reference.config.slice(1)}`);
+  }
+  if (reference.type === "template") {
+    const missingEnvVars = getMissingConfigValueEnvVarNames(config, env);
+    if (missingEnvVars.length === 1) {
+      throw new Error(`Failed to resolve ${description} from environment variable: ${missingEnvVars[0]}`);
+    }
+    if (missingEnvVars.length > 1) {
+      throw new Error(`Failed to resolve ${description} from environment variables: ${missingEnvVars.join(", ")}`);
+    }
+  }
+  throw new Error(`Failed to resolve ${description}`);
+}
+__name(resolveConfigValueOrThrow, "resolveConfigValueOrThrow");
+function resolveHeadersOrThrow(headers, description, env) {
+  if (!headers)
+    return void 0;
+  const resolved = {};
+  for (const [key, value] of Object.entries(headers)) {
+    resolved[key] = resolveConfigValueOrThrow(value, `${description} header "${key}"`, env);
+  }
+  return Object.keys(resolved).length > 0 ? resolved : void 0;
+}
+__name(resolveHeadersOrThrow, "resolveHeadersOrThrow");
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/auth-storage.js
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { setTimeout as sleep } from "timers/promises";
+
+// node_modules/@earendil-works/pi-coding-agent/dist/utils/abort.js
+function abortReason(signal) {
+  if (signal.reason !== void 0)
+    return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+__name(abortReason, "abortReason");
+function operationSignal(signal) {
+  return signal ?? new AbortController().signal;
+}
+__name(operationSignal, "operationSignal");
+function raceWithAbortSignal(operation, signal) {
+  if (!signal)
+    return operation;
+  if (signal.aborted) {
+    void operation.catch(() => {
+    });
+    return Promise.reject(abortReason(signal));
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = /* @__PURE__ */ __name(() => signal.removeEventListener("abort", onAbort), "cleanup");
+    const onAbort = /* @__PURE__ */ __name(() => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(abortReason(signal));
+    }, "onAbort");
+    signal.addEventListener("abort", onAbort, { once: true });
+    void operation.then((value) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve(value);
+    }, (error) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(error);
+    });
+    if (signal.aborted)
+      onAbort();
+  });
+}
+__name(raceWithAbortSignal, "raceWithAbortSignal");
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/auth-storage.js
+var MAX_EPERM_RETRIES = 5;
+function getRetryableLockErrorCode(error) {
+  const code = error instanceof Error && "code" in error ? error.code : void 0;
+  if (code === "ELOCKED")
+    return code;
+  if (code === "EPERM" && process.platform === "win32")
+    return code;
+  return void 0;
+}
+__name(getRetryableLockErrorCode, "getRetryableLockErrorCode");
+var AUTH_FILE_WRITE_OPTIONS = { encoding: "utf-8", mode: 384 };
+var sharedAuthFileReadState;
+var FileAuthStorageBackend = class {
+  static {
+    __name(this, "FileAuthStorageBackend");
+  }
+  authPath;
+  constructor(authPath = join(getAgentDir(), "auth.json")) {
+    this.authPath = normalizePath(authPath);
+  }
+  ensureParentDir() {
+    const dir = dirname(this.authPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+  }
+  ensureFileExists() {
+    if (!existsSync(this.authPath)) {
+      writeFileSync(this.authPath, "{}", AUTH_FILE_WRITE_OPTIONS);
+    }
+  }
+  acquireLockSyncWithRetry(path) {
+    const maxAttempts = 10;
+    const delayMs = 20;
+    for (let attempt = 1; ; attempt++) {
+      try {
+        return import_proper_lockfile.default.lockSync(path, { realpath: false });
+      } catch (error) {
+        if (!getRetryableLockErrorCode(error) || attempt === maxAttempts)
+          throw error;
+        const start = Date.now();
+        while (Date.now() - start < delayMs) {
+        }
+      }
+    }
+  }
+  withLock(fn) {
+    this.ensureParentDir();
+    this.ensureFileExists();
+    let release;
+    try {
+      release = this.acquireLockSyncWithRetry(this.authPath);
+      const current = existsSync(this.authPath) ? readFileSync(this.authPath, "utf-8") : void 0;
+      const { result, next } = fn(current);
+      if (next !== void 0) {
+        writeFileSync(this.authPath, next, AUTH_FILE_WRITE_OPTIONS);
+      }
+      return result;
+    } finally {
+      if (release) {
+        release();
+      }
+    }
+  }
+  async acquireLockAsync(signal, onCompromised) {
+    const staleMs = 3e4;
+    const maxDelayMs = 2e3;
+    const deadline = Date.now() + staleMs;
+    let retry = 0;
+    let epermRetries = 0;
+    while (true) {
+      signal?.throwIfAborted();
+      let release;
+      try {
+        release = await import_proper_lockfile.default.lock(this.authPath, {
+          realpath: false,
+          retries: 0,
+          stale: staleMs,
+          onCompromised
+        });
+      } catch (error) {
+        signal?.throwIfAborted();
+        const code = getRetryableLockErrorCode(error);
+        const remainingMs = deadline - Date.now();
+        if (!code || remainingMs <= 0)
+          throw error;
+        if (code === "EPERM" && ++epermRetries > MAX_EPERM_RETRIES)
+          throw error;
+        const baseDelayMs = Math.min(10 * 2 ** retry, maxDelayMs / 2);
+        retry++;
+        const delayMs = Math.min(Math.round(baseDelayMs * (1 + Math.random())), remainingMs);
+        if (signal)
+          await sleep(delayMs, void 0, { signal });
+        else
+          await sleep(delayMs);
+        continue;
+      }
+      if (signal?.aborted) {
+        await release();
+        signal.throwIfAborted();
+      }
+      return release;
+    }
+  }
+  async withLockAsync(fn, options) {
+    options?.signal?.throwIfAborted();
+    this.ensureParentDir();
+    this.ensureFileExists();
+    let release;
+    let lockCompromised = false;
+    let lockCompromisedError;
+    const throwIfCompromised = /* @__PURE__ */ __name(() => {
+      if (lockCompromised) {
+        throw lockCompromisedError ?? new Error("Auth storage lock was compromised");
+      }
+    }, "throwIfCompromised");
+    try {
+      release = await this.acquireLockAsync(options?.signal, (error) => {
+        lockCompromised = true;
+        lockCompromisedError = error;
+      });
+      throwIfCompromised();
+      options?.signal?.throwIfAborted();
+      const current = existsSync(this.authPath) ? readFileSync(this.authPath, "utf-8") : void 0;
+      const { result, next } = await fn(current);
+      throwIfCompromised();
+      options?.signal?.throwIfAborted();
+      if (next !== void 0) {
+        writeFileSync(this.authPath, next, AUTH_FILE_WRITE_OPTIONS);
+      }
+      throwIfCompromised();
+      return result;
+    } finally {
+      if (release) {
+        try {
+          await release();
+        } catch {
+        }
+      }
+    }
+  }
+};
+var ReadOnlyAuthStorage = class {
+  static {
+    __name(this, "ReadOnlyAuthStorage");
+  }
+  authPath;
+  data;
+  constructor(authPath = join(getAgentDir(), "auth.json")) {
+    this.authPath = normalizePath(authPath);
+  }
+  load() {
+    if (this.data)
+      return this.data;
+    let parsed;
+    try {
+      parsed = JSON.parse(stripBom(readFileSync(this.authPath, "utf-8")));
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        this.data = {};
+        return this.data;
+      }
+      throw new Error(`Failed to read auth.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("Invalid auth.json: expected an object");
+    }
+    for (const [providerId, credential] of Object.entries(parsed)) {
+      if (typeof credential !== "object" || credential === null || Array.isArray(credential)) {
+        throw new Error(`Invalid auth.json credential for provider "${providerId}"`);
+      }
+      const value = credential;
+      if (value.type === "api_key") {
+        const validKey = value.key === void 0 || typeof value.key === "string";
+        const validEnv = value.env === void 0 || typeof value.env === "object" && value.env !== null && !Array.isArray(value.env) && Object.values(value.env).every((entry) => typeof entry === "string");
+        if (validKey && validEnv)
+          continue;
+      } else if (value.type === "oauth" && typeof value.access === "string" && typeof value.refresh === "string" && typeof value.expires === "number" && Number.isFinite(value.expires)) {
+        continue;
+      }
+      throw new Error(`Invalid auth.json credential for provider "${providerId}"`);
+    }
+    this.data = parsed;
+    return this.data;
+  }
+  async read(providerId, options) {
+    options?.signal?.throwIfAborted();
+    const credential = this.load()[providerId];
+    options?.signal?.throwIfAborted();
+    if (!credential)
+      return void 0;
+    if (credential.type !== "api_key" || !credential.key || isCommandConfigValue(credential.key)) {
+      return structuredClone(credential);
+    }
+    return { ...credential, key: resolveConfigValue(credential.key, credential.env) };
+  }
+  async list(options) {
+    options?.signal?.throwIfAborted();
+    const credentials = Object.entries(this.load()).map(([providerId, credential]) => ({
+      providerId,
+      type: credential.type
+    }));
+    options?.signal?.throwIfAborted();
+    return credentials;
+  }
+  async modify(_providerId, _fn, _options) {
+    throw new Error("Read-only credential storage cannot modify auth.json");
+  }
+  async delete(_providerId, _options) {
+    throw new Error("Read-only credential storage cannot modify auth.json");
+  }
+};
+var InMemoryAuthStorageBackend = class {
+  static {
+    __name(this, "InMemoryAuthStorageBackend");
+  }
+  value;
+  asyncChain = Promise.resolve();
+  withLock(fn) {
+    const { result, next } = fn(this.value);
+    if (next !== void 0) {
+      this.value = next;
+    }
+    return result;
+  }
+  withLockAsync(fn, options) {
+    const previous = this.asyncChain;
+    const operation = (async () => {
+      await previous.catch(() => {
+      });
+      options?.signal?.throwIfAborted();
+      const { result, next } = await fn(this.value);
+      options?.signal?.throwIfAborted();
+      if (next !== void 0) {
+        this.value = next;
+      }
+      return result;
+    })();
+    this.asyncChain = operation.catch(() => {
+    });
+    return raceWithAbortSignal(operation, options?.signal);
+  }
+};
+var AuthStorage = class _AuthStorage {
+  static {
+    __name(this, "AuthStorage");
+  }
+  storage;
+  authPath;
+  readState;
+  constructor(storage, authPath) {
+    this.storage = storage;
+    this.authPath = authPath;
+    this.readState = authPath && sharedAuthFileReadState?.authPath === authPath ? sharedAuthFileReadState.readState : { data: {} };
+    if (authPath && !sharedAuthFileReadState) {
+      sharedAuthFileReadState = { authPath, readState: this.readState };
+    }
+    if (authPath) {
+      const revision = getFileRevision(authPath);
+      if (revision !== void 0 && revision === this.readState.revision)
+        return;
+    }
+    this.reload();
+  }
+  static create(authPath = join(getAgentDir(), "auth.json")) {
+    const normalizedAuthPath = normalizePath(authPath);
+    return new _AuthStorage(new FileAuthStorageBackend(normalizedAuthPath), normalizedAuthPath);
+  }
+  static fromStorage(storage) {
+    return new _AuthStorage(storage);
+  }
+  static inMemory(data = {}) {
+    const storage = new InMemoryAuthStorageBackend();
+    storage.withLock(() => ({ result: void 0, next: JSON.stringify(data, null, 2) }));
+    return _AuthStorage.fromStorage(storage);
+  }
+  parseStorageData(content) {
+    if (!content) {
+      return {};
+    }
+    return JSON.parse(stripBom(content));
+  }
+  updateReadState(data, revision) {
+    this.readState.data = data;
+    this.readState.revision = revision;
+  }
+  /**
+   * Reload credentials from storage.
+   */
+  reload() {
+    let content;
+    let revision;
+    try {
+      this.storage.withLock((current) => {
+        content = current;
+        revision = this.authPath ? getFileRevision(this.authPath) : void 0;
+        return { result: void 0 };
+      });
+      this.updateReadState(this.parseStorageData(content), revision);
+    } catch {
+    }
+  }
+  async reloadFromStorageAsync(options) {
+    return this.storage.withLockAsync(async (content) => {
+      const currentData = this.parseStorageData(content);
+      const revision = this.authPath ? getFileRevision(this.authPath) : void 0;
+      this.updateReadState(currentData, revision);
+      return { result: currentData };
+    }, options);
+  }
+  async readLatestData(options) {
+    options?.signal?.throwIfAborted();
+    if (!this.authPath) {
+      const reload2 = this.reloadFromStorageAsync(options);
+      return options?.signal ? reload2 : reload2.catch(() => this.readState.data);
+    }
+    const revision = getFileRevision(this.authPath);
+    if (revision !== void 0 && revision === this.readState.revision)
+      return this.readState.data;
+    if (!this.readState.reload) {
+      const controller = new AbortController();
+      const reload2 = {
+        controller,
+        promise: this.reloadFromStorageAsync({ signal: controller.signal }),
+        readers: 0
+      };
+      this.readState.reload = reload2;
+      void reload2.promise.then(() => {
+        if (this.readState.reload === reload2)
+          this.readState.reload = void 0;
+      }, () => {
+        if (this.readState.reload === reload2)
+          this.readState.reload = void 0;
+      });
+    }
+    const reload = this.readState.reload;
+    reload.readers++;
+    try {
+      const result = raceWithAbortSignal(reload.promise, options?.signal);
+      return options?.signal ? await result : await result.catch(() => this.readState.data);
+    } finally {
+      reload.readers--;
+      if (reload.readers === 0 && this.readState.reload === reload) {
+        this.readState.reload = void 0;
+        reload.controller.abort();
+      }
+    }
+  }
+  async read(provider, options) {
+    const credential = (await this.readLatestData(options))[provider];
+    options?.signal?.throwIfAborted();
+    if (credential?.type !== "api_key")
+      return credential;
+    if (credential.key === void 0)
+      return credential;
+    return { ...credential, key: resolveConfigValue(credential.key, credential.env) };
+  }
+  async modify(provider, fn, options) {
+    let latestData = this.readState.data;
+    let revision;
+    const result = await this.storage.withLockAsync(async (content) => {
+      const currentData = this.parseStorageData(content);
+      const next = await fn(currentData[provider]);
+      if (next === void 0) {
+        latestData = currentData;
+        revision = this.authPath ? getFileRevision(this.authPath) : void 0;
+        return { result: currentData[provider] };
+      }
+      const merged = { ...currentData, [provider]: next };
+      latestData = merged;
+      return { result: next, next: JSON.stringify(merged, null, 2) };
+    }, options);
+    this.updateReadState(latestData, revision);
+    return result;
+  }
+  async delete(provider, options) {
+    let latestData = this.readState.data;
+    await this.storage.withLockAsync(async (content) => {
+      const currentData = this.parseStorageData(content);
+      delete currentData[provider];
+      latestData = currentData;
+      return { result: void 0, next: JSON.stringify(currentData, null, 2) };
+    }, options);
+    this.updateReadState(latestData);
+  }
+  /** List credential metadata without resolving configured key values. */
+  async list(options) {
+    const entries = Object.entries(await this.readLatestData(options));
+    options?.signal?.throwIfAborted();
+    return entries.map(([providerId, credential]) => ({ providerId, type: credential.type }));
+  }
+};
+function readStoredCredential(providerId, authPath = join(getAgentDir(), "auth.json")) {
+  try {
+    const data = JSON.parse(stripBom(readFileSync(normalizePath(authPath), "utf-8")));
+    return data[providerId];
+  } catch {
+    return void 0;
+  }
+}
+__name(readStoredCredential, "readStoredCredential");
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/mcp-servers.js
+function toolPatternRegExp(pattern) {
+  const source = pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${source}$`);
+}
+__name(toolPatternRegExp, "toolPatternRegExp");
+function createToolNameMatcher(entries) {
+  const names = new Set(entries.filter((entry) => !entry.includes("*")));
+  const patterns = entries.filter((entry) => entry.includes("*")).map(toolPatternRegExp);
+  return (name) => names.has(name) || patterns.some((pattern) => pattern.test(name));
+}
+__name(createToolNameMatcher, "createToolNameMatcher");
+var LIST_MCP_RESOURCES_TOOL = "list_mcp_resources";
+var LIST_MCP_RESOURCE_TEMPLATES_TOOL = "list_mcp_resource_templates";
+var READ_MCP_RESOURCE_TOOL = "read_mcp_resource";
+var MCP_RESOURCE_TOOLS = /* @__PURE__ */ new Set([
+  LIST_MCP_RESOURCES_TOOL,
+  LIST_MCP_RESOURCE_TEMPLATES_TOOL,
+  READ_MCP_RESOURCE_TOOL
+]);
+function isMcpToolName(name) {
+  return name.startsWith("mcp__") || MCP_RESOURCE_TOOLS.has(name);
+}
+__name(isMcpToolName, "isMcpToolName");
+var MCP_EXPOSURES = ["codemode", "deferred", "direct", "hidden"];
+var MCP_EXPOSURE_ALIASES = { "codemode-deferred": "codemode" };
+var LOOPBACK_HOSTS = ["localhost", "127.0.0.1", "[::1]"];
+function isLoopbackRedirectUri(value) {
+  if (!URL.canParse(value))
+    return false;
+  const url = new URL(value);
+  return url.protocol === "http:" && LOOPBACK_HOSTS.includes(url.hostname) && url.search === "" && url.hash === "";
+}
+__name(isLoopbackRedirectUri, "isLoopbackRedirectUri");
+var SERVER_NAME = /^[A-Za-z0-9_-]+$/;
+function mcpNamespace(server) {
+  return `mcp__${server.replace(/-/g, "_")}`;
+}
+__name(mcpNamespace, "mcpNamespace");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+__name(isStringRecord, "isStringRecord");
+function validateOAuth(value) {
+  if (value === void 0)
+    return void 0;
+  if (!isRecord(value))
+    return "oauth must be an object";
+  if (value.clientId !== void 0 && typeof value.clientId !== "string")
+    return "oauth.clientId must be a string";
+  if (value.clientSecret !== void 0 && typeof value.clientSecret !== "string") {
+    return "oauth.clientSecret must be a string";
+  }
+  const port = value.callbackPort;
+  if (port !== void 0 && (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535)) {
+    return "oauth.callbackPort must be a port number";
+  }
+  if (value.callbackUrl !== void 0) {
+    if (typeof value.callbackUrl !== "string" || !isLoopbackRedirectUri(value.callbackUrl)) {
+      return "oauth.callbackUrl must be an http URI on localhost, 127.0.0.1, or [::1] without query or fragment";
+    }
+    const urlPort = new URL(value.callbackUrl).port;
+    if (urlPort && port !== void 0 && Number(urlPort) !== port) {
+      return "oauth.callbackUrl and oauth.callbackPort name different ports";
+    }
+  }
+  if (value.scope !== void 0 && typeof value.scope !== "string")
+    return "oauth.scope must be a string";
+  if (value.clientName !== void 0 && (typeof value.clientName !== "string" || !value.clientName.trim())) {
+    return "oauth.clientName must be a non-empty string";
+  }
+  if (value.clientRegistration !== void 0 && value.clientRegistration !== "dcr") {
+    if (value.clientRegistration !== "cimd")
+      return 'oauth.clientRegistration must be "dcr" or "cimd"';
+    if (value.clientId !== void 0 || value.clientName !== void 0) {
+      return 'oauth.clientRegistration "cimd" cannot be combined with oauth.clientId or oauth.clientName';
+    }
+    const callback = typeof value.callbackUrl === "string" ? new URL(value.callbackUrl) : void 0;
+    if (callback && (callback.hostname === "[::1]" || callback.pathname !== "/callback")) {
+      return 'oauth.clientRegistration "cimd" requires oauth.callbackUrl on localhost or 127.0.0.1 with path /callback';
+    }
+  }
+  const metadataUrl = value.authServerMetadataUrl;
+  if (metadataUrl !== void 0) {
+    const url = typeof metadataUrl === "string" && URL.canParse(metadataUrl) ? new URL(metadataUrl) : void 0;
+    if (!url || !(url.protocol === "https:" || url.protocol === "http:" && LOOPBACK_HOSTS.includes(url.hostname))) {
+      return "oauth.authServerMetadataUrl must be an https URL, or http on localhost, 127.0.0.1, or [::1]";
+    }
+  }
+  return void 0;
+}
+__name(validateOAuth, "validateOAuth");
+function isExposure(value) {
+  return typeof value === "string" && MCP_EXPOSURES.includes(value);
+}
+__name(isExposure, "isExposure");
+function resolveExposureAlias(value) {
+  return typeof value === "string" ? MCP_EXPOSURE_ALIASES[value] ?? value : value;
+}
+__name(resolveExposureAlias, "resolveExposureAlias");
+function resolveExposureAliases(value) {
+  const { exposure, toolExposure } = value;
+  const resolved = { ...value };
+  if (exposure !== void 0)
+    resolved.exposure = resolveExposureAlias(exposure);
+  if (isRecord(toolExposure)) {
+    resolved.toolExposure = Object.fromEntries(Object.entries(toolExposure).map(([tool, entry]) => [tool, resolveExposureAlias(entry)]));
+  }
+  return resolved;
+}
+__name(resolveExposureAliases, "resolveExposureAliases");
+function getMcpToolExposure(config, toolName) {
+  const overrides = config.toolExposure ?? {};
+  const exact = overrides[toolName];
+  if (exact !== void 0)
+    return exact;
+  for (const [pattern, exposure] of Object.entries(overrides)) {
+    if (pattern.includes("*") && toolPatternRegExp(pattern).test(toolName))
+      return exposure;
+  }
+  return config.exposure ?? "codemode";
+}
+__name(getMcpToolExposure, "getMcpToolExposure");
+function validateMcpServerConfig(name, raw) {
+  if (!SERVER_NAME.test(name))
+    return `invalid server name "${name}" (use letters, digits, "_" and "-")`;
+  if (!isRecord(raw))
+    return `server "${name}" must be an object`;
+  const value = resolveExposureAliases(raw);
+  const { type, exposure, enabled, timeout, toolExposure, description } = value;
+  const exposures = MCP_EXPOSURES.map((value2) => `"${value2}"`).join(", ");
+  if (exposure !== void 0 && !isExposure(exposure)) {
+    return `server "${name}": exposure must be one of ${exposures}`;
+  }
+  if (toolExposure !== void 0) {
+    if (!isRecord(toolExposure))
+      return `server "${name}": toolExposure must map tool names to exposures`;
+    for (const [tool, value2] of Object.entries(toolExposure)) {
+      if (!isExposure(value2))
+        return `server "${name}": toolExposure "${tool}" must be one of ${exposures}`;
+    }
+  }
+  if (enabled !== void 0 && typeof enabled !== "boolean")
+    return `server "${name}": enabled must be a boolean`;
+  if (description !== void 0 && typeof description !== "string") {
+    return `server "${name}": description must be a string`;
+  }
+  if (timeout !== void 0 && (typeof timeout !== "number" || !(timeout > 0))) {
+    return `server "${name}": timeout must be a positive number of seconds`;
+  }
+  if (type === "sse")
+    return `server "${name}": legacy SSE transport is not supported; use the streamable HTTP URL`;
+  if (typeof value.url === "string" && (type === void 0 || type === "http" || type === "streamable-http")) {
+    if (!URL.canParse(value.url) || !/^https?:$/.test(new URL(value.url).protocol)) {
+      return `server "${name}": url must be an http or https URL`;
+    }
+    if (value.headers !== void 0 && !isStringRecord(value.headers)) {
+      return `server "${name}": headers must map names to strings`;
+    }
+    const oauthError = validateOAuth(value.oauth);
+    if (oauthError)
+      return `server "${name}": ${oauthError}`;
+    if (value.auth !== void 0) {
+      if (!isRecord(value.auth) || typeof value.auth.provider !== "string" || !value.auth.provider) {
+        return `server "${name}": auth.provider must be a provider name`;
+      }
+      const url = new URL(value.url);
+      if (url.protocol !== "https:" && !LOOPBACK_HOSTS.includes(url.hostname)) {
+        return `server "${name}": auth requires an https URL, or http on localhost, 127.0.0.1, or [::1]`;
+      }
+    }
+    return value;
+  }
+  if (typeof value.command === "string" && (type === void 0 || type === "stdio")) {
+    if (value.args !== void 0 && !(Array.isArray(value.args) && value.args.every((arg) => typeof arg === "string"))) {
+      return `server "${name}": args must be an array of strings`;
+    }
+    if (value.env !== void 0 && !isStringRecord(value.env))
+      return `server "${name}": env must map names to strings`;
+    if (value.cwd !== void 0 && typeof value.cwd !== "string")
+      return `server "${name}": cwd must be a string`;
+    return value;
+  }
+  return `server "${name}" needs either "command" (stdio) or "url" (streamable HTTP)`;
+}
+__name(validateMcpServerConfig, "validateMcpServerConfig");
+var McpServerRegistry = class {
+  static {
+    __name(this, "McpServerRegistry");
+  }
+  servers = /* @__PURE__ */ new Map();
+  changeListener;
+  /** Register or replace a server. The caller checks ownership. */
+  register(server) {
+    this.servers.set(server.name, server);
+    this.changeListener?.();
+  }
+  /** Remove a server registered by `extensionPath`. Servers of other extensions are left alone. */
+  unregister(name, extensionPath) {
+    if (this.servers.get(name)?.extensionPath !== extensionPath)
+      return;
+    this.servers.delete(name);
+    this.changeListener?.();
+  }
+  get(name) {
+    return this.servers.get(name);
+  }
+  /** Copies of the registered servers, in registration order. */
+  list() {
+    return [...this.servers.values()].map((server) => ({ ...server, config: structuredClone(server.config) }));
+  }
+  /** Called after every change. The runner sets it when it binds, to emit `mcp_servers_change`. */
+  setChangeListener(listener) {
+    this.changeListener = listener;
+  }
+};
+
+// 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 {
+  static {
+    __name(this, "McpError");
+  }
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "McpError";
+    this.code = code;
+    this.data = data;
+  }
+};
+var McpConnectionClosedError = class extends Error {
+  static {
+    __name(this, "McpConnectionClosedError");
+  }
+  constructor(message = "MCP connection closed") {
+    super(message);
+    this.name = "McpConnectionClosedError";
+  }
+};
+var McpTimeoutError = class extends Error {
+  static {
+    __name(this, "McpTimeoutError");
+  }
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`MCP request timed out after ${timeoutMs}ms`);
+    this.name = "McpTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var McpAbortError = class extends Error {
+  static {
+    __name(this, "McpAbortError");
+  }
+  constructor(message = "MCP request aborted") {
+    super(message);
+    this.name = "AbortError";
+  }
+};
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isObject, "isObject");
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+__name(toError, "toError");
+function isJsonRpcId(value) {
+  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+__name(isJsonRpcId, "isJsonRpcId");
+function isJsonRpcRequest(message) {
+  return isObject(message) && message.jsonrpc === "2.0" && isJsonRpcId(message.id) && typeof message.method === "string";
+}
+__name(isJsonRpcRequest, "isJsonRpcRequest");
+function isJsonRpcNotification(message) {
+  return isObject(message) && message.jsonrpc === "2.0" && !("id" in message) && typeof message.method === "string";
+}
+__name(isJsonRpcNotification, "isJsonRpcNotification");
+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";
+}
+__name(isJsonRpcResponse, "isJsonRpcResponse");
+function parseJsonRpcMessage(value) {
+  if (isJsonRpcRequest(value) || isJsonRpcNotification(value) || isJsonRpcResponse(value))
+    return value;
+  throw new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid JSON-RPC message");
+}
+__name(parseJsonRpcMessage, "parseJsonRpcMessage");
+
+// 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;
+}
+__name(validateInitializeResult, "validateInitializeResult");
+function invalid(message) {
+  return new McpError(JSON_RPC_ERROR_CODES.invalidRequest, message);
+}
+__name(invalid, "invalid");
+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 } };
+}
+__name(validateListPage, "validateListPage");
+var isTool = /* @__PURE__ */ __name((tool) => typeof tool.name === "string" && isObject(tool.inputSchema), "isTool");
+var isResource = /* @__PURE__ */ __name((resource) => typeof resource.uri === "string" && (resource.name === void 0 || typeof resource.name === "string"), "isResource");
+var isResourceTemplate = /* @__PURE__ */ __name((template) => typeof template.uriTemplate === "string" && (template.name === void 0 || typeof template.name === "string"), "isResourceTemplate");
+function toResource(item) {
+  return { ...item, name: item.name ?? item.uri };
+}
+__name(toResource, "toResource");
+function toResourceTemplate(item) {
+  return { ...item, name: item.name ?? item.uriTemplate };
+}
+__name(toResourceTemplate, "toResourceTemplate");
+function pageCursor(page) {
+  return page.nextCursor === void 0 ? {} : { nextCursor: page.nextCursor };
+}
+__name(pageCursor, "pageCursor");
+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;
+}
+__name(validateReadResourceResult, "validateReadResourceResult");
+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;
+}
+__name(validateCallToolResult, "validateCallToolResult");
+var McpClient = class {
+  static {
+    __name(this, "McpClient");
+  }
+  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: /* @__PURE__ */ __name(() => this.cancelPending(id, new McpAbortError(), method !== "initialize", String(options.signal?.reason ?? "Aborted")), "onAbort"),
+        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 {
+  static {
+    __name(this, "TransportEvents");
+  }
+  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 {
+  }
+}
+__name(killProcessTree, "killProcessTree");
+function installExitHook() {
+  if (exitHookInstalled)
+    return;
+  exitHookInstalled = true;
+  process2.once("exit", () => {
+    for (const pid of liveProcessGroups) {
+      try {
+        process2.kill(-pid, "SIGTERM");
+      } catch {
+      }
+    }
+  });
+}
+__name(installExitHook, "installExitHook");
+var StdioTransport = class extends TransportEvents {
+  static {
+    __name(this, "StdioTransport");
+  }
+  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 = /* @__PURE__ */ __name(() => {
+        child.off("error", onError);
+        resolve();
+      }, "onSpawn");
+      const onError = /* @__PURE__ */ __name((error) => {
+        child.off("spawn", onSpawn);
+        reject(error);
+      }, "onError");
+      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 = /* @__PURE__ */ __name(() => {
+    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;
+  }, "dispatch");
+  const processLine = /* @__PURE__ */ __name((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));
+  }, "processLine");
+  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();
+  }
+}
+__name(consumeSseStream, "consumeSseStream");
+var McpHttpError = class extends Error {
+  static {
+    __name(this, "McpHttpError");
+  }
+  status;
+  body;
+  constructor(status, message, body = "") {
+    super(message);
+    this.name = "McpHttpError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var McpAuthRequiredError = class extends McpHttpError {
+  static {
+    __name(this, "McpAuthRequiredError");
+  }
+  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 {
+  static {
+    __name(this, "McpSessionExpiredError");
+  }
+  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();
+}
+__name(contentType, "contentType");
+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") ?? "");
+}
+__name(needsAuthorization, "needsAuthorization");
+function isTransientStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+__name(isTransientStatus, "isTransientStatus");
+function discard(response) {
+  return response.body?.cancel().catch(() => {
+  }) ?? Promise.resolve();
+}
+__name(discard, "discard");
+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}` : ""}`;
+}
+__name(describeHttpFailure, "describeHttpFailure");
+var StreamableHttpTransport = class extends TransportEvents {
+  static {
+    __name(this, "StreamableHttpTransport");
+  }
+  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: /* @__PURE__ */ __name((id) => {
+        cursor.lastEventId = id;
+      }, "onId"),
+      onRetry: /* @__PURE__ */ __name((delayMs) => {
+        cursor.retryMs = delayMs;
+      }, "onRetry"),
+      onEvent: /* @__PURE__ */ __name((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);
+      }, "onEvent")
+    });
+  }
+  /**
+   * 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 = /* @__PURE__ */ __name((message) => {
+      if (isJsonRpcResponse(message) && message.id === requestId)
+        answered = true;
+    }, "onMessage");
+    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 = /* @__PURE__ */ __name(() => {
+        clearTimeout(timer);
+        resolve(false);
+      }, "onAbort");
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(true);
+      }, ms);
+      timer.unref?.();
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+};
+
+// node_modules/@earendil-works/pi-mcp/dist/protocol/content.js
+function blockToLlmContent(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "text", text: block.text };
+    case "image":
+      return { type: "image", data: block.data, mimeType: block.mimeType };
+    case "audio":
+      return { type: "text", text: `[audio ${block.mimeType} omitted]` };
+    case "resource_link":
+      return { type: "text", text: `${block.name}: ${block.uri}` };
+    case "resource": {
+      const resource = block.resource;
+      if ("text" in resource)
+        return { type: "text", text: resource.text };
+      if (resource.mimeType?.startsWith("image/")) {
+        return { type: "image", data: resource.blob, mimeType: resource.mimeType };
+      }
+      return {
+        type: "text",
+        text: `[binary resource ${resource.uri} (${resource.mimeType ?? "unknown type"}) omitted]`
+      };
+    }
+    default:
+      return { type: "text", text: `[unsupported MCP content ${block.type}]` };
+  }
+}
+__name(blockToLlmContent, "blockToLlmContent");
+function toLlmContent(result) {
+  const content = (result.content ?? []).map(blockToLlmContent);
+  if (content.length === 0 && result.structuredContent !== void 0) {
+    content.push({ type: "text", text: JSON.stringify(result.structuredContent, null, 2) });
+  }
+  return content;
+}
+__name(toLlmContent, "toLlmContent");
+
+export {
+  require_proper_lockfile,
+  operationSignal,
+  raceWithAbortSignal,
+  getConfigValueEnvVarNames,
+  isCommandConfigValue,
+  isConfigValueConfigured,
+  resolveConfigValueOrThrow,
+  resolveHeadersOrThrow,
+  FileAuthStorageBackend,
+  ReadOnlyAuthStorage,
+  AuthStorage,
+  readStoredCredential,
+  createToolNameMatcher,
+  LIST_MCP_RESOURCES_TOOL,
+  LIST_MCP_RESOURCE_TEMPLATES_TOOL,
+  READ_MCP_RESOURCE_TOOL,
+  isMcpToolName,
+  mcpNamespace,
+  getMcpToolExposure,
+  validateMcpServerConfig,
+  McpServerRegistry,
+  JSON_RPC_ERROR_CODES,
+  McpError,
+  isObject,
+  LATEST_PROTOCOL_VERSION,
+  McpClient,
+  toLlmContent,
+  StdioTransport,
+  McpHttpError,
+  McpAuthRequiredError,
+  McpSessionExpiredError,
+  StreamableHttpTransport
+};