remotelink 0.4.3 → 0.4.5

package/dist/index.js

@@ -32,6 +32,1591 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module) {
+    "use strict";
+    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(fs8) {
+      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        patchLchmod(fs8);
+      }
+      if (!fs8.lutimes) {
+        patchLutimes(fs8);
+      }
+      fs8.chown = chownFix(fs8.chown);
+      fs8.fchown = chownFix(fs8.fchown);
+      fs8.lchown = chownFix(fs8.lchown);
+      fs8.chmod = chmodFix(fs8.chmod);
+      fs8.fchmod = chmodFix(fs8.fchmod);
+      fs8.lchmod = chmodFix(fs8.lchmod);
+      fs8.chownSync = chownFixSync(fs8.chownSync);
+      fs8.fchownSync = chownFixSync(fs8.fchownSync);
+      fs8.lchownSync = chownFixSync(fs8.lchownSync);
+      fs8.chmodSync = chmodFixSync(fs8.chmodSync);
+      fs8.fchmodSync = chmodFixSync(fs8.fchmodSync);
+      fs8.lchmodSync = chmodFixSync(fs8.lchmodSync);
+      fs8.stat = statFix(fs8.stat);
+      fs8.fstat = statFix(fs8.fstat);
+      fs8.lstat = statFix(fs8.lstat);
+      fs8.statSync = statFixSync(fs8.statSync);
+      fs8.fstatSync = statFixSync(fs8.fstatSync);
+      fs8.lstatSync = statFixSync(fs8.lstatSync);
+      if (fs8.chmod && !fs8.lchmod) {
+        fs8.lchmod = function(path8, mode, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs8.lchmodSync = function() {
+        };
+      }
+      if (fs8.chown && !fs8.lchown) {
+        fs8.lchown = function(path8, uid, gid, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs8.lchownSync = function() {
+        };
+      }
+      if (platform === "win32") {
+        fs8.rename = typeof fs8.rename !== "function" ? fs8.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 < 6e4) {
+                setTimeout(function() {
+                  fs8.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;
+        })(fs8.rename);
+      }
+      fs8.read = typeof fs8.read !== "function" ? fs8.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(fs8, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs8, fd, buffer, offset, length, position, callback);
+        }
+        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+        return read;
+      })(fs8.read);
+      fs8.readSync = typeof fs8.readSync !== "function" ? fs8.readSync : /* @__PURE__ */ (function(fs$readSync) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs8, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      })(fs8.readSync);
+      function patchLchmod(fs9) {
+        fs9.lchmod = function(path8, mode, callback) {
+          fs9.open(
+            path8,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback) callback(err);
+                return;
+              }
+              fs9.fchmod(fd, mode, function(err2) {
+                fs9.close(fd, function(err22) {
+                  if (callback) callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs9.lchmodSync = function(path8, mode) {
+          var fd = fs9.openSync(path8, constants.O_WRONLY | constants.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs9.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs9.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs9.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      function patchLutimes(fs9) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs9.futimes) {
+          fs9.lutimes = function(path8, at, mt, cb) {
+            fs9.open(path8, constants.O_SYMLINK, function(er, fd) {
+              if (er) {
+                if (cb) cb(er);
+                return;
+              }
+              fs9.futimes(fd, at, mt, function(er2) {
+                fs9.close(fd, function(er22) {
+                  if (cb) cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs9.lutimesSync = function(path8, at, mt) {
+            var fd = fs9.openSync(path8, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs9.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs9.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs9.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs9.futimes) {
+          fs9.lutimes = function(_a, _b, _c, cb) {
+            if (cb) process.nextTick(cb);
+          };
+          fs9.lutimesSync = function() {
+          };
+        }
+      }
+      function chmodFix(orig) {
+        if (!orig) return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs8, 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(fs8, 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(fs8, 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(fs8, 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(fs8, target, options, callback) : orig.call(fs8, target, callback);
+        };
+      }
+      function statFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, options) {
+          var stats = options ? orig.call(fs8, target, options) : orig.call(fs8, 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/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports, module) {
+    "use strict";
+    var Stream = __require("stream").Stream;
+    module.exports = legacy;
+    function legacy(fs8) {
+      return {
+        ReadStream,
+        WriteStream
+      };
+      function ReadStream(path8, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path8, options);
+        Stream.call(this);
+        var self = this;
+        this.path = path8;
+        this.fd = null;
+        this.readable = true;
+        this.paused = false;
+        this.flags = "r";
+        this.mode = 438;
+        this.bufferSize = 64 * 1024;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.encoding) this.setEncoding(this.encoding);
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.end === void 0) {
+            this.end = Infinity;
+          } else if ("number" !== typeof this.end) {
+            throw TypeError("end must be a Number");
+          }
+          if (this.start > this.end) {
+            throw new Error("start must be <= end");
+          }
+          this.pos = this.start;
+        }
+        if (this.fd !== null) {
+          process.nextTick(function() {
+            self._read();
+          });
+          return;
+        }
+        fs8.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(path8, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path8, options);
+        Stream.call(this);
+        this.path = path8;
+        this.fd = null;
+        this.writable = true;
+        this.flags = "w";
+        this.encoding = "binary";
+        this.mode = 438;
+        this.bytesWritten = 0;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.start < 0) {
+            throw new Error("start must be >= zero");
+          }
+          this.pos = this.start;
+        }
+        this.busy = false;
+        this._queue = [];
+        if (this.fd === null) {
+          this._open = fs8.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
+var require_clone = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js"(exports, module) {
+    "use strict";
+    module.exports = clone;
+    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module) {
+    "use strict";
+    var fs8 = __require("fs");
+    var polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone = require_clone();
+    var util = __require("util");
+    var gracefulQueue;
+    var previousSymbol;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+      gracefulQueue = /* @__PURE__ */ Symbol.for("graceful-fs.queue");
+      previousSymbol = /* @__PURE__ */ Symbol.for("graceful-fs.previous");
+    } else {
+      gracefulQueue = "___graceful-fs.queue";
+      previousSymbol = "___graceful-fs.previous";
+    }
+    function noop() {
+    }
+    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("\nGFS4: ");
+        console.error(m);
+      };
+    if (!fs8[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs8, queue);
+      fs8.close = (function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs8, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      })(fs8.close);
+      fs8.closeSync = (function(fs$closeSync) {
+        function closeSync2(fd) {
+          fs$closeSync.apply(fs8, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync2, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync2;
+      })(fs8.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug(fs8[gracefulQueue]);
+          __require("assert").equal(fs8[gracefulQueue].length, 0);
+        });
+      }
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      publishQueue(global, fs8[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs8));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs8.__patched) {
+      module.exports = patch(fs8);
+      fs8.__patched = true;
+    }
+    function patch(fs9) {
+      polyfills(fs9);
+      fs9.gracefulify = patch;
+      fs9.createReadStream = createReadStream2;
+      fs9.createWriteStream = createWriteStream;
+      var fs$readFile = fs9.readFile;
+      fs9.readFile = readFile;
+      function readFile(path8, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$readFile(path8, options, cb);
+        function go$readFile(path9, options2, cb2, startTime) {
+          return fs$readFile(path9, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$readFile, [path9, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$writeFile = fs9.writeFile;
+      fs9.writeFile = writeFile;
+      function writeFile(path8, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$writeFile(path8, data, options, cb);
+        function go$writeFile(path9, data2, options2, cb2, startTime) {
+          return fs$writeFile(path9, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$writeFile, [path9, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$appendFile = fs9.appendFile;
+      if (fs$appendFile)
+        fs9.appendFile = appendFile;
+      function appendFile(path8, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$appendFile(path8, data, options, cb);
+        function go$appendFile(path9, data2, options2, cb2, startTime) {
+          return fs$appendFile(path9, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$appendFile, [path9, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$copyFile = fs9.copyFile;
+      if (fs$copyFile)
+        fs9.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 = fs9.readdir;
+      fs9.readdir = readdir;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir(path8, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path9, options2, cb2, startTime) {
+          return fs$readdir(path9, fs$readdirCallback(
+            path9,
+            options2,
+            cb2,
+            startTime
+          ));
+        } : function go$readdir2(path9, options2, cb2, startTime) {
+          return fs$readdir(path9, options2, fs$readdirCallback(
+            path9,
+            options2,
+            cb2,
+            startTime
+          ));
+        };
+        return go$readdir(path8, options, cb);
+        function fs$readdirCallback(path9, options2, cb2, startTime) {
+          return function(err, files) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([
+                go$readdir,
+                [path9, 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(fs9);
+        ReadStream = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs9.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs9.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs9, "ReadStream", {
+        get: function() {
+          return ReadStream;
+        },
+        set: function(val) {
+          ReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs9, "WriteStream", {
+        get: function() {
+          return WriteStream;
+        },
+        set: function(val) {
+          WriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream;
+      Object.defineProperty(fs9, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs9, "FileWriteStream", {
+        get: function() {
+          return FileWriteStream;
+        },
+        set: function(val) {
+          FileWriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream(path8, 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(path8, 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 createReadStream2(path8, options) {
+        return new fs9.ReadStream(path8, options);
+      }
+      function createWriteStream(path8, options) {
+        return new fs9.WriteStream(path8, options);
+      }
+      var fs$open = fs9.open;
+      fs9.open = open;
+      function open(path8, flags, mode, cb) {
+        if (typeof mode === "function")
+          cb = mode, mode = null;
+        return go$open(path8, flags, mode, cb);
+        function go$open(path9, flags2, mode2, cb2, startTime) {
+          return fs$open(path9, flags2, mode2, function(err, fd) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$open, [path9, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      return fs9;
+    }
+    function enqueue(elem) {
+      debug("ENQUEUE", elem[0].name, elem[1]);
+      fs8[gracefulQueue].push(elem);
+      retry();
+    }
+    var retryTimer;
+    function resetQueue() {
+      var now = Date.now();
+      for (var i = 0; i < fs8[gracefulQueue].length; ++i) {
+        if (fs8[gracefulQueue][i].length > 2) {
+          fs8[gracefulQueue][i][3] = now;
+          fs8[gracefulQueue][i][4] = now;
+        }
+      }
+      retry();
+    }
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs8[gracefulQueue].length === 0)
+        return;
+      var elem = fs8[gracefulQueue].shift();
+      var fn = elem[0];
+      var args = elem[1];
+      var err = elem[2];
+      var startTime = elem[3];
+      var lastTime = elem[4];
+      if (startTime === void 0) {
+        debug("RETRY", fn.name, args);
+        fn.apply(null, args);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug("TIMEOUT", fn.name, args);
+        var cb = args.pop();
+        if (typeof cb === "function")
+          cb.call(null, err);
+      } else {
+        var sinceAttempt = Date.now() - lastTime;
+        var sinceStart = Math.max(lastTime - startTime, 1);
+        var desiredDelay = Math.min(sinceStart * 1.2, 100);
+        if (sinceAttempt >= desiredDelay) {
+          debug("RETRY", fn.name, args);
+          fn.apply(null, args.concat([startTime]));
+        } else {
+          fs8[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS({
+  "../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry_operation.js"(exports, module) {
+    "use strict";
+    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 = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout = this._timeouts.shift();
+      if (timeout === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(this._errors.length - 1, this._errors.length);
+          this._timeouts = this._cachedTimeouts.slice(0);
+          timeout = this._timeouts.shift();
+        } else {
+          return false;
+        }
+      }
+      var self = this;
+      var timer = setTimeout(function() {
+        self._attempts++;
+        if (self._operationTimeoutCb) {
+          self._timeout = setTimeout(function() {
+            self._operationTimeoutCb(self._attempts);
+          }, self._operationTimeout);
+          if (self._options.unref) {
+            self._timeout.unref();
+          }
+        }
+        self._fn(self._attempts);
+      }, timeout);
+      if (this._options.unref) {
+        timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self._operationTimeoutCb();
+        }, self._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry.js
+var require_retry = __commonJS({
+  "../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry.js"(exports) {
+    "use strict";
+    var RetryOperation = require_retry_operation();
+    exports.operation = function(options) {
+      var timeouts = exports.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && options.forever,
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a, b) {
+        return a - b;
+      });
+      return timeouts;
+    };
+    exports.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
+          }
+        }
+      }
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = 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/.pnpm/retry@0.12.0/node_modules/retry/index.js
+var require_retry2 = __commonJS({
+  "../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_retry();
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
+var require_signals = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports, module) {
+    "use strict";
+    module.exports = [
+      "SIGABRT",
+      "SIGALRM",
+      "SIGHUP",
+      "SIGINT",
+      "SIGTERM"
+    ];
+    if (process.platform !== "win32") {
+      module.exports.push(
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (process.platform === "linux") {
+      module.exports.push(
+        "SIGIO",
+        "SIGPOLL",
+        "SIGPWR",
+        "SIGSTKFLT",
+        "SIGUNUSED"
+      );
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
+var require_signal_exit = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports, module) {
+    "use strict";
+    var process4 = global.process;
+    var processOk = function(process5) {
+      return process5 && typeof process5 === "object" && typeof process5.removeListener === "function" && typeof process5.emit === "function" && typeof process5.reallyExit === "function" && typeof process5.listeners === "function" && typeof process5.kill === "function" && typeof process5.pid === "number" && typeof process5.on === "function";
+    };
+    if (!processOk(process4)) {
+      module.exports = function() {
+        return function() {
+        };
+      };
+    } else {
+      assert = __require("assert");
+      signals = require_signals();
+      isWin = /^win/i.test(process4.platform);
+      EE = __require("events");
+      if (typeof EE !== "function") {
+        EE = EE.EventEmitter;
+      }
+      if (process4.__signal_exit_emitter__) {
+        emitter = process4.__signal_exit_emitter__;
+      } else {
+        emitter = process4.__signal_exit_emitter__ = new EE();
+        emitter.count = 0;
+        emitter.emitted = {};
+      }
+      if (!emitter.infinite) {
+        emitter.setMaxListeners(Infinity);
+        emitter.infinite = true;
+      }
+      module.exports = function(cb, opts) {
+        if (!processOk(global.process)) {
+          return function() {
+          };
+        }
+        assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
+        if (loaded === false) {
+          load();
+        }
+        var ev = "exit";
+        if (opts && opts.alwaysLast) {
+          ev = "afterexit";
+        }
+        var remove = function() {
+          emitter.removeListener(ev, cb);
+          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+            unload();
+          }
+        };
+        emitter.on(ev, cb);
+        return remove;
+      };
+      unload = function unload2() {
+        if (!loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = false;
+        signals.forEach(function(sig) {
+          try {
+            process4.removeListener(sig, sigListeners[sig]);
+          } catch (er) {
+          }
+        });
+        process4.emit = originalProcessEmit;
+        process4.reallyExit = originalProcessReallyExit;
+        emitter.count -= 1;
+      };
+      module.exports.unload = unload;
+      emit = function emit2(event, code, signal) {
+        if (emitter.emitted[event]) {
+          return;
+        }
+        emitter.emitted[event] = true;
+        emitter.emit(event, code, signal);
+      };
+      sigListeners = {};
+      signals.forEach(function(sig) {
+        sigListeners[sig] = function listener() {
+          if (!processOk(global.process)) {
+            return;
+          }
+          var listeners = process4.listeners(sig);
+          if (listeners.length === emitter.count) {
+            unload();
+            emit("exit", null, sig);
+            emit("afterexit", null, sig);
+            if (isWin && sig === "SIGHUP") {
+              sig = "SIGINT";
+            }
+            process4.kill(process4.pid, sig);
+          }
+        };
+      });
+      module.exports.signals = function() {
+        return signals;
+      };
+      loaded = false;
+      load = function load2() {
+        if (loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = true;
+        emitter.count += 1;
+        signals = signals.filter(function(sig) {
+          try {
+            process4.on(sig, sigListeners[sig]);
+            return true;
+          } catch (er) {
+            return false;
+          }
+        });
+        process4.emit = processEmit;
+        process4.reallyExit = processReallyExit;
+      };
+      module.exports.load = load;
+      originalProcessReallyExit = process4.reallyExit;
+      processReallyExit = function processReallyExit2(code) {
+        if (!processOk(global.process)) {
+          return;
+        }
+        process4.exitCode = code || /* istanbul ignore next */
+        0;
+        emit("exit", process4.exitCode, null);
+        emit("afterexit", process4.exitCode, null);
+        originalProcessReallyExit.call(process4, process4.exitCode);
+      };
+      originalProcessEmit = process4.emit;
+      processEmit = function processEmit2(ev, arg) {
+        if (ev === "exit" && processOk(global.process)) {
+          if (arg !== void 0) {
+            process4.exitCode = arg;
+          }
+          var ret = originalProcessEmit.apply(this, arguments);
+          emit("exit", process4.exitCode, null);
+          emit("afterexit", process4.exitCode, null);
+          return ret;
+        } else {
+          return originalProcessEmit.apply(this, arguments);
+        }
+      };
+    }
+    var assert;
+    var signals;
+    var isWin;
+    var EE;
+    var emitter;
+    var unload;
+    var emit;
+    var sigListeners;
+    var loaded;
+    var load;
+    var originalProcessReallyExit;
+    var processReallyExit;
+    var originalProcessEmit;
+    var processEmit;
+  }
+});
+
+// ../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/mtime-precision.js
+var require_mtime_precision = __commonJS({
+  "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/mtime-precision.js"(exports, module) {
+    "use strict";
+    var cacheSymbol = /* @__PURE__ */ Symbol();
+    function probe(file, fs8, callback) {
+      const cachedPrecision = fs8[cacheSymbol];
+      if (cachedPrecision) {
+        return fs8.stat(file, (err, stat) => {
+          if (err) {
+            return callback(err);
+          }
+          callback(null, stat.mtime, cachedPrecision);
+        });
+      }
+      const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
+      fs8.utimes(file, mtime, mtime, (err) => {
+        if (err) {
+          return callback(err);
+        }
+        fs8.stat(file, (err2, stat) => {
+          if (err2) {
+            return callback(err2);
+          }
+          const precision = stat.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
+          Object.defineProperty(fs8, cacheSymbol, { value: precision });
+          callback(null, stat.mtime, precision);
+        });
+      });
+    }
+    function getMtime(precision) {
+      let now = Date.now();
+      if (precision === "s") {
+        now = Math.ceil(now / 1e3) * 1e3;
+      }
+      return new Date(now);
+    }
+    module.exports.probe = probe;
+    module.exports.getMtime = getMtime;
+  }
+});
+
+// ../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js
+var require_lockfile = __commonJS({
+  "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js"(exports, module) {
+    "use strict";
+    var path8 = __require("path");
+    var fs8 = require_graceful_fs();
+    var retry = require_retry2();
+    var onExit = require_signal_exit();
+    var mtimePrecision = require_mtime_precision();
+    var locks = {};
+    function getLockFile(file, options) {
+      return options.lockfilePath || `${file}.lock`;
+    }
+    function resolveCanonicalPath(file, options, callback) {
+      if (!options.realpath) {
+        return callback(null, path8.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 lock3 = locks[file];
+      if (lock3.updateTimeout) {
+        return;
+      }
+      lock3.updateDelay = lock3.updateDelay || options.update;
+      lock3.updateTimeout = setTimeout(() => {
+        lock3.updateTimeout = null;
+        options.fs.stat(lock3.lockfilePath, (err, stat) => {
+          const isOverThreshold = lock3.lastUpdate + options.stale < Date.now();
+          if (err) {
+            if (err.code === "ENOENT" || isOverThreshold) {
+              return setLockAsCompromised(file, lock3, Object.assign(err, { code: "ECOMPROMISED" }));
+            }
+            lock3.updateDelay = 1e3;
+            return updateLock(file, options);
+          }
+          const isMtimeOurs = lock3.mtime.getTime() === stat.mtime.getTime();
+          if (!isMtimeOurs) {
+            return setLockAsCompromised(
+              file,
+              lock3,
+              Object.assign(
+                new Error("Unable to update lock within the stale threshold"),
+                { code: "ECOMPROMISED" }
+              )
+            );
+          }
+          const mtime = mtimePrecision.getMtime(lock3.mtimePrecision);
+          options.fs.utimes(lock3.lockfilePath, mtime, mtime, (err2) => {
+            const isOverThreshold2 = lock3.lastUpdate + options.stale < Date.now();
+            if (lock3.released) {
+              return;
+            }
+            if (err2) {
+              if (err2.code === "ENOENT" || isOverThreshold2) {
+                return setLockAsCompromised(file, lock3, Object.assign(err2, { code: "ECOMPROMISED" }));
+              }
+              lock3.updateDelay = 1e3;
+              return updateLock(file, options);
+            }
+            lock3.mtime = mtime;
+            lock3.lastUpdate = Date.now();
+            lock3.updateDelay = null;
+            updateLock(file, options);
+          });
+        });
+      }, lock3.updateDelay);
+      if (lock3.updateTimeout.unref) {
+        lock3.updateTimeout.unref();
+      }
+    }
+    function setLockAsCompromised(file, lock3, err) {
+      lock3.released = true;
+      if (lock3.updateTimeout) {
+        clearTimeout(lock3.updateTimeout);
+      }
+      if (locks[file] === lock3) {
+        delete locks[file];
+      }
+      lock3.options.onCompromised(err);
+    }
+    function lock2(file, options, callback) {
+      options = {
+        stale: 1e4,
+        update: null,
+        realpath: true,
+        retries: 0,
+        fs: fs8,
+        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, 2e3);
+      options.update = options.update == null ? options.stale / 2 : options.update || 0;
+      options.update = Math.max(Math.min(options.update, options.stale / 2), 1e3);
+      resolveCanonicalPath(file, options, (err, file2) => {
+        if (err) {
+          return callback(err);
+        }
+        const operation = retry.operation(options.retries);
+        operation.attempt(() => {
+          acquireLock(file2, options, (err2, mtime, mtimePrecision2) => {
+            if (operation.retry(err2)) {
+              return;
+            }
+            if (err2) {
+              return callback(operation.mainError());
+            }
+            const lock3 = locks[file2] = {
+              lockfilePath: getLockFile(file2, options),
+              mtime,
+              mtimePrecision: mtimePrecision2,
+              options,
+              lastUpdate: Date.now()
+            };
+            updateLock(file2, options);
+            callback(null, (releasedCallback) => {
+              if (lock3.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: fs8,
+        realpath: true,
+        ...options
+      };
+      resolveCanonicalPath(file, options, (err, file2) => {
+        if (err) {
+          return callback(err);
+        }
+        const lock3 = locks[file2];
+        if (!lock3) {
+          return callback(Object.assign(new Error("Lock is not acquired/owned by you"), { code: "ENOTACQUIRED" }));
+        }
+        lock3.updateTimeout && clearTimeout(lock3.updateTimeout);
+        lock3.released = true;
+        delete locks[file2];
+        removeLock(file2, options, callback);
+      });
+    }
+    function check2(file, options, callback) {
+      options = {
+        stale: 1e4,
+        realpath: true,
+        fs: fs8,
+        ...options
+      };
+      options.stale = Math.max(options.stale || 0, 2e3);
+      resolveCanonicalPath(file, options, (err, file2) => {
+        if (err) {
+          return callback(err);
+        }
+        options.fs.stat(getLockFile(file2, options), (err2, stat) => {
+          if (err2) {
+            return err2.code === "ENOENT" ? callback(null, false) : callback(err2);
+          }
+          return callback(null, !isLockStale(stat, options));
+        });
+      });
+    }
+    function getLocks() {
+      return locks;
+    }
+    onExit(() => {
+      for (const file in locks) {
+        const options = locks[file].options;
+        try {
+          options.fs.rmdirSync(getLockFile(file, options));
+        } catch (e) {
+        }
+      }
+    });
+    module.exports.lock = lock2;
+    module.exports.unlock = unlock;
+    module.exports.check = check2;
+    module.exports.getLocks = getLocks;
+  }
+});
+
+// ../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/adapter.js
+var require_adapter = __commonJS({
+  "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/adapter.js"(exports, module) {
+    "use strict";
+    var fs8 = require_graceful_fs();
+    function createSyncFs(fs9) {
+      const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
+      const newFs = { ...fs9 };
+      methods.forEach((method) => {
+        newFs[method] = (...args) => {
+          const callback = args.pop();
+          let ret;
+          try {
+            ret = fs9[`${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 || fs8);
+      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/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/index.js
+var require_proper_lockfile = __commonJS({
+  "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/index.js"(exports, module) {
+    "use strict";
+    var lockfile = require_lockfile();
+    var { toPromise, toSync, toSyncOptions } = require_adapter();
+    async function lock2(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 check2(file, options) {
+      return toPromise(lockfile.check)(file, options);
+    }
+    function checkSync(file, options) {
+      return toSync(lockfile.check)(file, toSyncOptions(options));
+    }
+    module.exports = lock2;
+    module.exports.lock = lock2;
+    module.exports.unlock = unlock;
+    module.exports.lockSync = lockSync;
+    module.exports.unlockSync = unlockSync;
+    module.exports.check = check2;
+    module.exports.checkSync = checkSync;
+  }
+});
+
 // ../../node_modules/.pnpm/ws@8.21.3/node_modules/ws/lib/constants.js
 var require_constants = __commonJS({
   "../../node_modules/.pnpm/ws@8.21.3/node_modules/ws/lib/constants.js"(exports, module) {
@@ -5247,11 +6832,111 @@ async function goalWorkspace(args, policy = {}) {
   }
 }
 
+// src/agent-runtime.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import fs5 from "fs/promises";
+import { appendFileSync, mkdirSync, renameSync, statSync, openSync, closeSync } from "fs";
+import path5 from "path";
+import { spawn as spawn3 } from "child_process";
+var AGENT_LEASE_STALE_MS = 15e3;
+async function agentLeaseActive(directory) {
+  return (0, import_proper_lockfile.check)(path5.join(directory, "execution"), {
+    realpath: false,
+    stale: AGENT_LEASE_STALE_MS
+  });
+}
+async function tryAgentLease(directory, role = "execution") {
+  await fs5.mkdir(directory, { recursive: true, mode: 448 });
+  try {
+    return await (0, import_proper_lockfile.lock)(path5.join(directory, role), {
+      realpath: false,
+      stale: AGENT_LEASE_STALE_MS,
+      update: 3e3,
+      retries: 0
+    });
+  } catch (error) {
+    if (error.code === "ELOCKED") return null;
+    throw error;
+  }
+}
+function appendAgentEvent(directory, line) {
+  try {
+    mkdirSync(directory, { recursive: true, mode: 448 });
+    const file = path5.join(directory, "events.log");
+    if ((statSync(file, { throwIfNoEntry: false })?.size ?? 0) > 5 * 1024 * 1024) {
+      renameSync(file, file + ".1");
+    }
+    appendFileSync(file, line.replace(/\x1b\[[0-9;]*m/g, ""), { mode: 384 });
+  } catch {
+  }
+}
+async function readAgentEvents(directory, cursor) {
+  const file = path5.join(directory, "events.log");
+  let handle;
+  try {
+    handle = await fs5.open(file, "r");
+    const size = (await handle.stat()).size;
+    const start = cursor === null ? Math.max(0, size - 16384) : cursor > size ? 0 : cursor;
+    const buffer = Buffer.alloc(Math.min(size - start, 64 * 1024));
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
+    const content = buffer.subarray(0, bytesRead).toString("utf8");
+    return {
+      cursor: start + bytesRead,
+      text: cursor === null ? content.split("\n").slice(-21).join("\n") : content
+    };
+  } catch {
+    return { cursor, text: "" };
+  } finally {
+    await handle?.close();
+  }
+}
+async function superviseAgent(options) {
+  let delay = options.delayMs ?? 1e3;
+  while (!options.signal.aborted && await options.enabled()) {
+    const startedAt = Date.now();
+    const child = options.start();
+    const abort = () => child.kill();
+    options.signal.addEventListener("abort", abort, { once: true });
+    await new Promise((resolve) => {
+      child.once("error", () => resolve());
+      child.once("close", () => resolve());
+      if (options.signal.aborted) abort();
+    });
+    options.signal.removeEventListener("abort", abort);
+    if (options.signal.aborted || !await options.enabled()) break;
+    await new Promise((resolve) => {
+      const finish = () => {
+        clearTimeout(timer);
+        options.signal.removeEventListener("abort", finish);
+        resolve();
+      };
+      const timer = setTimeout(finish, delay);
+      options.signal.addEventListener("abort", finish, { once: true });
+      if (options.signal.aborted) finish();
+    });
+    delay = Date.now() - startedAt > 6e4 ? options.delayMs ?? 1e3 : Math.min(delay * 2, 3e4);
+  }
+}
+function startSupervisedAgent(node, bundle, logs) {
+  if (!logs) return spawn3(node, [bundle, "--agent"], { stdio: "inherit", windowsHide: true });
+  mkdirSync(logs, { recursive: true, mode: 448 });
+  const out = openSync(path5.join(logs, "agent.log"), "a", 384);
+  let err;
+  try {
+    err = openSync(path5.join(logs, "agent-error.log"), "a", 384);
+    return spawn3(node, [bundle, "--agent"], { stdio: ["ignore", out, err], windowsHide: true });
+  } finally {
+    closeSync(out);
+    if (err !== void 0) closeSync(err);
+  }
+}
+
 // src/index.ts
 import os4 from "os";
-import path6 from "path";
-import fs6 from "fs/promises";
-import { spawn as spawn4 } from "child_process";
+import path7 from "path";
+import fs7 from "fs/promises";
+import { spawn as spawn5 } from "child_process";
+import { randomUUID } from "crypto";
 import process3 from "process";
 import { createInterface } from "readline/promises";
 import { fileURLToPath } from "url";
@@ -5269,26 +6954,43 @@ var wrapper_default = import_websocket.default;
 
 // src/background.ts
 import os3 from "os";
-import path5 from "path";
-import fs5 from "fs/promises";
-import { spawn as spawn3 } from "child_process";
-var CONFIG_DIR = path5.join(os3.homedir(), ".remotearc");
-var AGENT_DIR = path5.join(CONFIG_DIR, "agent");
-var LOG_DIR = path5.join(CONFIG_DIR, "logs");
-var AGENT_BUNDLE = path5.join(AGENT_DIR, "remotelink.mjs");
-var AGENT_VERSION_FILE = path5.join(AGENT_DIR, "version");
-var MAC_LABEL = "app.remotearc.agent";
-var WINDOWS_RUN_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
-var WINDOWS_RUN_VALUE = "Remote Arc Agent";
-var LINUX_UNIT = "remotearc-agent.service";
+import path6 from "path";
+import fs6 from "fs/promises";
+import { spawn as spawn4 } from "child_process";
+var LegacyBackgroundAgentError = class extends Error {
+};
+function parseReleaseVersion(value) {
+  if (!value) return null;
+  const match = value.trim().match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function isOlderRelease(current, target) {
+  const a = parseReleaseVersion(current);
+  const b = parseReleaseVersion(target);
+  if (!a || !b) return false;
+  if (a[0] !== b[0]) return a[0] < b[0];
+  if (a[1] !== b[1]) return a[1] < b[1];
+  return a[2] < b[2];
+}
+function windowsSupervisorLaunchScript(node, bundle) {
+  const quote = (value) => "'" + value.replaceAll("'", "''") + "'";
+  return "Start-Process -FilePath " + quote(node) + " -ArgumentList " + quote('"' + bundle + '" --supervise') + " -WindowStyle Hidden | Out-Null";
+}
 async function run2(command, args, options = {}) {
   return new Promise((resolve, reject) => {
-    const child = spawn3(command, args, {
+    const child = spawn4(command, args, {
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true
     });
     let stdout = "";
     let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill();
+      const detail = `${command} timed out after 10 seconds`;
+      if (options.ignoreFailure) resolve({ code: 124, stdout, stderr: detail });
+      else reject(new Error(detail));
+    }, 1e4);
     child.stdout?.on("data", (chunk) => {
       stdout += chunk.toString();
     });
@@ -5296,6 +6998,7 @@ async function run2(command, args, options = {}) {
       stderr += chunk.toString();
     });
     child.once("error", (error) => {
+      clearTimeout(timer);
       if (options.ignoreFailure) {
         resolve({ code: 1, stdout, stderr: stderr || error.message });
         return;
@@ -5303,6 +7006,7 @@ async function run2(command, args, options = {}) {
       reject(error);
     });
     child.once("close", (code) => {
+      clearTimeout(timer);
       const result = { code: code ?? 1, stdout, stderr };
       if ((code ?? 1) !== 0 && !options.ignoreFailure) {
         reject(
@@ -5316,48 +7020,70 @@ async function run2(command, args, options = {}) {
     });
   });
 }
-function xmlEscape(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-function psQuote(value) {
-  return "'" + value.replaceAll("'", "''") + "'";
-}
-async function ensureBundle(sourcePath, version) {
-  await fs5.mkdir(AGENT_DIR, { recursive: true });
-  await fs5.mkdir(LOG_DIR, { recursive: true });
-  if (path5.resolve(sourcePath) !== path5.resolve(AGENT_BUNDLE)) {
-    await fs5.copyFile(sourcePath, AGENT_BUNDLE);
-    if (process.platform !== "win32") {
-      await fs5.chmod(AGENT_BUNDLE, 448).catch(() => void 0);
+function createBackgroundController(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const home = options.home ?? os3.homedir();
+  const nodePath = options.nodePath ?? process.execPath;
+  const uid = options.uid ?? process.getuid?.() ?? os3.userInfo().uid;
+  const runCommand = options.run ?? run2;
+  const wait = options.wait ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const leaseActive = options.leaseActive ?? agentLeaseActive;
+  const CONFIG_DIR2 = path6.join(home, ".remotearc");
+  const AGENT_DIR = path6.join(CONFIG_DIR2, "agent");
+  const LOG_DIR = path6.join(CONFIG_DIR2, "logs");
+  const AGENT_BUNDLE = path6.join(AGENT_DIR, "remotelink.mjs");
+  const AGENT_VERSION_FILE = path6.join(AGENT_DIR, "version");
+  const MAC_LABEL = "app.remotearc.agent";
+  const WINDOWS_RUN_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+  const WINDOWS_RUN_VALUE = "Remote Arc Agent";
+  const LINUX_UNIT = "remotearc-agent.service";
+  function xmlEscape(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+  }
+  function psQuote(value) {
+    return "'" + value.replaceAll("'", "''") + "'";
+  }
+  function unitQuote(value) {
+    return JSON.stringify(value).replaceAll("%", "%%");
+  }
+  async function ensureBundle(sourcePath, version) {
+    await fs6.mkdir(AGENT_DIR, { recursive: true });
+    await fs6.mkdir(LOG_DIR, { recursive: true });
+    if (path6.resolve(sourcePath) !== path6.resolve(AGENT_BUNDLE)) {
+      const staging = AGENT_BUNDLE + "." + process.pid + ".tmp";
+      await fs6.copyFile(sourcePath, staging);
+      await fs6.rename(staging, AGENT_BUNDLE);
+      if (platform !== "win32") {
+        await fs6.chmod(AGENT_BUNDLE, 448).catch(() => void 0);
+      }
+    }
+    if (version) {
+      await fs6.writeFile(AGENT_VERSION_FILE, version + "\n", { mode: 384 });
     }
   }
-  if (version) {
-    await fs5.writeFile(AGENT_VERSION_FILE, version + "\n", { mode: 384 });
+  async function backgroundBundleVersion() {
+    return fs6.readFile(AGENT_VERSION_FILE, "utf8").then((value) => value.trim() || null).catch(() => null);
   }
-}
-async function backgroundBundleVersion() {
-  return fs5.readFile(AGENT_VERSION_FILE, "utf8").then((value) => value.trim() || null).catch(() => null);
-}
-function macPlistPath() {
-  return path5.join(os3.homedir(), "Library", "LaunchAgents", MAC_LABEL + ".plist");
-}
-function linuxUnitPath() {
-  return path5.join(os3.homedir(), ".config", "systemd", "user", LINUX_UNIT);
-}
-async function enableMac(sourcePath, preserveCurrent, version) {
-  await ensureBundle(sourcePath, version);
-  const plistPath = macPlistPath();
-  await fs5.mkdir(path5.dirname(plistPath), { recursive: true });
-  const stdoutPath = path5.join(LOG_DIR, "agent.log");
-  const stderrPath = path5.join(LOG_DIR, "agent-error.log");
-  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+  function macPlistPath() {
+    return path6.join(home, "Library", "LaunchAgents", MAC_LABEL + ".plist");
+  }
+  function linuxUnitPath() {
+    return path6.join(home, ".config", "systemd", "user", LINUX_UNIT);
+  }
+  async function enableMac(sourcePath, preserveCurrent, version) {
+    await ensureBundle(sourcePath, version);
+    const plistPath = macPlistPath();
+    await fs6.mkdir(path6.dirname(plistPath), { recursive: true });
+    const stdoutPath = path6.join(LOG_DIR, "agent.log");
+    const stderrPath = path6.join(LOG_DIR, "agent-error.log");
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
   <key>Label</key><string>${MAC_LABEL}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${xmlEscape(process.execPath)}</string>
+    <string>${xmlEscape(nodePath)}</string>
     <string>${xmlEscape(AGENT_BUNDLE)}</string>
     <string>--agent</string>
   </array>
@@ -5370,7 +7096,7 @@ async function enableMac(sourcePath, preserveCurrent, version) {
   <key>EnvironmentVariables</key>
   <dict>
     <key>PATH</key><string>${xmlEscape(process.env.PATH || "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin")}</string>
-    <key>HOME</key><string>${xmlEscape(os3.homedir())}</string>
+    <key>HOME</key><string>${xmlEscape(home)}</string>
   </dict>
   <key>ThrottleInterval</key><integer>5</integer>
   <key>StandardOutPath</key><string>${xmlEscape(stdoutPath)}</string>
@@ -5378,211 +7104,321 @@ async function enableMac(sourcePath, preserveCurrent, version) {
 </dict>
 </plist>
 `;
-  await fs5.writeFile(plistPath, plist, { mode: 384 });
-  const domain = `gui/${process.getuid?.() ?? os3.userInfo().uid}`;
-  const loaded = await run2(
-    "launchctl",
-    ["print", domain + "/" + MAC_LABEL],
-    { ignoreFailure: true }
-  );
-  await run2("launchctl", ["enable", domain + "/" + MAC_LABEL], {
-    ignoreFailure: true
-  });
-  if (!(preserveCurrent && loaded.code === 0)) {
-    await run2("launchctl", ["bootout", domain + "/" + MAC_LABEL], {
+    await fs6.writeFile(plistPath, plist, { mode: 384 });
+    const domain = `gui/${uid}`;
+    const loaded = await runCommand(
+      "launchctl",
+      ["print", domain + "/" + MAC_LABEL],
+      { ignoreFailure: true }
+    );
+    await runCommand("launchctl", ["enable", domain + "/" + MAC_LABEL], {
       ignoreFailure: true
     });
-    await run2("launchctl", ["bootstrap", domain, plistPath]);
-    await run2("launchctl", ["kickstart", "-k", domain + "/" + MAC_LABEL], {
+    if (loaded.code !== 0) {
+      const bootstrapped = await runCommand(
+        "launchctl",
+        ["bootstrap", domain, plistPath],
+        { ignoreFailure: true }
+      );
+      if (bootstrapped.code !== 0) {
+        const observed = await runCommand(
+          "launchctl",
+          ["print", domain + "/" + MAC_LABEL],
+          { ignoreFailure: true }
+        );
+        if (observed.code !== 0) {
+          throw new Error(
+            "launchctl bootstrap exited with " + bootstrapped.code + ": " + (bootstrapped.stderr.trim() || bootstrapped.stdout.trim()) + ". The current terminal remains connected."
+          );
+        }
+      }
+    }
+    await runCommand("launchctl", ["kickstart", domain + "/" + MAC_LABEL], {
       ignoreFailure: true
     });
+    return backgroundAgentStatus2();
   }
-  return backgroundAgentStatus();
-}
-async function disableMac(stopCurrent) {
-  const plistPath = macPlistPath();
-  const domain = `gui/${process.getuid?.() ?? os3.userInfo().uid}`;
-  await run2("launchctl", ["disable", domain + "/" + MAC_LABEL], {
-    ignoreFailure: true
-  });
-  await fs5.rm(plistPath, { force: true });
-  if (stopCurrent) {
-    await run2("launchctl", ["bootout", domain + "/" + MAC_LABEL], {
+  async function disableMac(stopCurrent) {
+    const plistPath = macPlistPath();
+    const domain = `gui/${uid}`;
+    await runCommand("launchctl", ["disable", domain + "/" + MAC_LABEL], {
       ignoreFailure: true
     });
+    await fs6.rm(plistPath, { force: true });
+    if (stopCurrent) {
+      await runCommand("launchctl", ["bootout", domain + "/" + MAC_LABEL], {
+        ignoreFailure: true
+      });
+    }
+    return backgroundAgentStatus2();
   }
-  return backgroundAgentStatus();
-}
-async function statusMac() {
-  const plistPath = macPlistPath();
-  const enabled = await fs5.access(plistPath).then(() => true).catch(() => false);
-  const domain = "gui/" + (process.getuid?.() ?? os3.userInfo().uid);
-  const result = await run2("launchctl", ["print", domain + "/" + MAC_LABEL], { ignoreFailure: true });
-  const pidMatch = result.stdout.match(/\\bpid = (\\d+)/);
-  const pid = pidMatch ? Number(pidMatch[1]) : null;
-  const active = result.code === 0 && pid !== null && /\\bstate = running\\b/i.test(result.stdout);
-  return {
-    supported: true,
-    enabled,
-    active,
-    service: "launchd",
-    pid,
-    version: await backgroundBundleVersion(),
-    detail: enabled && !active ? "Background connection is configured but the launchd agent is not currently running." : void 0
-  };
-}
-async function enableLinux(sourcePath, preserveCurrent, version) {
-  await ensureBundle(sourcePath, version);
-  const unitPath = linuxUnitPath();
-  await fs5.mkdir(path5.dirname(unitPath), { recursive: true });
-  const unit = `[Unit]
+  async function statusMac() {
+    const plistPath = macPlistPath();
+    const installed = await fs6.access(plistPath).then(() => true).catch(() => false);
+    const domain = "gui/" + uid;
+    const result = await runCommand(
+      "launchctl",
+      ["print", domain + "/" + MAC_LABEL],
+      { ignoreFailure: true }
+    );
+    const disabled = await runCommand("launchctl", ["print-disabled", domain], {
+      ignoreFailure: true
+    });
+    const enabled = installed && !disabled.stdout.includes('"' + MAC_LABEL + '" => true');
+    const pidMatch = result.stdout.match(/\bpid = (\d+)/);
+    const pid = pidMatch ? Number(pidMatch[1]) : null;
+    const active = result.code === 0 && pid !== null && /\bstate = running\b/i.test(result.stdout);
+    return {
+      supported: true,
+      enabled,
+      active,
+      service: "launchd",
+      pid,
+      workerPid: pid,
+      version: await backgroundBundleVersion(),
+      detail: enabled && !active ? "Background connection is configured but the launchd agent is not currently running." : void 0
+    };
+  }
+  async function enableLinux(sourcePath, preserveCurrent, version) {
+    await ensureBundle(sourcePath, version);
+    const unitPath = linuxUnitPath();
+    await fs6.mkdir(path6.dirname(unitPath), { recursive: true });
+    const unit = `[Unit]
 Description=Remote Arc background agent
 After=network-online.target
 Wants=network-online.target
 
 [Service]
 Type=simple
-ExecStart=${process.execPath} ${AGENT_BUNDLE} --agent
+ExecStart=:${unitQuote(nodePath)} ${unitQuote(AGENT_BUNDLE)} --agent
 Restart=on-failure
 RestartSec=3
 Environment=NODE_ENV=production
+Environment=${unitQuote("PATH=" + (process.env.PATH || "/usr/local/bin:/usr/bin:/bin"))}
+Environment=${unitQuote("HOME=" + home)}
 
 [Install]
 WantedBy=default.target
 `;
-  await fs5.writeFile(unitPath, unit, { mode: 384 });
-  await run2("systemctl", ["--user", "daemon-reload"]);
-  await run2(
-    "systemctl",
-    preserveCurrent ? ["--user", "enable", LINUX_UNIT] : ["--user", "enable", "--now", LINUX_UNIT]
-  );
-  return backgroundAgentStatus();
-}
-async function disableLinux(stopCurrent) {
-  await run2(
-    "systemctl",
-    stopCurrent ? ["--user", "disable", "--now", LINUX_UNIT] : ["--user", "disable", LINUX_UNIT],
-    { ignoreFailure: true }
-  );
-  await fs5.rm(linuxUnitPath(), { force: true });
-  if (stopCurrent) {
-    await run2("systemctl", ["--user", "daemon-reload"], {
-      ignoreFailure: true
-    });
+    await fs6.writeFile(unitPath, unit, { mode: 384 });
+    await runCommand("systemctl", ["--user", "daemon-reload"]);
+    await runCommand("systemctl", ["--user", "enable", "--now", LINUX_UNIT]);
+    return backgroundAgentStatus2();
   }
-  return backgroundAgentStatus();
-}
-async function statusLinux() {
-  const enabledResult = await run2("systemctl", ["--user", "is-enabled", LINUX_UNIT], { ignoreFailure: true });
-  const activeResult = await run2("systemctl", ["--user", "is-active", LINUX_UNIT], { ignoreFailure: true });
-  const pidResult = await run2("systemctl", ["--user", "show", LINUX_UNIT, "--property", "MainPID", "--value"], { ignoreFailure: true });
-  const supported = !enabledResult.stderr.toLowerCase().includes("failed to connect to bus");
-  const pidValue = Number(pidResult.stdout.trim());
-  return {
-    supported,
-    enabled: enabledResult.code === 0,
-    active: activeResult.code === 0 && Number.isFinite(pidValue) && pidValue > 0,
-    service: supported ? "systemd-user" : "unsupported",
-    pid: Number.isFinite(pidValue) && pidValue > 0 ? pidValue : null,
-    version: await backgroundBundleVersion(),
-    detail: supported ? void 0 : "systemd user services are unavailable"
-  };
-}
-async function powershell(script, ignoreFailure = false) {
-  const utf8Script = "$OutputEncoding = [Console]::OutputEncoding = [System.Text.UTF8Encoding]::new(); " + script;
-  return run2(
-    "powershell.exe",
-    ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", utf8Script],
-    { ignoreFailure }
-  );
-}
-async function windowsAgentPid() {
-  const escapedBundle = AGENT_BUNDLE.replaceAll("'", "''");
-  const script = "$p = Get-CimInstance Win32_Process | Where-Object { $_.Name -ieq 'node.exe' -and $_.CommandLine -like '*" + escapedBundle + "*' -and $_.CommandLine -like '*--agent*' } | Select-Object -First 1 -ExpandProperty ProcessId; if ($null -ne $p) { Write-Output $p }";
-  const result = await powershell(script, true);
-  const pid = Number(result.stdout.trim());
-  return Number.isFinite(pid) && pid > 0 ? pid : null;
-}
-async function enableWindows(sourcePath, preserveCurrent, version) {
-  await ensureBundle(sourcePath, version);
-  const command = '"' + process.execPath + '" "' + AGENT_BUNDLE + '" --agent';
-  await run2("reg.exe", [
-    "add",
-    WINDOWS_RUN_KEY,
-    "/v",
-    WINDOWS_RUN_VALUE,
-    "/t",
-    "REG_SZ",
-    "/d",
-    command,
-    "/f"
-  ]);
-  if (!preserveCurrent && !await windowsAgentPid()) {
-    const stdoutPath = path5.join(LOG_DIR, "agent.log");
-    const stderrPath = path5.join(LOG_DIR, "agent-error.log");
-    await powershell(
-      "Start-Process -FilePath " + psQuote(process.execPath) + " -ArgumentList @(" + psQuote(AGENT_BUNDLE) + ", '--agent') -WindowStyle Hidden -RedirectStandardOutput " + psQuote(stdoutPath) + " -RedirectStandardError " + psQuote(stderrPath) + " | Out-Null"
+  async function disableLinux(stopCurrent) {
+    await runCommand(
+      "systemctl",
+      stopCurrent ? ["--user", "disable", "--now", LINUX_UNIT] : ["--user", "disable", LINUX_UNIT],
+      { ignoreFailure: true }
     );
-    await new Promise((resolve) => setTimeout(resolve, 350));
+    await fs6.rm(linuxUnitPath(), { force: true });
+    if (stopCurrent) {
+      await runCommand("systemctl", ["--user", "daemon-reload"], {
+        ignoreFailure: true
+      });
+    }
+    return backgroundAgentStatus2();
   }
-  return backgroundAgentStatus();
-}
-async function disableWindows(stopCurrent) {
-  await run2("reg.exe", ["delete", WINDOWS_RUN_KEY, "/v", WINDOWS_RUN_VALUE, "/f"], { ignoreFailure: true });
-  if (stopCurrent) {
+  async function statusLinux() {
+    const enabledResult = await runCommand(
+      "systemctl",
+      ["--user", "is-enabled", LINUX_UNIT],
+      { ignoreFailure: true }
+    );
+    const activeResult = await runCommand(
+      "systemctl",
+      ["--user", "is-active", LINUX_UNIT],
+      { ignoreFailure: true }
+    );
+    const pidResult = await runCommand(
+      "systemctl",
+      ["--user", "show", LINUX_UNIT, "--property", "MainPID", "--value"],
+      { ignoreFailure: true }
+    );
+    const supported = !enabledResult.stderr.toLowerCase().includes("failed to connect to bus");
+    const pidValue = Number(pidResult.stdout.trim());
+    return {
+      supported,
+      enabled: enabledResult.code === 0,
+      active: activeResult.code === 0 && Number.isFinite(pidValue) && pidValue > 0,
+      service: supported ? "systemd-user" : "unsupported",
+      pid: Number.isFinite(pidValue) && pidValue > 0 ? pidValue : null,
+      workerPid: Number.isFinite(pidValue) && pidValue > 0 ? pidValue : null,
+      version: await backgroundBundleVersion(),
+      detail: supported ? void 0 : "systemd user services are unavailable"
+    };
+  }
+  async function powershell(script, ignoreFailure = false) {
+    const utf8Script = "$OutputEncoding = [Console]::OutputEncoding = [System.Text.UTF8Encoding]::new(); " + script;
+    return runCommand(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        utf8Script
+      ],
+      { ignoreFailure }
+    );
+  }
+  async function windowsAgentPid(role = "--supervise") {
+    const script = "$p = Get-CimInstance Win32_Process | Where-Object { $_.Name -ieq 'node.exe' -and $_.ExecutablePath -ieq " + psQuote(nodePath) + ` -and $_.CommandLine -match ('^"?' + [regex]::Escape(` + psQuote(nodePath) + `) + '"?\\s+"?' + [regex]::Escape(` + psQuote(AGENT_BUNDLE) + `) + '"?\\s+` + role + "(?:\\s|$)') } | Select-Object -First 1 -ExpandProperty ProcessId; if ($null -ne $p) { Write-Output $p }";
+    const result = await powershell(script, true);
+    const pid = Number(result.stdout.trim());
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  }
+  async function enableWindows(sourcePath, preserveCurrent, version) {
+    await ensureBundle(sourcePath, version);
+    const start = windowsSupervisorLaunchScript(nodePath, AGENT_BUNDLE);
+    const encoded = Buffer.from(start, "utf16le").toString("base64");
+    const command = "powershell.exe -NoProfile -NonInteractive -WindowStyle Hidden -EncodedCommand " + encoded;
+    await runCommand("reg.exe", [
+      "add",
+      WINDOWS_RUN_KEY,
+      "/v",
+      WINDOWS_RUN_VALUE,
+      "/t",
+      "REG_SZ",
+      "/d",
+      command,
+      "/f"
+    ]);
+    if (!await windowsAgentPid()) await powershell(start);
+    return backgroundAgentStatus2();
+  }
+  async function disableWindows(stopCurrent) {
+    await runCommand(
+      "reg.exe",
+      ["delete", WINDOWS_RUN_KEY, "/v", WINDOWS_RUN_VALUE, "/f"],
+      { ignoreFailure: true }
+    );
+    if (stopCurrent) {
+      for (const role of ["--agent", "--supervise"]) {
+        const pid = await windowsAgentPid(role);
+        if (pid && pid !== process.pid)
+          await powershell(
+            "Stop-Process -Id " + pid + " -Force -ErrorAction SilentlyContinue",
+            true
+          );
+      }
+    }
+    return backgroundAgentStatus2();
+  }
+  async function statusWindows() {
+    const enabledResult = await runCommand(
+      "reg.exe",
+      ["query", WINDOWS_RUN_KEY, "/v", WINDOWS_RUN_VALUE],
+      { ignoreFailure: true }
+    );
     const pid = await windowsAgentPid();
-    if (pid) {
-      await powershell("Stop-Process -Id " + pid + " -Force -ErrorAction SilentlyContinue", true);
+    return {
+      supported: true,
+      enabled: enabledResult.code === 0,
+      active: pid !== null,
+      service: "registry-run",
+      pid,
+      workerPid: await windowsAgentPid("--agent"),
+      version: await backgroundBundleVersion(),
+      detail: enabledResult.code === 0 && pid === null ? "Login startup is configured, but its supervisor is not running; recovery is unavailable." : void 0
+    };
+  }
+  async function backgroundAgentStatus2() {
+    if (platform === "darwin") return statusMac();
+    if (platform === "win32") return statusWindows();
+    if (platform === "linux") return statusLinux();
+    return {
+      supported: false,
+      enabled: false,
+      active: false,
+      service: "unsupported",
+      detail: "unsupported operating system"
+    };
+  }
+  async function enableBackgroundAgent2(sourcePath, options2 = {}) {
+    const preserveCurrent = options2.preserveCurrent ?? false;
+    const before = await backgroundAgentStatus2();
+    if (before.workerPid && before.workerPid !== process.pid) {
+      let participates = await leaseActive(AGENT_DIR);
+      for (let attempt = 0; !participates && attempt < 6; attempt++) {
+        await wait(500);
+        participates = await leaseActive(AGENT_DIR);
+      }
+      if (!participates) {
+        const canUpgradeLegacy = isOlderRelease(before.version, options2.version) && before.enabled;
+        if (!canUpgradeLegacy) {
+          throw new LegacyBackgroundAgentError(
+            "An existing background Agent does not hold the execution lease and cannot be identified as a safe older release. Stop it locally before retrying; this launch will not create a competing executor."
+          );
+        }
+        if (platform === "darwin") await disableMac(true);
+        else if (platform === "win32") await disableWindows(true);
+        else if (platform === "linux") await disableLinux(true);
+        else {
+          throw new LegacyBackgroundAgentError(
+            "The existing background Agent is older, but automatic handoff is not supported on this operating system."
+          );
+        }
+        let stopped = false;
+        for (let attempt = 0; attempt < 40; attempt++) {
+          const status2 = await backgroundAgentStatus2();
+          if (!status2.workerPid) {
+            stopped = true;
+            break;
+          }
+          await wait(250);
+        }
+        if (!stopped) {
+          throw new LegacyBackgroundAgentError(
+            "The older background Agent did not stop cleanly. Automatic upgrade was aborted before installing the new executor."
+          );
+        }
+      }
+    }
+    if (platform === "darwin")
+      await enableMac(sourcePath, preserveCurrent, options2.version);
+    else if (platform === "win32")
+      await enableWindows(sourcePath, preserveCurrent, options2.version);
+    else if (platform === "linux")
+      await enableLinux(sourcePath, preserveCurrent, options2.version);
+    else return backgroundAgentStatus2();
+    for (let attempt = 0; attempt < 20; attempt++) {
+      const status2 = await backgroundAgentStatus2();
+      if (status2.enabled && status2.active) return status2;
+      if (!status2.supported) return status2;
+      await wait(200);
     }
+    const status = await backgroundAgentStatus2();
+    throw new Error(
+      status.detail || "Background supervisor did not start; the current terminal remains connected."
+    );
+  }
+  async function disableBackgroundAgent2(options2 = {}) {
+    const stopCurrent = options2.stopCurrent ?? true;
+    if (platform === "darwin") return disableMac(stopCurrent);
+    if (platform === "win32") return disableWindows(stopCurrent);
+    if (platform === "linux") return disableLinux(stopCurrent);
+    return backgroundAgentStatus2();
   }
-  return backgroundAgentStatus();
-}
-async function statusWindows() {
-  const enabledResult = await run2("reg.exe", ["query", WINDOWS_RUN_KEY, "/v", WINDOWS_RUN_VALUE], { ignoreFailure: true });
-  const pid = await windowsAgentPid();
-  return {
-    supported: true,
-    enabled: enabledResult.code === 0,
-    active: pid !== null,
-    service: "registry-run",
-    pid,
-    version: await backgroundBundleVersion(),
-    detail: enabledResult.code === 0 && pid === null ? "Background connection is configured but the user-level agent is not currently running." : void 0
-  };
-}
-async function backgroundAgentStatus() {
-  if (process.platform === "darwin") return statusMac();
-  if (process.platform === "win32") return statusWindows();
-  if (process.platform === "linux") return statusLinux();
   return {
-    supported: false,
-    enabled: false,
-    active: false,
-    service: "unsupported",
-    detail: "unsupported operating system"
+    backgroundAgentStatus: backgroundAgentStatus2,
+    enableBackgroundAgent: enableBackgroundAgent2,
+    disableBackgroundAgent: disableBackgroundAgent2
   };
 }
-async function enableBackgroundAgent(sourcePath, options = {}) {
-  const preserveCurrent = options.preserveCurrent ?? false;
-  if (process.platform === "darwin") return enableMac(sourcePath, preserveCurrent, options.version);
-  if (process.platform === "win32") return enableWindows(sourcePath, preserveCurrent, options.version);
-  if (process.platform === "linux") return enableLinux(sourcePath, preserveCurrent, options.version);
-  return backgroundAgentStatus();
-}
-async function disableBackgroundAgent(options = {}) {
-  const stopCurrent = options.stopCurrent ?? true;
-  if (process.platform === "darwin") return disableMac(stopCurrent);
-  if (process.platform === "win32") return disableWindows(stopCurrent);
-  if (process.platform === "linux") return disableLinux(stopCurrent);
-  return backgroundAgentStatus();
-}
+var {
+  backgroundAgentStatus,
+  enableBackgroundAgent,
+  disableBackgroundAgent
+} = createBackgroundController();
 
 // src/index.ts
-var VERSION = "0.4.3";
+var VERSION = "0.4.5";
 var DEFAULT_ORIGIN = "https://mcp.remotearc.app";
-var CONFIG_DIR2 = path6.join(os4.homedir(), ".remotearc");
-var CONFIG_PATH = path6.join(CONFIG_DIR2, "config.json");
-var LEGACY_CONFIG_PATH = path6.join(os4.homedir(), ".remote-link", "config.json");
+var CONFIG_DIR = path7.join(os4.homedir(), ".remotearc");
+var CONFIG_PATH = path7.join(CONFIG_DIR, "config.json");
+var LEGACY_CONFIG_PATH = path7.join(os4.homedir(), ".remote-link", "config.json");
 var SELF_PATH = fileURLToPath(import.meta.url);
 var RevokedDeviceCredentialError = class extends Error {
   constructor() {
@@ -5696,12 +7532,14 @@ function nowTime() {
 function logLine(level, message) {
   const icon = level === "success" ? green("\u2713") : level === "warn" ? yellow("!") : level === "error" ? red("\xD7") : level === "event" ? cyan("\u2192") : cyan("\u2022");
   process3.stdout.write(`${dim(nowTime())}  ${icon}  ${message}
+`);
+  appendAgentEvent(path7.join(CONFIG_DIR, "logs"), `${nowTime()}  ${level}  ${message}
 `);
 }
 function banner() {
   process3.stdout.write("\n");
   process3.stdout.write(bold("Remote Arc") + "  " + dim(`v${VERSION}`) + "\n");
-  process3.stdout.write(dim("Secure remote MCP bridge") + "\n\n");
+  process3.stdout.write(dim("Persistent agent runtime for your computers") + "\n\n");
 }
 function argFlag(name) {
   return process3.argv.includes(name);
@@ -5718,11 +7556,11 @@ function modeLabel(mode) {
 }
 async function readConfig() {
   try {
-    return JSON.parse(await fs6.readFile(CONFIG_PATH, "utf8"));
+    return JSON.parse(await fs7.readFile(CONFIG_PATH, "utf8"));
   } catch {
     try {
       const legacy = JSON.parse(
-        await fs6.readFile(LEGACY_CONFIG_PATH, "utf8")
+        await fs7.readFile(LEGACY_CONFIG_PATH, "utf8")
       );
       await writeConfig(legacy);
       logLine("success", "Migrated existing Remote Link pairing to Remote Arc.");
@@ -5733,22 +7571,26 @@ async function readConfig() {
   }
 }
 async function writeConfig(config) {
-  await fs6.mkdir(CONFIG_DIR2, { recursive: true });
-  await fs6.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", {
-    mode: 384
-  });
+  await fs7.mkdir(CONFIG_DIR, { recursive: true, mode: 448 });
+  const staging = CONFIG_PATH + "." + randomUUID() + ".tmp";
+  try {
+    await fs7.writeFile(staging, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+    await fs7.rename(staging, CONFIG_PATH);
+  } finally {
+    await fs7.rm(staging, { force: true });
+  }
 }
 async function resetConfig() {
   await Promise.all([
-    fs6.rm(CONFIG_PATH, { force: true }),
-    fs6.rm(LEGACY_CONFIG_PATH, { force: true })
+    fs7.rm(CONFIG_PATH, { force: true }),
+    fs7.rm(LEGACY_CONFIG_PATH, { force: true })
   ]);
   logLine("success", "Removed saved device credentials.");
 }
 function openBrowser(url) {
   const command = process3.platform === "win32" ? "cmd" : process3.platform === "darwin" ? "open" : "xdg-open";
   const args = process3.platform === "win32" ? ["/c", "start", "", url] : [url];
-  const child = spawn4(command, args, {
+  const child = spawn5(command, args, {
     detached: true,
     stdio: "ignore"
   });
@@ -5855,9 +7697,13 @@ async function connectAgent(config) {
   }
   const wsUrl = new URL("/agent", config.origin.replace(/^http/, "ws"));
   let stopped = false;
+  let rePair = false;
   let backoff = 1e3;
+  let currentSocket = null;
+  let backgroundSettings = Promise.resolve();
   const shutdown = async () => {
     stopped = true;
+    currentSocket?.terminate();
     keepAwake.close();
     await core.close().catch(() => void 0);
   };
@@ -5870,6 +7716,15 @@ async function connectAgent(config) {
         Authorization: "Bearer " + config.deviceToken
       }
     });
+    currentSocket = ws;
+    const send = (message) => {
+      if (ws.readyState !== wrapper_default.OPEN) return;
+      try {
+        ws.send(JSON.stringify(message));
+      } catch {
+        ws.terminate();
+      }
+    };
     const absorbSocketError = () => void 0;
     ws.on("error", absorbSocketError);
     try {
@@ -5905,29 +7760,48 @@ async function connectAgent(config) {
         ws.once("unexpected-response", onUnexpectedResponse);
       });
       backoff = 1e3;
-      ws.send(
-        JSON.stringify({
-          type: "hello",
-          device: {
-            id: config.deviceId,
-            name: config.deviceName,
-            platform: process3.platform,
-            arch: process3.arch,
-            hostname: os4.hostname(),
-            agentVersion: VERSION,
-            pid: process3.pid,
-            backgroundProcess: argFlag("--agent"),
-            connectedAt: (/* @__PURE__ */ new Date()).toISOString()
-          },
-          tools: [...tools.map((tool) => tool.name), ...internalTools],
-          capabilities: [
-            "native_core_v1",
-            "device_policy_v1",
-            "undo_history_v1",
-            "background_agent_v1"
-          ]
-        })
-      );
+      const connectedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const publishPresence = async () => {
+        const saved = await readConfig();
+        if (!saved || saved.deviceId !== config.deviceId || saved.deviceToken !== config.deviceToken) {
+          logLine("warn", "The local pairing changed or was removed; stopping this execution owner.");
+          await shutdown();
+          return;
+        }
+        const local = await backgroundAgentStatus().catch(() => null);
+        const recovery = local ? { ...local, enabled: saved?.backgroundEnabled === true && local.enabled && local.active } : null;
+        if (ws.readyState !== wrapper_default.OPEN) return;
+        ws.send(
+          JSON.stringify({
+            type: "hello",
+            device: {
+              id: config.deviceId,
+              name: config.deviceName,
+              platform: process3.platform,
+              arch: process3.arch,
+              hostname: os4.hostname(),
+              agentVersion: VERSION,
+              pid: process3.pid,
+              backgroundProcess: argFlag("--agent"),
+              connectedAt,
+              recoveryEnabled: recovery?.enabled ?? false,
+              supervisorActive: recovery?.active,
+              supervisorPid: recovery?.pid,
+              supervisorService: recovery?.service
+            },
+            tools: [...tools.map((tool) => tool.name), ...internalTools],
+            capabilities: [
+              "native_core_v1",
+              "device_policy_v1",
+              "undo_history_v1",
+              "background_agent_v1",
+              "background_recovery_v2"
+            ]
+          })
+        );
+      };
+      await publishPresence();
+      const presenceTimer = setInterval(() => void publishPresence().catch(() => void 0), 3e4);
       logLine("success", `Relay connected \xB7 ${bold(config.deviceName)} \xB7 ${config.mode} mode`);
       logLine("success", "Device presence published.");
       process3.stdout.write("       " + dim(config.origin) + "\n");
@@ -5942,7 +7816,7 @@ async function connectAgent(config) {
               "content-type": "application/json"
             },
             body: JSON.stringify({
-              background_enabled: background?.enabled,
+              background_enabled: background ? (await readConfig())?.backgroundEnabled === true && background.enabled && background.active : void 0,
               background_process: argFlag("--agent"),
               background_service: background?.service
             })
@@ -6011,29 +7885,32 @@ async function connectAgent(config) {
               if (typeof enabled !== "boolean") {
                 throw new Error("enabled must be a boolean");
               }
-              config.backgroundEnabled = enabled;
-              await writeConfig(config);
-              if (enabled) {
-                const current = await backgroundAgentStatus();
-                result = current.enabled && current.active ? { ...current, desired_enabled: true } : {
-                  ...await enableBackgroundAgent(SELF_PATH, {
-                    preserveCurrent: argFlag("--agent"),
-                    version: VERSION
-                  }),
-                  desired_enabled: true
-                };
-                exitAfterResponse = !argFlag("--agent");
-              } else {
-                const stopCurrent = message.arguments?.stop_current === true;
-                const runningAsBackgroundAgent = argFlag("--agent");
-                result = {
-                  ...await disableBackgroundAgent({
-                    stopCurrent: stopCurrent && !runningAsBackgroundAgent
-                  }),
-                  desired_enabled: false
-                };
-                exitAfterResponse = stopCurrent && runningAsBackgroundAgent;
-              }
+              const change = backgroundSettings.then(async () => {
+                config = { ...await readConfig() || config, backgroundEnabled: enabled };
+                await writeConfig(config);
+                if (enabled) {
+                  const current = await backgroundAgentStatus();
+                  result = current.enabled && current.active ? { ...current, desired_enabled: true } : {
+                    ...await enableBackgroundAgent(SELF_PATH, {
+                      preserveCurrent: argFlag("--agent"),
+                      version: VERSION
+                    }),
+                    desired_enabled: true
+                  };
+                } else {
+                  const stopCurrent = message.arguments?.stop_current === true;
+                  const runningAsBackgroundAgent = argFlag("--agent");
+                  result = {
+                    ...await disableBackgroundAgent({
+                      stopCurrent: stopCurrent && !runningAsBackgroundAgent
+                    }),
+                    desired_enabled: false
+                  };
+                  exitAfterResponse = stopCurrent && runningAsBackgroundAgent;
+                }
+              });
+              backgroundSettings = change.catch(() => void 0);
+              await change;
             } else {
               result = await core.call(
                 message.tool,
@@ -6042,30 +7919,31 @@ async function connectAgent(config) {
               );
             }
             logLine("success", `tool.done ${message.tool} \xB7 ${Date.now() - callStarted}ms`);
-            ws.send(
-              JSON.stringify({
-                type: "result",
-                id: message.id,
-                result
-              })
-            );
+            send({
+              type: "result",
+              id: message.id,
+              result
+            });
+            if (message.tool === "set_background_agent") {
+              await publishPresence();
+              void sendHeartbeat();
+            }
             if (exitAfterResponse) {
-              setTimeout(() => process3.exit(0), 500);
+              setTimeout(() => void shutdown(), 500);
             }
           } catch (error) {
             logLine("error", `tool.fail ${message.tool} \xB7 ${error instanceof Error ? error.message : String(error)}`);
-            ws.send(
-              JSON.stringify({
-                type: "result",
-                id: message.id,
-                error: error instanceof Error ? error.message : String(error)
-              })
-            );
+            send({
+              type: "result",
+              id: message.id,
+              error: error instanceof Error ? error.message : String(error)
+            });
           }
         });
         ws.once("close", resolve);
         ws.once("error", resolve);
       });
+      clearInterval(presenceTimer);
       clearInterval(heartbeatTimer);
       clearInterval(approvalTimer);
       clearInterval(livenessTimer);
@@ -6074,8 +7952,8 @@ async function connectAgent(config) {
         logLine("warn", error.message);
         await resetConfig();
         logLine("event", "Starting a fresh device pairing\u2026");
-        await core.close().catch(() => void 0);
-        return "rePair";
+        rePair = true;
+        await shutdown();
       }
       logLine(
         "error",
@@ -6105,8 +7983,10 @@ async function connectAgent(config) {
       backoff = Math.min(backoff * 2, 3e4);
     }
   }
+  process3.off("SIGINT", shutdown);
+  process3.off("SIGTERM", shutdown);
   await core.close().catch(() => void 0);
-  return "stopped";
+  return rePair ? "rePair" : "stopped";
 }
 async function main() {
   if (argFlag("--help") || argFlag("-h")) {
@@ -6123,9 +8003,9 @@ async function main() {
         "Options:",
         "  --safe          Hard local read-only cap; dashboard cannot enable write tools",
         "  --developer     Legacy alias for dashboard-managed capabilities",
-        "  --foreground    Keep this session attached to the terminal instead of background mode",
-        "  --background    Enable the login background agent",
-        "  --no-background Disable login background mode and run this session in the foreground",
+        "  --foreground    Stay attached without installing or repairing recovery",
+        "  --background    Enable process recovery and keep this terminal attached",
+        "  --no-background Disable recovery; preserve the currently executing Agent",
         "  --reset         Remove local pairing and background-agent registration",
         "  --version       Print CLI version",
         "  --help        Show this help",
@@ -6146,6 +8026,7 @@ async function main() {
   const origin = process3.env.REMOTEARC_ORIGIN || process3.env.REMOTE_LINK_ORIGIN || process3.argv.find((value) => value.startsWith("--origin="))?.slice(9) || DEFAULT_ORIGIN;
   const agentMode = argFlag("--agent");
   const foregroundMode = argFlag("--foreground");
+  const supervisorMode = argFlag("--supervise");
   const disableBackground = argFlag("--no-background");
   const enableBackground = argFlag("--background");
   let config = await readConfig();
@@ -6156,45 +8037,67 @@ async function main() {
       logLine("info", "Migrated relay origin to " + DEFAULT_ORIGIN);
     }
     if (!config) {
-      if (agentMode) return;
+      if (agentMode || supervisorMode) return;
       config = await pair(origin, selectedMode());
-    } else if (argFlag("--safe") || argFlag("--developer")) {
-      config.mode = argFlag("--safe") ? "safe" : "managed";
-      await writeConfig(config);
     }
     if (disableBackground) {
       config.backgroundEnabled = false;
       await writeConfig(config);
-      await disableBackgroundAgent({ stopCurrent: true }).catch(() => void 0);
+      await disableBackgroundAgent({ stopCurrent: false }).catch(() => void 0);
     } else if (enableBackground) {
       config.backgroundEnabled = true;
       await writeConfig(config);
     }
     logLine("info", `Using paired device identity ${dim(config.deviceId.slice(0, 8))}\u2026`);
-    if (agentMode) {
-      if (config.backgroundEnabled !== true) return;
-      const result2 = await connectAgent(config);
-      if (result2 !== "rePair") return;
+    if (supervisorMode) {
+      const release2 = await tryAgentLease(path7.join(CONFIG_DIR, "agent"), "supervisor");
+      if (!release2) return;
+      const abort2 = new AbortController();
+      const stop = () => abort2.abort();
+      process3.on("SIGINT", stop);
+      process3.on("SIGTERM", stop);
+      try {
+        await superviseAgent({
+          enabled: async () => (await readConfig())?.backgroundEnabled === true,
+          signal: abort2.signal,
+          start: () => startSupervisedAgent(process3.execPath, SELF_PATH, path7.join(CONFIG_DIR, "logs"))
+        });
+      } finally {
+        process3.off("SIGINT", stop);
+        process3.off("SIGTERM", stop);
+        await release2();
+      }
       return;
     }
-    if (!foregroundMode && config.backgroundEnabled === true) {
+    if (agentMode && config.backgroundEnabled !== true) return;
+    if (!agentMode && !foregroundMode && config.backgroundEnabled === true) {
       try {
+        const existing = await backgroundAgentStatus().catch(() => null);
+        if (existing?.active && existing.version && existing.version !== VERSION) {
+          logLine(
+            "info",
+            `Background Agent v${existing.version} detected \xB7 checking safe handoff to v${VERSION}\u2026`
+          );
+        }
         const status = await enableBackgroundAgent(SELF_PATH, { version: VERSION });
-        if (status.supported && status.enabled) {
+        if (status.supported && status.enabled && status.active) {
           banner();
-          logLine("success", "Background connection enabled.");
+          logLine("success", "Process recovery enabled; this terminal stays attached.");
           logLine(
             "info",
-            `Service: ${status.service} \xB7 starts automatically at login`
+            `Supervisor: ${status.service} \xB7 PID ${status.pid} \xB7 takes over if the executing Agent ends`
           );
           logLine(
             "info",
             "Use the Remote Arc dashboard or --no-background to disable it."
           );
+        } else logLine("warn", status.detail || "Background services are unavailable on this system.");
+      } catch (error) {
+        if (error instanceof LegacyBackgroundAgentError) {
+          logLine("error", error.message);
+          process3.exitCode = 1;
           return;
         }
-        logLine("warn", status.detail || "Background services are unavailable on this system.");
-      } catch (error) {
         logLine(
           "warn",
           "Could not enable background mode; keeping this terminal session connected: " + (error instanceof Error ? error.message : String(error))
@@ -6207,8 +8110,56 @@ async function main() {
         "Background connection is not configured yet \xB7 finish setup in the browser or Devices."
       );
     }
-    const result = await connectAgent(config);
-    if (result !== "rePair") return;
+    const abort = new AbortController();
+    const stopWaiting = () => abort.abort();
+    process3.on("SIGINT", stopWaiting);
+    process3.on("SIGTERM", stopWaiting);
+    let release = null;
+    let cursor = null;
+    let announced = false;
+    let lastApprovalPoll = 0;
+    try {
+      while (!abort.signal.aborted && !release) {
+        if (agentMode && (await readConfig())?.backgroundEnabled !== true) return;
+        release = await tryAgentLease(path7.join(CONFIG_DIR, "agent"));
+        if (release) break;
+        if (!agentMode && (argFlag("--safe") || argFlag("--developer"))) {
+          logLine("error", "Another Agent owns execution. Stop it locally before changing the local permission profile.");
+          process3.exitCode = 1;
+          return;
+        }
+        if (!agentMode) {
+          if (!announced) {
+            logLine("info", "An Agent already owns execution. Following its operation log; Ctrl+C closes this viewer.");
+            announced = true;
+          }
+          const events = await readAgentEvents(path7.join(CONFIG_DIR, "logs"), cursor);
+          cursor = events.cursor;
+          if (events.text) process3.stdout.write(events.text);
+          if (Date.now() - lastApprovalPoll >= 4e3) {
+            lastApprovalPoll = Date.now();
+            void promptPendingApproval(config);
+          }
+        }
+        await sleep(500);
+      }
+      if (!release || abort.signal.aborted) return;
+      if (argFlag("--safe") || argFlag("--developer")) {
+        config.mode = argFlag("--safe") ? "safe" : "managed";
+        await writeConfig(config);
+      }
+      process3.off("SIGINT", stopWaiting);
+      process3.off("SIGTERM", stopWaiting);
+      const result = await connectAgent(config);
+      if (result !== "rePair") {
+        if (agentMode && (await readConfig())?.backgroundEnabled === true) process3.exitCode = 1;
+        return;
+      }
+    } finally {
+      process3.off("SIGINT", stopWaiting);
+      process3.off("SIGTERM", stopWaiting);
+      await release?.();
+    }
     config = null;
   }
 }