@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/dist/cli-447dt1h3.js

@@ -0,0 +1,3828 @@
+import {
+  Container,
+  Spacer,
+  Text,
+  VisualLinePreview,
+  formatToolCallWithArgs,
+  getAgentDir,
+  getFileRevision,
+  getShellConfig,
+  getTextOutput,
+  keyHint,
+  normalizePath,
+  replaceTabs,
+  stripBom
+} from "./cli-d5czme6m.js";
+import {
+  require_cross_spawn
+} from "./cli-5bfdm1ah.js";
+import {
+  require_signal_exit
+} from "./cli-0xqde53b.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./cli-bc05qbss.js";
+
+// node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS(function(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, function CB(er) {
+            if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 60000) {
+              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);
+          });
+        }
+        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 = 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);
+          };
+        }
+        return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+      }
+      if (Object.setPrototypeOf)
+        Object.setPrototypeOf(read, fs$read);
+      return read;
+    }(fs.read);
+    fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : 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;
+      };
+    }
+    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() {};
+      }
+    }
+    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);
+        });
+      };
+    }
+    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;
+        }
+      };
+    }
+    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);
+        });
+      };
+    }
+    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;
+        }
+      };
+    }
+    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);
+        }
+        return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
+      };
+    }
+    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;
+      };
+    }
+    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;
+    }
+  }
+});
+
+// node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS(function(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 !== undefined) {
+        if (typeof this.start !== "number") {
+          throw TypeError("start must be a Number");
+        }
+        if (this.end === undefined) {
+          this.end = Infinity;
+        } else if (typeof this.end !== "number") {
+          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();
+      });
+    }
+    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 !== undefined) {
+        if (typeof this.start !== "number") {
+          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, undefined]);
+        this.flush();
+      }
+    }
+  }
+});
+
+// node_modules/graceful-fs/clone.js
+var require_clone = __commonJS(function(exports, module) {
+  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 = Object.create(null);
+    Object.getOwnPropertyNames(obj).forEach(function(key) {
+      Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+    });
+    return copy;
+  }
+});
+
+// node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = __commonJS(function(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 = Symbol.for("graceful-fs.queue");
+    previousSymbol = Symbol.for("graceful-fs.previous");
+  } else {
+    gracefulQueue = "___graceful-fs.queue";
+    previousSymbol = "___graceful-fs.previous";
+  }
+  function noop() {}
+  function publishQueue(context, queue2) {
+    Object.defineProperty(context, gracefulQueue, {
+      get: function() {
+        return queue2;
+      }
+    });
+  }
+  var debug = noop;
+  if (util.debuglog)
+    debug = util.debuglog("gfs4");
+  else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+    debug = function() {
+      var m = util.format.apply(util, arguments);
+      m = "GFS4: " + m.split(/\n/).join(`
+GFS4: `);
+      console.error(m);
+    };
+  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);
+        });
+      }
+      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();
+      }
+      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);
+          }
+        });
+      }
+    }
+    var fs$writeFile = fs2.writeFile;
+    fs2.writeFile = writeFile2;
+    function writeFile2(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);
+          }
+        });
+      }
+    }
+    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);
+          }
+        });
+      }
+    }
+    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);
+          }
+        });
+      }
+    }
+    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) ? function go$readdir2(path2, options2, cb2, startTime) {
+        return fs$readdir(path2, fs$readdirCallback(path2, options2, cb2, startTime));
+      } : function go$readdir2(path2, options2, cb2, startTime) {
+        return fs$readdir(path2, options2, fs$readdirCallback(path2, options2, cb2, startTime));
+      };
+      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);
+          }
+        };
+      }
+    }
+    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: function() {
+        return ReadStream;
+      },
+      set: function(val) {
+        ReadStream = val;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(fs2, "WriteStream", {
+      get: function() {
+        return WriteStream;
+      },
+      set: function(val) {
+        WriteStream = val;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    var FileReadStream = ReadStream;
+    Object.defineProperty(fs2, "FileReadStream", {
+      get: function() {
+        return FileReadStream;
+      },
+      set: function(val) {
+        FileReadStream = val;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    var FileWriteStream = WriteStream;
+    Object.defineProperty(fs2, "FileWriteStream", {
+      get: function() {
+        return FileWriteStream;
+      },
+      set: function(val) {
+        FileWriteStream = val;
+      },
+      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);
+    }
+    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();
+        }
+      });
+    }
+    function WriteStream(path, options) {
+      if (this instanceof WriteStream)
+        return fs$WriteStream.apply(this, arguments), this;
+      else
+        return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+    }
+    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);
+        }
+      });
+    }
+    function createReadStream(path, options) {
+      return new fs2.ReadStream(path, options);
+    }
+    function createWriteStream(path, options) {
+      return new fs2.WriteStream(path, options);
+    }
+    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);
+          }
+        });
+      }
+    }
+    return fs2;
+  }
+  function enqueue(elem) {
+    debug("ENQUEUE", elem[0].name, elem[1]);
+    fs[gracefulQueue].push(elem);
+    retry();
+  }
+  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();
+  }
+  function retry() {
+    clearTimeout(retryTimer);
+    retryTimer = undefined;
+    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 === undefined) {
+      debug("RETRY", fn.name, args);
+      fn.apply(null, args);
+    } else if (Date.now() - startTime >= 60000) {
+      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 === undefined) {
+      retryTimer = setTimeout(retry, 0);
+    }
+  }
+});
+
+// node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS(function(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);
+    }
+  }
+  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 = 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 === undefined) {
+      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 = 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/retry/lib/retry.js
+var require_retry = __commonJS(function(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 * 1000,
+      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] = 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);
+        });
+      }.bind(obj, original);
+      obj[method].options = options;
+    }
+  };
+});
+
+// node_modules/proper-lockfile/lib/mtime-precision.js
+var require_mtime_precision = __commonJS(function(exports, module) {
+  var cacheSymbol = 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() / 1000) * 1000 + 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() % 1000 === 0 ? "s" : "ms";
+        Object.defineProperty(fs, cacheSymbol, { value: precision });
+        callback(null, stat.mtime, precision);
+      });
+    });
+  }
+  function getMtime(precision) {
+    let now = Date.now();
+    if (precision === "s") {
+      now = Math.ceil(now / 1000) * 1000;
+    }
+    return new Date(now);
+  }
+  exports.probe = probe;
+  exports.getMtime = getMtime;
+});
+
+// node_modules/proper-lockfile/lib/lockfile.js
+var require_lockfile = __commonJS(function(exports, module) {
+  var path = __require("path");
+  var fs = require_graceful_fs();
+  var retry = require_retry();
+  var onExit = require_signal_exit();
+  var mtimePrecision = require_mtime_precision();
+  var locks = {};
+  function getLockFile(file, options) {
+    return options.lockfilePath || `${file}.lock`;
+  }
+  function resolveCanonicalPath(file, options, callback) {
+    if (!options.realpath) {
+      return callback(null, path.resolve(file));
+    }
+    options.fs.realpath(file, callback);
+  }
+  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);
+        });
+      });
+    });
+  }
+  function isLockStale(stat, options) {
+    return stat.mtime.getTime() < Date.now() - options.stale;
+  }
+  function removeLock(file, options, callback) {
+    options.fs.rmdir(getLockFile(file, options), (err) => {
+      if (err && err.code !== "ENOENT") {
+        return callback(err);
+      }
+      callback();
+    });
+  }
+  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 = 1000;
+          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 = 1000;
+            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();
+    }
+  }
+  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);
+  }
+  function lock(file, options, callback) {
+    options = {
+      stale: 1e4,
+      update: null,
+      realpath: true,
+      retries: 0,
+      fs,
+      onCompromised: (err) => {
+        throw err;
+      },
+      ...options
+    };
+    options.retries = options.retries || 0;
+    options.retries = typeof options.retries === "number" ? { retries: options.retries } : options.retries;
+    options.stale = Math.max(options.stale || 0, 2000);
+    options.update = options.update == null ? options.stale / 2 : options.update || 0;
+    options.update = Math.max(Math.min(options.update, options.stale / 2), 1000);
+    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);
+          });
+        });
+      });
+    });
+  }
+  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);
+    });
+  }
+  function check(file, options, callback) {
+    options = {
+      stale: 1e4,
+      realpath: true,
+      fs,
+      ...options
+    };
+    options.stale = Math.max(options.stale || 0, 2000);
+    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));
+      });
+    });
+  }
+  function getLocks() {
+    return locks;
+  }
+  onExit(() => {
+    for (const file in locks) {
+      const options = locks[file].options;
+      try {
+        options.fs.rmdirSync(getLockFile(file, options));
+      } catch (e) {}
+    }
+  });
+  exports.lock = lock;
+  exports.unlock = unlock;
+  exports.check = check;
+  exports.getLocks = getLocks;
+});
+
+// node_modules/proper-lockfile/lib/adapter.js
+var require_adapter = __commonJS(function(exports, module) {
+  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;
+  }
+  function toPromise(method) {
+    return (...args) => new Promise((resolve, reject) => {
+      args.push((err, result) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(result);
+        }
+      });
+      method(...args);
+    });
+  }
+  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;
+    };
+  }
+  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;
+  }
+  module.exports = {
+    toPromise,
+    toSync,
+    toSyncOptions
+  };
+});
+
+// node_modules/proper-lockfile/index.js
+var require_proper_lockfile = __commonJS(function(exports, module) {
+  var lockfile = require_lockfile();
+  var { toPromise, toSync, toSyncOptions } = require_adapter();
+  async function lock(file, options) {
+    const release = await toPromise(lockfile.lock)(file, options);
+    return toPromise(release);
+  }
+  function lockSync(file, options) {
+    const release = toSync(lockfile.lock)(file, toSyncOptions(options));
+    return toSync(release);
+  }
+  function unlock(file, options) {
+    return toPromise(lockfile.unlock)(file, options);
+  }
+  function unlockSync(file, options) {
+    return toSync(lockfile.unlock)(file, toSyncOptions(options));
+  }
+  function check(file, options) {
+    return toPromise(lockfile.check)(file, options);
+  }
+  function checkSync(file, options) {
+    return toSync(lockfile.check)(file, toSyncOptions(options));
+  }
+  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 = 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 });
+}
+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;
+}
+function parseConfigValueReference(config) {
+  if (config.startsWith("!")) {
+    return { type: "command", config };
+  }
+  return { type: "template", parts: parseConfigValueTemplate(config) };
+}
+function resolveEnvConfigValue(name, env) {
+  return env?.[name] || process.env[name] || undefined;
+}
+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;
+}
+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 === undefined)
+      return;
+    resolved += envValue;
+  }
+  return resolved;
+}
+function getConfigValueEnvVarNames(config) {
+  const reference = parseConfigValueReference(config);
+  return reference.type === "template" ? getTemplateEnvVarNames(reference.parts) : [];
+}
+function getMissingConfigValueEnvVarNames(config, env) {
+  return getConfigValueEnvVarNames(config).filter((name) => resolveEnvConfigValue(name, env) === undefined);
+}
+function isCommandConfigValue(config) {
+  return parseConfigValueReference(config).type === "command";
+}
+function isConfigValueConfigured(config, env) {
+  return getMissingConfigValueEnvVarNames(config, env).length === 0;
+}
+function resolveConfigValue(config, env) {
+  const reference = parseConfigValueReference(config);
+  if (reference.type === "command") {
+    return executeCommand(reference.config);
+  }
+  return resolveTemplate(reference.parts, env);
+}
+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 : undefined,
+      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: undefined };
+      }
+      return { executed: true, value: undefined };
+    }
+    if (result.status !== 0) {
+      return { executed: true, value: undefined };
+    }
+    const value = (result.stdout ?? "").trim();
+    return { executed: true, value: value || undefined };
+  } catch {
+    return { executed: false, value: undefined };
+  }
+}
+function executeWithDefaultShell(command) {
+  try {
+    const output = execSync(command, {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return output.trim() || undefined;
+  } catch {
+    return;
+  }
+}
+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);
+}
+function executeCommand(commandConfig) {
+  if (commandResultCache.has(commandConfig)) {
+    return commandResultCache.get(commandConfig);
+  }
+  const result = executeCommandUncached(commandConfig);
+  commandResultCache.set(commandConfig, result);
+  return result;
+}
+function resolveConfigValueUncached(config, env) {
+  const reference = parseConfigValueReference(config);
+  if (reference.type === "command") {
+    return executeCommandUncached(reference.config);
+  }
+  return resolveTemplate(reference.parts, env);
+}
+function resolveConfigValueOrThrow(config, description, env) {
+  const resolvedValue = resolveConfigValueUncached(config, env);
+  if (resolvedValue !== undefined) {
+    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}`);
+}
+function resolveHeadersOrThrow(headers, description, env) {
+  if (!headers)
+    return;
+  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 : undefined;
+}
+
+// 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
+};
+
+class McpError extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "McpError";
+    this.code = code;
+    this.data = data;
+  }
+}
+
+class McpConnectionClosedError extends Error {
+  constructor(message = "MCP connection closed") {
+    super(message);
+    this.name = "McpConnectionClosedError";
+  }
+}
+
+class McpTimeoutError extends Error {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`MCP request timed out after ${timeoutMs}ms`);
+    this.name = "McpTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+class McpAbortError extends Error {
+  constructor(message = "MCP request aborted") {
+    super(message);
+    this.name = "AbortError";
+  }
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function isJsonRpcId(value) {
+  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function isJsonRpcRequest(message) {
+  return isObject(message) && message.jsonrpc === "2.0" && isJsonRpcId(message.id) && typeof message.method === "string";
+}
+function isJsonRpcNotification(message) {
+  return isObject(message) && message.jsonrpc === "2.0" && !("id" in message) && typeof message.method === "string";
+}
+function isJsonRpcResponse(message) {
+  if (!isObject(message) || message.jsonrpc !== "2.0" || !isJsonRpcId(message.id))
+    return false;
+  if ("result" in message)
+    return !("error" in message);
+  if (!("error" in message) || !isObject(message.error))
+    return false;
+  return typeof message.error.code === "number" && typeof message.error.message === "string";
+}
+function parseJsonRpcMessage(value) {
+  if (isJsonRpcRequest(value) || isJsonRpcNotification(value) || isJsonRpcResponse(value))
+    return value;
+  throw new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid JSON-RPC message");
+}
+
+// node_modules/@earendil-works/pi-mcp/dist/protocol/types.js
+var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05"];
+
+// node_modules/@earendil-works/pi-mcp/dist/client.js
+var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+var MAX_LIST_PAGES = 1000;
+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 !== undefined && typeof value.instructions !== "string") {
+    throw new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid MCP initialize result");
+  }
+  return value;
+}
+function invalid(message) {
+  return new McpError(JSON_RPC_ERROR_CODES.invalidRequest, message);
+}
+function validateListPage(method, key, value, isItem) {
+  const items = isObject(value) ? value[key] : undefined;
+  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`);
+  }
+  if (value.nextCursor !== undefined && typeof value.nextCursor !== "string") {
+    throw invalid(`Invalid MCP ${method} cursor`);
+  }
+  return { items, ...value.nextCursor === undefined ? {} : { nextCursor: value.nextCursor } };
+}
+var isTool = (tool) => typeof tool.name === "string" && isObject(tool.inputSchema);
+var isResource = (resource) => typeof resource.uri === "string" && (resource.name === undefined || typeof resource.name === "string");
+var isResourceTemplate = (template) => typeof template.uriTemplate === "string" && (template.name === undefined || typeof template.name === "string");
+function toResource(item) {
+  return { ...item, name: item.name ?? item.uri };
+}
+function toResourceTemplate(item) {
+  return { ...item, name: item.name ?? item.uriTemplate };
+}
+function pageCursor(page) {
+  return page.nextCursor === undefined ? {} : { nextCursor: page.nextCursor };
+}
+function validateReadResourceResult(value) {
+  if (!isObject(value) || !Array.isArray(value.contents))
+    throw invalid("Invalid MCP resources/read result");
+  for (const contents of value.contents) {
+    if (!isObject(contents) || typeof contents.uri !== "string" || typeof contents.text !== "string" && typeof contents.blob !== "string") {
+      throw invalid("Invalid contents in MCP resources/read result");
+    }
+  }
+  return value;
+}
+function validateCallToolResult(value) {
+  if (!isObject(value) || value.content !== undefined && !Array.isArray(value.content)) {
+    throw new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid MCP tools/call result");
+  }
+  if (value.structuredContent !== undefined && !isObject(value.structuredContent)) {
+    throw new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid MCP tools/call structured content");
+  }
+  return value.content === undefined ? { ...value, content: [] } : value;
+}
+
+class McpClient {
+  options;
+  state = "idle";
+  transport;
+  nextRequestId = 1;
+  serverInfoValue;
+  serverCapabilitiesValue;
+  instructionsValue;
+  protocolVersionValue;
+  pending = new Map;
+  progressRequests = new Map;
+  incoming = new Map;
+  requestHandlers = new Map;
+  notificationListeners = new Map;
+  errorListeners = new Set;
+  closeListeners = 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.onError((error) => this.emitError(error)),
+      transport.onClose(() => this.handleTransportClose())
+    ];
+    try {
+      await transport.start();
+      const capabilities = { ...this.options.capabilities };
+      if (this.options.roots && capabilities.roots === undefined)
+        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 === undefined ? {} : { 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", undefined, 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) ?? 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);
+  }
+  onClose(listener) {
+    this.closeListeners.add(listener);
+    return () => this.closeListeners.delete(listener);
+  }
+  async ping(options = {}) {
+    await this.request("ping", undefined, options);
+  }
+  async listTools(options = {}) {
+    return await this.listAll("tools/list", "tools", isTool, options);
+  }
+  async listResources(options = {}) {
+    return (await this.listAll("resources/list", "resources", isResource, options)).map(toResource);
+  }
+  async listResourcesPage(cursor, options = {}) {
+    const page = await this.listPage("resources/list", "resources", isResource, cursor, options);
+    return { resources: page.items.map(toResource), ...pageCursor(page) };
+  }
+  async listResourceTemplates(options = {}) {
+    const templates = await this.listAll("resources/templates/list", "resourceTemplates", isResourceTemplate, options);
+    return templates.map(toResourceTemplate);
+  }
+  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 === undefined ? undefined : { cursor }, options), isItem);
+  }
+  async listAll(method, key, isItem, options) {
+    const items = [];
+    const cursors = 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 === undefined)
+        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 === undefined ? {} : { arguments: args } }, options));
+  }
+  async close() {
+    const transport = this.transport;
+    this.transport = undefined;
+    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 : undefined;
+    const requestParams = progressToken === undefined ? params : { ...params, _meta: { ...isObject(params?._meta) ? params._meta : {}, progressToken } };
+    const message = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      ...requestParams === undefined ? {} : { params: requestParams }
+    };
+    return new Promise((resolve, reject) => {
+      const entry = {
+        resolve,
+        reject,
+        timeoutMs: options.timeoutMs ?? this.options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+        timer: undefined,
+        signal: options.signal,
+        onAbort: () => this.cancelPending(id, new McpAbortError, method !== "initialize", String(options.signal?.reason ?? "Aborted")),
+        cancellable: method !== "initialize",
+        onProgress: options.onProgress,
+        progressToken
+      };
+      this.pending.set(id, entry);
+      if (progressToken !== undefined)
+        this.progressRequests.set(progressToken, id);
+      options.signal?.addEventListener("abort", entry.onAbort, { once: true });
+      this.armTimeout(id, entry);
+      transport.send(message).catch((error) => this.cancelPending(id, error, false));
+    });
+  }
+  async notifyInternal(method, params, allowConnecting) {
+    await this.requireTransport(allowConnecting).send({
+      jsonrpc: "2.0",
+      method,
+      ...params === undefined ? {} : { 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)) {
+      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 === undefined ? undefined : this.pending.get(requestId);
+    if (requestId === undefined || !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) {
+      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 !== undefined)
+      this.progressRequests.delete(entry.progressToken);
+    entry.signal?.removeEventListener("abort", entry.onAbort);
+  }
+  rejectPending(error) {
+    for (const [id, entry] of this.pending) {
+      this.removePending(id, entry);
+      entry.reject(error);
+    }
+  }
+  handleTransportClose() {
+    this.markClosed(new McpConnectionClosedError);
+  }
+  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;
+
+class TransportEvents {
+  messageListeners = new Set;
+  errorListeners = new Set;
+  closeListeners = 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 = 2000;
+var STDIN_CLOSE_GRACE_MS = 500;
+var USE_PROCESS_GROUPS = process2.platform !== "win32";
+var liveProcessGroups = new Set;
+var exitHookInstalled = false;
+function killProcessTree(child, signal) {
+  const pid = child.pid;
+  if (process2.platform === "win32" && pid !== undefined) {
+    if (child.exitCode !== null)
+      return;
+    spawn("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true }).on("error", () => {});
+    return;
+  }
+  if (USE_PROCESS_GROUPS && pid !== undefined) {
+    try {
+      process2.kill(-pid, signal);
+      return;
+    } catch {}
+  }
+  try {
+    child.kill(signal);
+  } catch {}
+}
+function installExitHook() {
+  if (exitHookInstalled)
+    return;
+  exitHookInstalled = true;
+  process2.once("exit", () => {
+    for (const pid of liveProcessGroups) {
+      try {
+        process2.kill(-pid, "SIGTERM");
+      } catch {}
+    }
+  });
+}
+
+class StdioTransport extends TransportEvents {
+  options;
+  child;
+  stdoutBuffer = Buffer.alloc(0);
+  stderrBuffer = Buffer.alloc(0);
+  started = false;
+  closed = false;
+  constructor(options) {
+    super();
+    this.options = Object.freeze({ ...options, args: options.args ? [...options.args] : undefined });
+  }
+  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 = 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,
+      detached: USE_PROCESS_GROUPS
+    });
+    this.child = child;
+    const pid = child.pid;
+    if (USE_PROCESS_GROUPS && pid !== undefined) {
+      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 = undefined;
+      if (this.stdoutBuffer.toString("utf8").trim()) {
+        this.emitError(new Error("MCP stdio server closed with an incomplete JSON-RPC message"));
+      }
+      this.stdoutBuffer = Buffer.alloc(0);
+      this.emitClose();
+    });
+    await new Promise((resolve, reject) => {
+      const onSpawn = () => {
+        child.off("error", onError);
+        resolve();
+      };
+      const onError = (error) => {
+        child.off("spawn", onSpawn);
+        reject(error);
+      };
+      child.once("spawn", onSpawn);
+      child.once("error", onError);
+    });
+    child.on("error", (error) => {
+      if (!this.closed)
+        this.emitError(error);
+    });
+  }
+  async send(message) {
+    const stdin = this.child?.stdin;
+    if (!this.started || this.closed || !stdin?.writable)
+      throw new McpConnectionClosedError;
+    const payload = `${JSON.stringify(message)}
+`;
+    await new Promise((resolve, reject) => {
+      stdin.write(payload, (error) => error ? reject(error) : resolve());
+    });
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    const child = this.child;
+    if (!child) {
+      this.emitClose();
+      return;
+    }
+    if (child.exitCode !== null || child.signalCode !== null) {
+      child.stdin?.end();
+      return;
+    }
+    const closeTimeoutMs = this.options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
+    await new Promise((resolve) => {
+      const timers = [];
+      child.once("close", () => {
+        for (const timer of timers)
+          clearTimeout(timer);
+        killProcessTree(child, "SIGTERM");
+        resolve();
+      });
+      const grace = Math.min(STDIN_CLOSE_GRACE_MS, closeTimeoutMs);
+      timers.push(setTimeout(() => killProcessTree(child, "SIGTERM"), grace));
+      timers.push(setTimeout(() => killProcessTree(child, "SIGKILL"), grace + closeTimeoutMs));
+      child.stdin?.end();
+    });
+  }
+  handleStdout(chunk) {
+    this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+    const maxMessageBytes = this.options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES;
+    while (true) {
+      const newline = this.stdoutBuffer.indexOf(10);
+      if (newline < 0) {
+        if (this.stdoutBuffer.length > maxMessageBytes) {
+          this.stdoutBuffer = Buffer.alloc(0);
+          this.emitError(new Error(`MCP stdio message exceeds ${maxMessageBytes} bytes`));
+        }
+        return;
+      }
+      const line = this.stdoutBuffer.subarray(0, newline);
+      this.stdoutBuffer = this.stdoutBuffer.subarray(newline + 1);
+      if (line.length > maxMessageBytes) {
+        this.emitError(new Error(`MCP stdio message exceeds ${maxMessageBytes} bytes`));
+        continue;
+      }
+      const text = line.toString("utf8").replace(/\r$/, "");
+      if (!text.trim())
+        continue;
+      try {
+        this.emitMessage(parseJsonRpcMessage(JSON.parse(text)));
+      } catch (error) {
+        this.emitError(error);
+      }
+    }
+  }
+  handleStderr(chunk) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const maxStderrBytes = this.options.maxStderrBytes ?? DEFAULT_MAX_STDERR_BYTES;
+    this.stderrBuffer = Buffer.concat([this.stderrBuffer, buffer]);
+    if (this.stderrBuffer.length > maxStderrBytes)
+      this.stderrBuffer = this.stderrBuffer.subarray(-maxStderrBytes);
+    this.options.onStderr?.(buffer.toString("utf8"));
+  }
+}
+
+// node_modules/@earendil-works/pi-mcp/dist/transports/streamable-http.js
+var MAX_ERROR_BODY_BYTES = 8 * 1024;
+var ERROR_MESSAGE_BODY_CHARS = 500;
+var DEFAULT_RECONNECT_INITIAL_DELAY_MS = 1000;
+var DEFAULT_RECONNECT_MAX_DELAY_MS = 30000;
+var DEFAULT_RECONNECT_MAX_RETRIES = 5;
+async function consumeSseStream(stream, options) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let buffered = "";
+  let eventName;
+  let eventId;
+  let dataLines = [];
+  let dataBytes = 0;
+  const maxEventBytes = options.maxEventBytes ?? DEFAULT_MAX_MESSAGE_BYTES;
+  const dispatch = () => {
+    if (dataLines.length === 0) {
+      eventName = undefined;
+      eventId = undefined;
+      return;
+    }
+    const data = dataLines.join(`
+`);
+    options.onEvent({ ...eventName ? { event: eventName } : {}, data, ...eventId ? { id: eventId } : {} });
+    eventName = undefined;
+    eventId = undefined;
+    dataLines = [];
+    dataBytes = 0;
+  };
+  const processLine = (rawLine) => {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (line === "") {
+      dispatch();
+      return;
+    }
+    if (line.startsWith(":"))
+      return;
+    const colon = line.indexOf(":");
+    const field = colon < 0 ? line : line.slice(0, colon);
+    let value = colon < 0 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" "))
+      value = value.slice(1);
+    if (field === "data") {
+      dataBytes += Buffer.byteLength(value) + (dataLines.length > 0 ? 1 : 0);
+      if (dataBytes > maxEventBytes)
+        throw new Error(`MCP SSE event exceeds ${maxEventBytes} bytes`);
+      dataLines.push(value);
+    } else if (field === "event")
+      eventName = value;
+    else if (field === "id" && !value.includes("\x00")) {
+      eventId = value;
+      options.onId?.(value);
+    } else if (field === "retry" && /^\d+$/.test(value))
+      options.onRetry?.(Number(value));
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffered += decoder.decode(value, { stream: true });
+      let newline = buffered.indexOf(`
+`);
+      while (newline >= 0) {
+        processLine(buffered.slice(0, newline));
+        buffered = buffered.slice(newline + 1);
+        newline = buffered.indexOf(`
+`);
+      }
+      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();
+  }
+}
+
+class McpHttpError extends Error {
+  status;
+  body;
+  constructor(status, message, body = "") {
+    super(message);
+    this.name = "McpHttpError";
+    this.status = status;
+    this.body = body;
+  }
+}
+
+class McpAuthRequiredError extends McpHttpError {
+  wwwAuthenticate;
+  constructor(response, body = "") {
+    super(401, "MCP server requires authentication", body);
+    this.name = "McpAuthRequiredError";
+    this.wwwAuthenticate = response.headers.get("www-authenticate");
+  }
+}
+
+class McpSessionExpiredError extends McpHttpError {
+  constructor(body = "") {
+    super(404, "MCP session expired", body);
+    this.name = "McpSessionExpiredError";
+  }
+}
+function contentType(response) {
+  return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+}
+function needsAuthorization(response) {
+  if (response.status === 401)
+    return true;
+  if (response.status !== 403)
+    return false;
+  return /(?:^|[\s,])error="?insufficient_scope"?/i.test(response.headers.get("www-authenticate") ?? "");
+}
+function isTransientStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+function discard(response) {
+  return response.body?.cancel().catch(() => {}) ?? Promise.resolve();
+}
+function describeHttpFailure(status, body) {
+  const text = body.trim();
+  const snippet = text.length > ERROR_MESSAGE_BODY_CHARS ? `${text.slice(0, ERROR_MESSAGE_BODY_CHARS - 3)}...` : text;
+  return `MCP HTTP request failed with status ${status}${snippet ? `: ${snippet}` : ""}`;
+}
+
+class StreamableHttpTransport extends TransportEvents {
+  url;
+  options;
+  fetch;
+  controller = new AbortController;
+  started = false;
+  closed = false;
+  sessionIdValue;
+  protocolVersion;
+  getStreamStarted = false;
+  constructor(options) {
+    super();
+    this.options = Object.freeze({ ...options, headers: options.headers ? { ...options.headers } : undefined });
+    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) {
+    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)
+    });
+    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) {
+      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) {
+      const controller = new AbortController;
+      const timeout = setTimeout(() => controller.abort(), 1000);
+      try {
+        const { headers } = await this.headers();
+        await this.fetch(this.url, { method: "DELETE", headers, signal: controller.signal }).then(discard).catch(() => {
+          return;
+        });
+      } catch {} finally {
+        clearTimeout(timeout);
+      }
+    }
+    this.emitClose();
+  }
+  async authorizedFetch(method, init) {
+    const onUnauthorized = this.options.authProvider?.onUnauthorized?.bind(this.options.authProvider);
+    for (let attempt = 0;; attempt++) {
+      const { headers, token } = await this.headers(init.headers);
+      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 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);
+    const token = await this.options.authProvider?.token();
+    if (token)
+      headers.set("Authorization", `Bearer ${token}`);
+    return { headers, ...token ? { token } : {} };
+  }
+  captureSession(response) {
+    const sessionId = response.headers.get("mcp-session-id");
+    if (sessionId)
+      this.sessionIdValue = sessionId;
+  }
+  async checkResponse(response) {
+    if (response.ok)
+      return;
+    const body = (await response.text().catch(() => "")).slice(0, MAX_ERROR_BODY_BYTES);
+    if (response.status === 401)
+      throw new McpAuthRequiredError(response, body);
+    if (response.status === 404 && this.sessionIdValue)
+      throw new McpSessionExpiredError(body);
+    throw new McpHttpError(response.status, describeHttpFailure(response.status, body), body);
+  }
+  async consumeSse(stream, cursor, onMessage) {
+    await consumeSseStream(stream, {
+      maxEventBytes: this.options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES,
+      onId: (id) => {
+        cursor.lastEventId = id;
+      },
+      onRetry: (delayMs) => {
+        cursor.retryMs = delayMs;
+      },
+      onEvent: (event) => {
+        cursor.received = true;
+        if (!event.data.trim() || event.event !== undefined && event.event !== "message")
+          return;
+        let message;
+        try {
+          message = parseJsonRpcMessage(JSON.parse(event.data));
+        } catch (error) {
+          this.emitError(error);
+          return;
+        }
+        onMessage?.(message);
+        this.emitMessage(message);
+      }
+    });
+  }
+  async consumeResponseStream(body, requestId) {
+    const cursor = { lastEventId: undefined, retryMs: undefined, received: false };
+    let answered = false;
+    const onMessage = (message) => {
+      if (isJsonRpcResponse(message) && message.id === requestId)
+        answered = true;
+    };
+    let stream = body;
+    let failure;
+    for (let attempt = 0;; ) {
+      if (stream) {
+        try {
+          await this.consumeSse(stream, cursor, onMessage);
+          failure = undefined;
+        } catch (error) {
+          failure = error;
+        }
+      }
+      if (answered || this.closed)
+        return;
+      if (failure !== undefined && !this.isRetryable(failure))
+        break;
+      if (cursor.lastEventId === undefined || 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 = undefined;
+      }
+    }
+    if (this.closed)
+      return;
+    const reason = failure === undefined ? "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;
+    this.runGetStream();
+  }
+  async runGetStream() {
+    const cursor = { lastEventId: undefined, retryMs: undefined, 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;
+    }
+  }
+  async openSseStream(lastEventId) {
+    const response = await this.authorizedFetch("GET", {
+      headers: {
+        accept: "text/event-stream",
+        ...lastEventId === undefined ? {} : { "last-event-id": lastEventId }
+      }
+    });
+    if (response.status === 405) {
+      await discard(response);
+      return;
+    }
+    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;
+  }
+  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 !== undefined)
+      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;
+  }
+  sleep(ms) {
+    const signal = this.controller.signal;
+    if (signal.aborted)
+      return Promise.resolve(false);
+    return new Promise((resolve) => {
+      const onAbort = () => {
+        clearTimeout(timer);
+        resolve(false);
+      };
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(true);
+      }, ms);
+      timer.unref?.();
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+}
+// 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}]` };
+  }
+}
+function toLlmContent(result) {
+  const content = (result.content ?? []).map(blockToLlmContent);
+  if (content.length === 0 && result.structuredContent !== undefined) {
+    content.push({ type: "text", text: JSON.stringify(result.structuredContent, null, 2) });
+  }
+  return content;
+}
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/mcp/tools.js
+import { createHash, randomBytes } from "node:crypto";
+import { writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/tools/truncate.js
+var DEFAULT_MAX_LINES = 2000;
+var DEFAULT_MAX_BYTES = 50 * 1024;
+var GREP_MAX_LINE_LENGTH = 500;
+function splitLinesForCounting(content) {
+  if (content.length === 0) {
+    return [];
+  }
+  const lines = content.split(`
+`);
+  if (content.endsWith(`
+`)) {
+    lines.pop();
+  }
+  return lines;
+}
+function formatSize(bytes) {
+  if (bytes < 1024) {
+    return `${bytes}B`;
+  } else if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  } else {
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  }
+}
+function truncateHead(content, options = {}) {
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const totalBytes = Buffer.byteLength(content, "utf-8");
+  const lines = splitLinesForCounting(content);
+  const totalLines = lines.length;
+  if (totalLines <= maxLines && totalBytes <= maxBytes) {
+    return {
+      content,
+      truncated: false,
+      truncatedBy: null,
+      totalLines,
+      totalBytes,
+      outputLines: totalLines,
+      outputBytes: totalBytes,
+      lastLinePartial: false,
+      firstLineExceedsLimit: false,
+      maxLines,
+      maxBytes
+    };
+  }
+  const firstLineBytes = Buffer.byteLength(lines[0], "utf-8");
+  if (firstLineBytes > maxBytes) {
+    return {
+      content: "",
+      truncated: true,
+      truncatedBy: "bytes",
+      totalLines,
+      totalBytes,
+      outputLines: 0,
+      outputBytes: 0,
+      lastLinePartial: false,
+      firstLineExceedsLimit: true,
+      maxLines,
+      maxBytes
+    };
+  }
+  const outputLinesArr = [];
+  let outputBytesCount = 0;
+  let truncatedBy = "lines";
+  for (let i = 0;i < lines.length && i < maxLines; i++) {
+    const line = lines[i];
+    const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0);
+    if (outputBytesCount + lineBytes > maxBytes) {
+      truncatedBy = "bytes";
+      break;
+    }
+    outputLinesArr.push(line);
+    outputBytesCount += lineBytes;
+  }
+  if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+    truncatedBy = "lines";
+  }
+  const outputContent = outputLinesArr.join(`
+`);
+  const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+  return {
+    content: outputContent,
+    truncated: true,
+    truncatedBy,
+    totalLines,
+    totalBytes,
+    outputLines: outputLinesArr.length,
+    outputBytes: finalOutputBytes,
+    lastLinePartial: false,
+    firstLineExceedsLimit: false,
+    maxLines,
+    maxBytes
+  };
+}
+function truncateTail(content, options = {}) {
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const totalBytes = Buffer.byteLength(content, "utf-8");
+  const lines = splitLinesForCounting(content);
+  const totalLines = lines.length;
+  if (totalLines <= maxLines && totalBytes <= maxBytes) {
+    return {
+      content,
+      truncated: false,
+      truncatedBy: null,
+      totalLines,
+      totalBytes,
+      outputLines: totalLines,
+      outputBytes: totalBytes,
+      lastLinePartial: false,
+      firstLineExceedsLimit: false,
+      maxLines,
+      maxBytes
+    };
+  }
+  const outputLinesArr = [];
+  let outputBytesCount = 0;
+  let truncatedBy = "lines";
+  let lastLinePartial = false;
+  for (let i = lines.length - 1;i >= 0 && outputLinesArr.length < maxLines; i--) {
+    const line = lines[i];
+    const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0);
+    if (outputBytesCount + lineBytes > maxBytes) {
+      truncatedBy = "bytes";
+      if (outputLinesArr.length === 0) {
+        const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
+        outputLinesArr.unshift(truncatedLine);
+        outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
+        lastLinePartial = true;
+      }
+      break;
+    }
+    outputLinesArr.unshift(line);
+    outputBytesCount += lineBytes;
+  }
+  if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+    truncatedBy = "lines";
+  }
+  const outputContent = outputLinesArr.join(`
+`);
+  const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+  return {
+    content: outputContent,
+    truncated: true,
+    truncatedBy,
+    totalLines,
+    totalBytes,
+    outputLines: outputLinesArr.length,
+    outputBytes: finalOutputBytes,
+    lastLinePartial,
+    firstLineExceedsLimit: false,
+    maxLines,
+    maxBytes
+  };
+}
+function truncateStringToBytesFromEnd(str, maxBytes) {
+  const buf = Buffer.from(str, "utf-8");
+  if (buf.length <= maxBytes) {
+    return str;
+  }
+  let start = buf.length - maxBytes;
+  while (start < buf.length && (buf[start] & 192) === 128) {
+    start++;
+  }
+  return buf.slice(start).toString("utf-8");
+}
+function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
+  if (line.length <= maxChars) {
+    return { text: line, wasTruncated: false };
+  }
+  return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
+}
+function truncateMiddle(content, maxBytes) {
+  const buf = Buffer.from(content, "utf-8");
+  const totalLines = splitLinesForCounting(content).length;
+  if (buf.length <= maxBytes) {
+    return { content, truncated: false, removedChars: 0, totalBytes: buf.length, totalLines };
+  }
+  const isBoundary = (index) => index >= buf.length || (buf[index] & 192) !== 128;
+  let headEnd = Math.floor(maxBytes / 2);
+  while (headEnd > 0 && !isBoundary(headEnd))
+    headEnd--;
+  let tailStart = buf.length - (maxBytes - Math.floor(maxBytes / 2));
+  while (tailStart < buf.length && !isBoundary(tailStart))
+    tailStart++;
+  const head = buf.subarray(0, headEnd).toString("utf-8");
+  const tail = buf.subarray(tailStart).toString("utf-8");
+  const removedChars = Array.from(buf.subarray(headEnd, tailStart).toString("utf-8")).length;
+  return {
+    content: `${head}…${removedChars} chars truncated…${tail}`,
+    truncated: true,
+    removedChars,
+    totalBytes: buf.length,
+    totalLines
+  };
+}
+
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/mcp/tools.js
+function toToolExposure(exposure) {
+  return exposure === "codemode" ? "deferred" : exposure;
+}
+var MAX_TOOL_NAME_LENGTH = 64;
+var MCP_OUTPUT_MAX_BYTES = 20 * 1024;
+var OUTPUT_PREVIEW_LINES = 5;
+var READ_MCP_RESOURCE_TOOL = "read_mcp_resource";
+async function saveToTempFile(data, extension) {
+  const path = join(tmpdir(), `pi-mcp-${randomBytes(8).toString("hex")}${extension}`);
+  await writeFile(path, data, { mode: 384 });
+  return path;
+}
+function createMcpToolName(server, tool, isTaken = () => false) {
+  const name = `mcp__${server}__${tool}`.replace(/[^A-Za-z0-9_]/g, "_");
+  if (name.length <= MAX_TOOL_NAME_LENGTH && !isTaken(name))
+    return name;
+  const hash = createHash("sha256").update(`${server}\x00${tool}`).digest("hex").slice(0, 8);
+  return `${name.slice(0, MAX_TOOL_NAME_LENGTH - hash.length - 1)}_${hash}`;
+}
+function textOf(content) {
+  return content.filter((block) => block.type === "text").map((block) => block.text).join(`
+`);
+}
+function createMcpResultSchema(structuredContentSchema) {
+  return {
+    type: "object",
+    properties: {
+      content: { type: "array", items: { type: "object" } },
+      ...structuredContentSchema ? { structuredContent: structuredContentSchema } : {},
+      isError: { type: "boolean" },
+      _meta: { type: "object" }
+    },
+    required: ["content"]
+  };
+}
+async function limitMcpContent(content, saveOutput = saveToTempFile) {
+  const combined = textOf(content);
+  const truncation = truncateMiddle(combined, MCP_OUTPUT_MAX_BYTES);
+  if (!truncation.truncated)
+    return { content };
+  let fullOutputPath;
+  let where;
+  try {
+    fullOutputPath = await saveOutput(combined, ".txt");
+    where = `[Full output: ${fullOutputPath} (read it with offset/limit)]`;
+  } catch (error) {
+    where = `[Could not save the full output: ${error instanceof Error ? error.message : String(error)}]`;
+  }
+  const tokens = Math.ceil(truncation.totalBytes / 4);
+  const text = `Warning: truncated output (original token count: ${tokens})
+Total output lines: ${truncation.totalLines}
+
+${truncation.content}
+
+${where}`;
+  return {
+    content: [{ type: "text", text }, ...content.filter((block) => block.type === "image")],
+    ...fullOutputPath ? { fullOutputPath } : {}
+  };
+}
+function extensionOf(uri) {
+  const path = URL.canParse(uri) ? new URL(uri).pathname : uri;
+  return /\.[A-Za-z0-9]{1,8}$/.exec(path)?.[0] ?? ".bin";
+}
+function isTextMimeType(mimeType) {
+  if (!mimeType)
+    return false;
+  const type = mimeType.split(";", 1)[0].trim().toLowerCase();
+  return type.startsWith("text/") || type === "application/json" || type.endsWith("+json") || type.endsWith("+xml");
+}
+async function blockToContent(server, block, options) {
+  if (block.type === "resource_link") {
+    const details = [block.mimeType, block.size === undefined ? undefined : formatSize(block.size)].filter(Boolean);
+    const read = options.readableResources ? `. Read it with ${READ_MCP_RESOURCE_TOOL} (server "${server}")` : "";
+    const description = block.description ? `: ${block.description}` : "";
+    return [
+      {
+        type: "text",
+        text: `[Resource ${block.uri} "${block.title ?? block.name}"${details.length > 0 ? ` (${details.join(", ")})` : ""}${description}${read}]`
+      }
+    ];
+  }
+  if (block.type === "resource" && "blob" in block.resource && !block.resource.mimeType?.startsWith("image/")) {
+    const { uri, mimeType, blob } = block.resource;
+    const data = Buffer.from(blob, "base64");
+    if (isTextMimeType(mimeType))
+      return [{ type: "text", text: data.toString("utf8") }];
+    const kind = `${mimeType ?? "unknown type"}, ${formatSize(data.length)}`;
+    try {
+      const path = await (options.saveOutput ?? saveToTempFile)(data, extensionOf(uri));
+      return [{ type: "text", text: `[Binary resource ${uri} (${kind}) saved to ${path}]` }];
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return [{ type: "text", text: `[Binary resource ${uri} (${kind}) could not be saved: ${reason}]` }];
+    }
+  }
+  return toLlmContent({ content: [block] });
+}
+async function toModelContent(server, blocks, options = {}) {
+  return (await Promise.all(blocks.map((block) => blockToContent(server, block, options)))).flat();
+}
+async function convertMcpResult(server, tool, result, options = {}) {
+  const converted = result.content.length > 0 ? await toModelContent(server, result.content, options) : toLlmContent(result);
+  if (result.isError && textOf(converted) === "") {
+    converted.push({ type: "text", text: `MCP tool ${server}/${tool} returned an error` });
+  }
+  const { content, fullOutputPath } = await limitMcpContent(converted, options.saveOutput);
+  const { _meta: _ignored, ...scriptResult } = result;
+  return {
+    content,
+    details: { server, tool, ...fullOutputPath ? { fullOutputPath } : {} },
+    structuredContent: scriptResult,
+    ...result.isError ? { isError: true } : {}
+  };
+}
+function toParameters(schema) {
+  return {
+    ...schema,
+    type: schema.type ?? "object",
+    ...schema.properties === undefined ? { properties: {} } : {}
+  };
+}
+var ANNOTATION_HINTS = ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"];
+function toToolAnnotations(tool) {
+  const annotations = {};
+  for (const hint of ANNOTATION_HINTS) {
+    const value = tool.annotations?.[hint];
+    if (typeof value === "boolean")
+      annotations[hint] = value;
+  }
+  return Object.keys(annotations).length > 0 ? annotations : undefined;
+}
+function createMcpToolDefinition(options) {
+  const { server, tool } = options;
+  const title = tool.title ?? tool.annotations?.title;
+  const annotations = toToolAnnotations(tool);
+  const label = `${server}/${tool.name}`;
+  return {
+    name: options.name,
+    label,
+    description: tool.description?.trim() || title || `MCP tool ${tool.name} from server ${server}`,
+    parameters: toParameters(tool.inputSchema),
+    outputSchema: createMcpResultSchema(tool.outputSchema),
+    exposure: toToolExposure(options.exposure),
+    namespace: options.namespace,
+    ...annotations ? { annotations } : {},
+    renderCall(args, theme, context) {
+      const component = context.lastComponent ?? new Text("", 0, 0);
+      component.setText(formatToolCallWithArgs(label, args, theme, context.expanded));
+      return component;
+    },
+    renderResult(result, options2, theme, context) {
+      const component = context.lastComponent ?? new Container;
+      component.clear();
+      const output = getTextOutput(result, context.showImages).trim();
+      if (!output)
+        return component;
+      const color = context.isError ? "error" : "toolOutput";
+      const styled = replaceTabs(output).split(`
+`).map((line) => theme.fg(color, line)).join(`
+`);
+      component.addChild(new Spacer(1));
+      if (options2.expanded) {
+        component.addChild(new Text(styled, 0, 0));
+      } else {
+        component.addChild(new VisualLinePreview({
+          text: styled,
+          maxVisualLines: OUTPUT_PREVIEW_LINES,
+          keep: "start",
+          formatHint: (hidden) => `${theme.fg("muted", `... (${hidden} more lines,`)} ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`
+        }));
+        const fullOutputPath = result.details?.fullOutputPath;
+        if (fullOutputPath)
+          component.addChild(new Text(theme.fg("muted", `Full output: ${fullOutputPath}`), 0, 0));
+      }
+      return component;
+    },
+    async execute(_toolCallId, params, signal, onUpdate) {
+      const client = await options.getClient();
+      const result = await client.callTool(tool.name, params ?? {}, {
+        signal,
+        timeoutMs: options.timeoutMs,
+        onProgress: (progress) => {
+          const total = progress.total === undefined ? "" : `/${progress.total}`;
+          const text = progress.message ?? `Progress ${progress.progress}${total}`;
+          onUpdate?.({ content: [{ type: "text", text }], details: { server, tool: tool.name } });
+        }
+      });
+      return convertMcpResult(server, tool.name, result, { readableResources: options.readableResources?.() });
+    }
+  };
+}
+
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/mcp/resources.js
+var LIST_MCP_RESOURCES_TOOL = "list_mcp_resources";
+var LIST_MCP_RESOURCE_TEMPLATES_TOOL = "list_mcp_resource_templates";
+function isMcpAppResource(item) {
+  const uri = item.uri ?? item.uriTemplate ?? "";
+  return uri.startsWith("ui://") || /;\s*profile\s*=\s*"?mcp-app"?/i.test(item.mimeType ?? "");
+}
+function listed(server, item) {
+  const { _meta, icons: _icons, ...rest } = item;
+  return { server, ...rest };
+}
+var stringProperty = (description) => ({ type: "string", description });
+var SERVER_FILTER = stringProperty("MCP server name. Omit to list every server with resources.");
+var CURSOR = stringProperty("Opaque cursor from a previous call with the same server; omit for the first page.");
+var LIST_PARAMETERS = {
+  type: "object",
+  properties: { server: SERVER_FILTER, cursor: CURSOR },
+  additionalProperties: false
+};
+var READ_PARAMETERS = {
+  type: "object",
+  properties: {
+    server: stringProperty("MCP server name exactly as configured. Must match the 'server' field returned by list_mcp_resources."),
+    uri: stringProperty("Resource URI to read. Must be one of the URIs returned by list_mcp_resources.")
+  },
+  required: ["server", "uri"],
+  additionalProperties: false
+};
+var optionalString = { type: "string" };
+var LISTING_ERRORS = {
+  type: "array",
+  description: "Servers that could not be listed",
+  items: {
+    type: "object",
+    properties: { server: { type: "string" }, error: { type: "string" } },
+    required: ["server", "error"]
+  }
+};
+var LIST_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    server: optionalString,
+    resources: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          server: { type: "string" },
+          uri: { type: "string" },
+          name: { type: "string" },
+          title: optionalString,
+          description: optionalString,
+          mimeType: optionalString,
+          size: { type: "number" }
+        },
+        required: ["server", "uri", "name"]
+      }
+    },
+    nextCursor: optionalString,
+    errors: LISTING_ERRORS
+  },
+  required: ["resources"]
+};
+var LIST_TEMPLATES_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    server: optionalString,
+    resourceTemplates: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          server: { type: "string" },
+          uriTemplate: { type: "string", description: "RFC 6570 URI template" },
+          name: { type: "string" },
+          title: optionalString,
+          description: optionalString,
+          mimeType: optionalString
+        },
+        required: ["server", "uriTemplate", "name"]
+      }
+    },
+    nextCursor: optionalString,
+    errors: LISTING_ERRORS
+  },
+  required: ["resourceTemplates"]
+};
+var READ_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    server: { type: "string" },
+    uri: { type: "string" },
+    contents: {
+      type: "array",
+      items: {
+        anyOf: [
+          {
+            type: "object",
+            properties: { uri: { type: "string" }, mimeType: optionalString, text: { type: "string" } },
+            required: ["uri", "text"]
+          },
+          {
+            type: "object",
+            properties: {
+              uri: { type: "string" },
+              mimeType: optionalString,
+              blob: { type: "string", description: "base64" }
+            },
+            required: ["uri", "blob"]
+          }
+        ]
+      }
+    }
+  },
+  required: ["server", "uri", "contents"]
+};
+function stringArgument(params, key) {
+  const value = params?.[key];
+  if (value === undefined || value === null)
+    return;
+  if (typeof value !== "string")
+    throw new Error(`${key} must be a string`);
+  return value.trim() || undefined;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function jsonResult(tool, server, payload) {
+  const { content, fullOutputPath } = await limitMcpContent([{ type: "text", text: JSON.stringify(payload) }]);
+  return {
+    content,
+    details: { server: server ?? "", tool, ...fullOutputPath ? { fullOutputPath } : {} },
+    structuredContent: payload
+  };
+}
+function createMcpResourceToolDefinitions(options) {
+  const readOnly = { readOnlyHint: true };
+  const findServer = (name) => {
+    const servers = options.servers();
+    const server = servers.find((candidate) => candidate.name === name);
+    if (server)
+      return server;
+    const available = servers.map((candidate) => candidate.name).join(", ");
+    throw new Error(`MCP server "${name}" has no resources${available ? `. Servers with resources: ${available}` : ""}`);
+  };
+  const list = async (params, signal, key, page, all) => {
+    const serverName = stringArgument(params, "server");
+    const cursor = stringArgument(params, "cursor");
+    const visible = (item) => !isMcpAppResource(item);
+    if (serverName) {
+      const server = findServer(serverName);
+      const result = await page(server, cursor, { signal, timeoutMs: server.timeoutMs });
+      return {
+        server: server.name,
+        [key]: result.items.filter(visible).map((item) => listed(server.name, item)),
+        ...result.nextCursor === undefined ? {} : { nextCursor: result.nextCursor }
+      };
+    }
+    if (cursor)
+      throw new Error("cursor can only be used when a server is specified");
+    const servers = [...options.servers()].sort((a, b) => a.name.localeCompare(b.name));
+    const results = await Promise.allSettled(servers.map((server) => all(server, { signal, timeoutMs: server.timeoutMs })));
+    const items = [];
+    const errors = [];
+    results.forEach((result, index) => {
+      const server = servers[index].name;
+      if (result.status === "fulfilled")
+        items.push(...result.value.filter(visible).map((item) => listed(server, item)));
+      else
+        errors.push({ server, error: errorMessage(result.reason) });
+    });
+    return { [key]: items, ...errors.length > 0 ? { errors } : {} };
+  };
+  const listResources = {
+    name: LIST_MCP_RESOURCES_TOOL,
+    label: LIST_MCP_RESOURCES_TOOL,
+    description: "Lists resources provided by MCP servers. Resources allow servers to share data that provides context to language models, such as files, database schemas, or application-specific information. Prefer resources over web search when possible.",
+    parameters: LIST_PARAMETERS,
+    outputSchema: LIST_OUTPUT_SCHEMA,
+    exposure: toToolExposure(options.exposure),
+    annotations: readOnly,
+    async execute(_toolCallId, params, signal) {
+      const payload = await list(params, signal, "resources", async (server, cursor, requestOptions) => {
+        const result = await server.resourcesPage(cursor, requestOptions);
+        return { items: result.resources, nextCursor: result.nextCursor };
+      }, (server, requestOptions) => server.allResources(requestOptions));
+      return jsonResult(LIST_MCP_RESOURCES_TOOL, stringArgument(params, "server"), payload);
+    }
+  };
+  const listTemplates = {
+    name: LIST_MCP_RESOURCE_TEMPLATES_TOOL,
+    label: LIST_MCP_RESOURCE_TEMPLATES_TOOL,
+    description: "Lists resource templates provided by MCP servers. Parameterized resource templates allow servers to share data that takes parameters and provides context to language models, such as files, database schemas, or application-specific information. Prefer resource templates over web search when possible.",
+    parameters: LIST_PARAMETERS,
+    outputSchema: LIST_TEMPLATES_OUTPUT_SCHEMA,
+    exposure: toToolExposure(options.exposure),
+    annotations: readOnly,
+    async execute(_toolCallId, params, signal) {
+      const payload = await list(params, signal, "resourceTemplates", async (server, cursor, requestOptions) => {
+        const result = await server.resourceTemplatesPage(cursor, requestOptions);
+        return { items: result.resourceTemplates, nextCursor: result.nextCursor };
+      }, (server, requestOptions) => server.allResourceTemplates(requestOptions));
+      return jsonResult(LIST_MCP_RESOURCE_TEMPLATES_TOOL, stringArgument(params, "server"), payload);
+    }
+  };
+  const readResource = {
+    name: READ_MCP_RESOURCE_TOOL,
+    label: READ_MCP_RESOURCE_TOOL,
+    description: "Read a specific resource from an MCP server given the server name and resource URI.",
+    parameters: READ_PARAMETERS,
+    outputSchema: READ_OUTPUT_SCHEMA,
+    exposure: toToolExposure(options.exposure),
+    annotations: readOnly,
+    async execute(_toolCallId, params, signal) {
+      const serverName = stringArgument(params, "server");
+      const uri = stringArgument(params, "uri");
+      if (!serverName)
+        throw new Error("server must be provided");
+      if (!uri)
+        throw new Error("uri must be provided");
+      const server = findServer(serverName);
+      const result = await server.readResource(uri, { signal, timeoutMs: server.timeoutMs });
+      const blocks = result.contents.flatMap((contents2) => [
+        ...result.contents.length > 1 ? [{ type: "text", text: `${contents2.uri}:` }] : [],
+        { type: "resource", resource: contents2 }
+      ]);
+      const converted = await toModelContent(server.name, blocks);
+      const { content, fullOutputPath } = await limitMcpContent(converted.length > 0 ? converted : [{ type: "text", text: `Resource ${uri} is empty.` }]);
+      const contents = result.contents.map(({ _meta: _ignored, ...rest }) => rest);
+      return {
+        content,
+        details: {
+          server: server.name,
+          tool: READ_MCP_RESOURCE_TOOL,
+          ...fullOutputPath ? { fullOutputPath } : {}
+        },
+        structuredContent: { server: server.name, uri, contents }
+      };
+    }
+  };
+  return [listResources, listTemplates, readResource];
+}
+
+// node_modules/@earendil-works/pi-coding-agent/dist/utils/abort.js
+function abortReason(signal) {
+  if (signal.reason !== undefined)
+    return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+function operationSignal(signal) {
+  return signal ?? new AbortController().signal;
+}
+function raceWithAbortSignal(operation, signal) {
+  if (!signal)
+    return operation;
+  if (signal.aborted) {
+    operation.catch(() => {});
+    return Promise.reject(abortReason(signal));
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(abortReason(signal));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then((value) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve(value);
+    }, (error) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(error);
+    });
+    if (signal.aborted)
+      onAbort();
+  });
+}
+
+// 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 as join2 } from "path";
+import { setTimeout as sleep } from "timers/promises";
+var AUTH_FILE_WRITE_OPTIONS = { encoding: "utf-8", mode: 384 };
+var sharedAuthFileReadState;
+
+class FileAuthStorageBackend {
+  authPath;
+  constructor(authPath = join2(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;
+    let lastError;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      try {
+        return import_proper_lockfile.default.lockSync(path, { realpath: false });
+      } catch (error) {
+        const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : undefined;
+        if (code !== "ELOCKED" || attempt === maxAttempts) {
+          throw error;
+        }
+        lastError = error;
+        const start = Date.now();
+        while (Date.now() - start < delayMs) {}
+      }
+    }
+    throw lastError ?? new Error("Failed to acquire auth storage lock");
+  }
+  withLock(fn) {
+    this.ensureParentDir();
+    this.ensureFileExists();
+    let release;
+    try {
+      release = this.acquireLockSyncWithRetry(this.authPath);
+      const current = existsSync(this.authPath) ? readFileSync(this.authPath, "utf-8") : undefined;
+      const { result, next } = fn(current);
+      if (next !== undefined) {
+        writeFileSync(this.authPath, next, AUTH_FILE_WRITE_OPTIONS);
+      }
+      return result;
+    } finally {
+      if (release) {
+        release();
+      }
+    }
+  }
+  async acquireLockAsync(signal, onCompromised) {
+    const staleMs = 30000;
+    const maxDelayMs = 2000;
+    const deadline = Date.now() + staleMs;
+    let retry = 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 = typeof error === "object" && error !== null && "code" in error ? String(error.code) : undefined;
+        const remainingMs = deadline - Date.now();
+        if (code !== "ELOCKED" || remainingMs <= 0)
+          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, undefined, { 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 = () => {
+      if (lockCompromised) {
+        throw lockCompromisedError ?? new Error("Auth storage lock was compromised");
+      }
+    };
+    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") : undefined;
+      const { result, next } = await fn(current);
+      throwIfCompromised();
+      options?.signal?.throwIfAborted();
+      if (next !== undefined) {
+        writeFileSync(this.authPath, next, AUTH_FILE_WRITE_OPTIONS);
+      }
+      throwIfCompromised();
+      return result;
+    } finally {
+      if (release) {
+        try {
+          await release();
+        } catch {}
+      }
+    }
+  }
+}
+
+class ReadOnlyAuthStorage {
+  authPath;
+  data;
+  constructor(authPath = join2(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 === undefined || typeof value.key === "string";
+        const validEnv = value.env === undefined || 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;
+    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");
+  }
+}
+
+class InMemoryAuthStorageBackend {
+  value;
+  asyncChain = Promise.resolve();
+  withLock(fn) {
+    const { result, next } = fn(this.value);
+    if (next !== undefined) {
+      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 !== undefined) {
+        this.value = next;
+      }
+      return result;
+    })();
+    this.asyncChain = operation.catch(() => {});
+    return raceWithAbortSignal(operation, options?.signal);
+  }
+}
+
+class 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 !== undefined && revision === this.readState.revision)
+        return;
+    }
+    this.reload();
+  }
+  static create(authPath = join2(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: undefined, 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() {
+    let content;
+    let revision;
+    try {
+      this.storage.withLock((current) => {
+        content = current;
+        revision = this.authPath ? getFileRevision(this.authPath) : undefined;
+        return { result: undefined };
+      });
+      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) : undefined;
+      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 !== undefined && 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;
+      reload2.promise.then(() => {
+        if (this.readState.reload === reload2)
+          this.readState.reload = undefined;
+      }, () => {
+        if (this.readState.reload === reload2)
+          this.readState.reload = undefined;
+      });
+    }
+    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 = undefined;
+        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 === undefined)
+      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 === undefined) {
+        latestData = currentData;
+        revision = this.authPath ? getFileRevision(this.authPath) : undefined;
+        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: undefined, next: JSON.stringify(currentData, null, 2) };
+    }, options);
+    this.updateReadState(latestData);
+  }
+  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 = join2(getAgentDir(), "auth.json")) {
+  try {
+    const data = JSON.parse(stripBom(readFileSync(normalizePath(authPath), "utf-8")));
+    return data[providerId];
+  } catch {
+    return;
+  }
+}
+
+export { DEFAULT_MAX_LINES, DEFAULT_MAX_BYTES, GREP_MAX_LINE_LENGTH, formatSize, truncateHead, truncateTail, truncateLine, getConfigValueEnvVarNames, isCommandConfigValue, isConfigValueConfigured, resolveConfigValueOrThrow, resolveHeadersOrThrow, require_proper_lockfile, operationSignal, raceWithAbortSignal, FileAuthStorageBackend, ReadOnlyAuthStorage, AuthStorage, readStoredCredential, JSON_RPC_ERROR_CODES, McpError, isObject, LATEST_PROTOCOL_VERSION, McpClient, StdioTransport, McpHttpError, McpAuthRequiredError, McpSessionExpiredError, StreamableHttpTransport, READ_MCP_RESOURCE_TOOL, createMcpToolName, createMcpToolDefinition, LIST_MCP_RESOURCES_TOOL, LIST_MCP_RESOURCE_TEMPLATES_TOOL, isMcpAppResource, createMcpResourceToolDefinitions };