remotelink 0.4.7 → 0.5.0

package/dist/index.js

@@ -59,54 +59,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs8) {
+    function patch(fs9) {
       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) {
+        patchLchmod(fs9);
+      }
+      if (!fs9.lutimes) {
+        patchLutimes(fs9);
+      }
+      fs9.chown = chownFix(fs9.chown);
+      fs9.fchown = chownFix(fs9.fchown);
+      fs9.lchown = chownFix(fs9.lchown);
+      fs9.chmod = chmodFix(fs9.chmod);
+      fs9.fchmod = chmodFix(fs9.fchmod);
+      fs9.lchmod = chmodFix(fs9.lchmod);
+      fs9.chownSync = chownFixSync(fs9.chownSync);
+      fs9.fchownSync = chownFixSync(fs9.fchownSync);
+      fs9.lchownSync = chownFixSync(fs9.lchownSync);
+      fs9.chmodSync = chmodFixSync(fs9.chmodSync);
+      fs9.fchmodSync = chmodFixSync(fs9.fchmodSync);
+      fs9.lchmodSync = chmodFixSync(fs9.lchmodSync);
+      fs9.stat = statFix(fs9.stat);
+      fs9.fstat = statFix(fs9.fstat);
+      fs9.lstat = statFix(fs9.lstat);
+      fs9.statSync = statFixSync(fs9.statSync);
+      fs9.fstatSync = statFixSync(fs9.fstatSync);
+      fs9.lstatSync = statFixSync(fs9.lstatSync);
+      if (fs9.chmod && !fs9.lchmod) {
+        fs9.lchmod = function(path9, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs8.lchmodSync = function() {
+        fs9.lchmodSync = function() {
         };
       }
-      if (fs8.chown && !fs8.lchown) {
-        fs8.lchown = function(path8, uid, gid, cb) {
+      if (fs9.chown && !fs9.lchown) {
+        fs9.lchown = function(path9, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs8.lchownSync = function() {
+        fs9.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs8.rename = typeof fs8.rename !== "function" ? fs8.rename : (function(fs$rename) {
+        fs9.rename = typeof fs9.rename !== "function" ? fs9.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) {
+                  fs9.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -122,9 +122,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs8.rename);
+        })(fs9.rename);
       }
-      fs8.read = typeof fs8.read !== "function" ? fs8.read : (function(fs$read) {
+      fs9.read = typeof fs9.read !== "function" ? fs9.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -132,22 +132,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs8, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs9, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs8, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs9, 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) {
+      })(fs9.read);
+      fs9.readSync = typeof fs9.readSync !== "function" ? fs9.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);
+              return fs$readSync.call(fs9, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -157,11 +157,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs8.readSync);
-      function patchLchmod(fs9) {
-        fs9.lchmod = function(path8, mode, callback) {
-          fs9.open(
-            path8,
+      })(fs9.readSync);
+      function patchLchmod(fs10) {
+        fs10.lchmod = function(path9, mode, callback) {
+          fs10.open(
+            path9,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -169,80 +169,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs9.fchmod(fd, mode, function(err2) {
-                fs9.close(fd, function(err22) {
+              fs10.fchmod(fd, mode, function(err2) {
+                fs10.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);
+        fs10.lchmodSync = function(path9, mode) {
+          var fd = fs10.openSync(path9, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs9.fchmodSync(fd, mode);
+            ret = fs10.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs9.closeSync(fd);
+                fs10.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs9.closeSync(fd);
+              fs10.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) {
+      function patchLutimes(fs10) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs10.futimes) {
+          fs10.lutimes = function(path9, at, mt, cb) {
+            fs10.open(path9, 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) {
+              fs10.futimes(fd, at, mt, function(er2) {
+                fs10.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs9.lutimesSync = function(path8, at, mt) {
-            var fd = fs9.openSync(path8, constants.O_SYMLINK);
+          fs10.lutimesSync = function(path9, at, mt) {
+            var fd = fs10.openSync(path9, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs9.futimesSync(fd, at, mt);
+              ret = fs10.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs9.closeSync(fd);
+                  fs10.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs9.closeSync(fd);
+                fs10.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs9.futimes) {
-          fs9.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs10.futimes) {
+          fs10.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs9.lutimesSync = function() {
+          fs10.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs8, target, mode, function(er) {
+          return orig.call(fs9, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -252,7 +252,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs8, target, mode);
+            return orig.call(fs9, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -261,7 +261,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs8, target, uid, gid, function(er) {
+          return orig.call(fs9, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -271,7 +271,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs8, target, uid, gid);
+            return orig.call(fs9, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -291,13 +291,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs8, target, options, callback) : orig.call(fs8, target, callback);
+          return options ? orig.call(fs9, target, options, callback) : orig.call(fs9, 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);
+          var stats = options ? orig.call(fs9, target, options) : orig.call(fs9, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -327,16 +327,16 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs8) {
+    function legacy(fs9) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path8, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path8, options);
+      function ReadStream(path9, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path9, options);
         Stream.call(this);
         var self = this;
-        this.path = path8;
+        this.path = path9;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -370,7 +370,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs8.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs9.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -381,10 +381,10 @@ var require_legacy_streams = __commonJS({
           self._read();
         });
       }
-      function WriteStream(path8, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path8, options);
+      function WriteStream(path9, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path9, options);
         Stream.call(this);
-        this.path = path8;
+        this.path = path9;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -409,7 +409,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs8.open;
+          this._open = fs9.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -445,7 +445,7 @@ var require_clone = __commonJS({
 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 fs9 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -477,12 +477,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs8[gracefulQueue]) {
+    if (!fs9[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs8, queue);
-      fs8.close = (function(fs$close) {
+      publishQueue(fs9, queue);
+      fs9.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs8, fd, function(err) {
+          return fs$close.call(fs9, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -494,48 +494,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs8.close);
-      fs8.closeSync = (function(fs$closeSync) {
+      })(fs9.close);
+      fs9.closeSync = (function(fs$closeSync) {
         function closeSync2(fd) {
-          fs$closeSync.apply(fs8, arguments);
+          fs$closeSync.apply(fs9, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync2, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync2;
-      })(fs8.closeSync);
+      })(fs9.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs8[gracefulQueue]);
-          __require("assert").equal(fs8[gracefulQueue].length, 0);
+          debug(fs9[gracefulQueue]);
+          __require("assert").equal(fs9[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) {
+      publishQueue(global, fs9[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs9));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs9.__patched) {
+      module.exports = patch(fs9);
+      fs9.__patched = true;
+    }
+    function patch(fs10) {
+      polyfills(fs10);
+      fs10.gracefulify = patch;
+      fs10.createReadStream = createReadStream2;
+      fs10.createWriteStream = createWriteStream;
+      var fs$readFile = fs10.readFile;
+      fs10.readFile = readFile;
+      function readFile(path9, 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) {
+        return go$readFile(path9, options, cb);
+        function go$readFile(path10, options2, cb2, startTime) {
+          return fs$readFile(path10, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path9, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path10, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -543,16 +543,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs9.writeFile;
-      fs9.writeFile = writeFile;
-      function writeFile(path8, data, options, cb) {
+      var fs$writeFile = fs10.writeFile;
+      fs10.writeFile = writeFile;
+      function writeFile(path9, 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) {
+        return go$writeFile(path9, data, options, cb);
+        function go$writeFile(path10, data2, options2, cb2, startTime) {
+          return fs$writeFile(path10, 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()]);
+              enqueue([go$writeFile, [path10, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -560,17 +560,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs9.appendFile;
+      var fs$appendFile = fs10.appendFile;
       if (fs$appendFile)
-        fs9.appendFile = appendFile;
-      function appendFile(path8, data, options, cb) {
+        fs10.appendFile = appendFile;
+      function appendFile(path9, 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) {
+        return go$appendFile(path9, data, options, cb);
+        function go$appendFile(path10, data2, options2, cb2, startTime) {
+          return fs$appendFile(path10, 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()]);
+              enqueue([go$appendFile, [path10, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -578,9 +578,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs9.copyFile;
+      var fs$copyFile = fs10.copyFile;
       if (fs$copyFile)
-        fs9.copyFile = copyFile;
+        fs10.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -598,34 +598,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs9.readdir;
-      fs9.readdir = readdir;
+      var fs$readdir = fs10.readdir;
+      fs10.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path8, options, cb) {
+      function readdir(path9, 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,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path10, options2, cb2, startTime) {
+          return fs$readdir(path10, fs$readdirCallback(
+            path10,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path9, options2, cb2, startTime) {
-          return fs$readdir(path9, options2, fs$readdirCallback(
-            path9,
+        } : function go$readdir2(path10, options2, cb2, startTime) {
+          return fs$readdir(path10, options2, fs$readdirCallback(
+            path10,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path8, options, cb);
-        function fs$readdirCallback(path9, options2, cb2, startTime) {
+        return go$readdir(path9, options, cb);
+        function fs$readdirCallback(path10, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path9, options2, cb2],
+                [path10, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -640,21 +640,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs9);
+        var legStreams = legacy(fs10);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs9.ReadStream;
+      var fs$ReadStream = fs10.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs9.WriteStream;
+      var fs$WriteStream = fs10.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs9, "ReadStream", {
+      Object.defineProperty(fs10, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -664,7 +664,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs9, "WriteStream", {
+      Object.defineProperty(fs10, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -675,7 +675,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs9, "FileReadStream", {
+      Object.defineProperty(fs10, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -686,7 +686,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs9, "FileWriteStream", {
+      Object.defineProperty(fs10, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -696,7 +696,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path8, options) {
+      function ReadStream(path9, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -716,7 +716,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path8, options) {
+      function WriteStream(path9, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -734,22 +734,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream2(path8, options) {
-        return new fs9.ReadStream(path8, options);
+      function createReadStream2(path9, options) {
+        return new fs10.ReadStream(path9, options);
       }
-      function createWriteStream(path8, options) {
-        return new fs9.WriteStream(path8, options);
+      function createWriteStream(path9, options) {
+        return new fs10.WriteStream(path9, options);
       }
-      var fs$open = fs9.open;
-      fs9.open = open;
-      function open(path8, flags, mode, cb) {
+      var fs$open = fs10.open;
+      fs10.open = open;
+      function open(path9, 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) {
+        return go$open(path9, flags, mode, cb);
+        function go$open(path10, flags2, mode2, cb2, startTime) {
+          return fs$open(path10, 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()]);
+              enqueue([go$open, [path10, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -757,20 +757,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs9;
+      return fs10;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs8[gracefulQueue].push(elem);
+      fs9[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;
+      for (var i = 0; i < fs9[gracefulQueue].length; ++i) {
+        if (fs9[gracefulQueue][i].length > 2) {
+          fs9[gracefulQueue][i][3] = now;
+          fs9[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -778,9 +778,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs8[gracefulQueue].length === 0)
+      if (fs9[gracefulQueue].length === 0)
         return;
-      var elem = fs8[gracefulQueue].shift();
+      var elem = fs9[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -802,7 +802,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs8[gracefulQueue].push(elem);
+          fs9[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -1242,10 +1242,10 @@ 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];
+    function probe(file, fs9, callback) {
+      const cachedPrecision = fs9[cacheSymbol];
       if (cachedPrecision) {
-        return fs8.stat(file, (err, stat) => {
+        return fs9.stat(file, (err, stat) => {
           if (err) {
             return callback(err);
           }
@@ -1253,16 +1253,16 @@ var require_mtime_precision = __commonJS({
         });
       }
       const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
-      fs8.utimes(file, mtime, mtime, (err) => {
+      fs9.utimes(file, mtime, mtime, (err) => {
         if (err) {
           return callback(err);
         }
-        fs8.stat(file, (err2, stat) => {
+        fs9.stat(file, (err2, stat) => {
           if (err2) {
             return callback(err2);
           }
           const precision = stat.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
-          Object.defineProperty(fs8, cacheSymbol, { value: precision });
+          Object.defineProperty(fs9, cacheSymbol, { value: precision });
           callback(null, stat.mtime, precision);
         });
       });
@@ -1283,8 +1283,8 @@ var require_mtime_precision = __commonJS({
 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 path9 = __require("path");
+    var fs9 = require_graceful_fs();
     var retry = require_retry2();
     var onExit = require_signal_exit();
     var mtimePrecision = require_mtime_precision();
@@ -1294,7 +1294,7 @@ var require_lockfile = __commonJS({
     }
     function resolveCanonicalPath(file, options, callback) {
       if (!options.realpath) {
-        return callback(null, path8.resolve(file));
+        return callback(null, path9.resolve(file));
       }
       options.fs.realpath(file, callback);
     }
@@ -1415,7 +1415,7 @@ var require_lockfile = __commonJS({
         update: null,
         realpath: true,
         retries: 0,
-        fs: fs8,
+        fs: fs9,
         onCompromised: (err) => {
           throw err;
         },
@@ -1459,7 +1459,7 @@ var require_lockfile = __commonJS({
     }
     function unlock(file, options, callback) {
       options = {
-        fs: fs8,
+        fs: fs9,
         realpath: true,
         ...options
       };
@@ -1481,7 +1481,7 @@ var require_lockfile = __commonJS({
       options = {
         stale: 1e4,
         realpath: true,
-        fs: fs8,
+        fs: fs9,
         ...options
       };
       options.stale = Math.max(options.stale || 0, 2e3);
@@ -1520,16 +1520,16 @@ var require_lockfile = __commonJS({
 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) {
+    var fs9 = require_graceful_fs();
+    function createSyncFs(fs10) {
       const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-      const newFs = { ...fs9 };
+      const newFs = { ...fs10 };
       methods.forEach((method) => {
         newFs[method] = (...args) => {
           const callback = args.pop();
           let ret;
           try {
-            ret = fs9[`${method}Sync`](...args);
+            ret = fs10[`${method}Sync`](...args);
           } catch (err) {
             return callback(err);
           }
@@ -1567,7 +1567,7 @@ var require_adapter = __commonJS({
     }
     function toSyncOptions(options) {
       options = { ...options };
-      options.fs = createSyncFs(options.fs || fs8);
+      options.fs = createSyncFs(options.fs || fs9);
       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" });
       }
@@ -3856,7 +3856,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash } = __require("crypto");
+    var { randomBytes, createHash: createHash2 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -4524,8 +4524,8 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
-        if (res.headers["sec-websocket-accept"] !== digest) {
+        const digest2 = createHash2("sha1").update(key + GUID).digest("base64");
+        if (res.headers["sec-websocket-accept"] !== digest2) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
         }
@@ -4893,7 +4893,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash } = __require("crypto");
+    var { createHash: createHash2 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -5200,12 +5200,12 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash2("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
           "Connection: Upgrade",
-          `Sec-WebSocket-Accept: ${digest}`
+          `Sec-WebSocket-Accept: ${digest2}`
         ];
         const ws = new this.options.WebSocket(null, void 0, this.options);
         if (protocols.size) {
@@ -5287,8 +5287,252 @@ var require_websocket_server = __commonJS({
   }
 });
 
+// src/go-launcher.ts
+import os from "os";
+import path from "path";
+import fs from "fs/promises";
+import { createHash, randomUUID } from "crypto";
+import { spawn, spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+
+// package.json
+var package_default = {
+  name: "remotelink",
+  version: "0.5.0",
+  description: "Controlled remote computer access for AI across computers you own.",
+  type: "module",
+  bin: {
+    remotelink: "dist/index.js",
+    "remote-link": "dist/index.js",
+    "remote-arc": "dist/index.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  engines: {
+    node: ">=20"
+  },
+  scripts: {
+    build: "tsup",
+    typecheck: "tsc --noEmit",
+    prepublishOnly: "node ../../scripts/sync-release-docs.mjs --write && pnpm build && node ../../scripts/build-device.mjs --release"
+  },
+  dependencies: {
+    "proper-lockfile": "^4.1.2",
+    ws: "^8.18.3"
+  },
+  devDependencies: {
+    "@remotearc/execution-core": "workspace:*",
+    "@types/node": "^24.13.6",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/ws": "^8.18.1",
+    tsup: "^8.5.0",
+    typescript: "^6.0.3"
+  },
+  license: "UNLICENSED",
+  homepage: "https://remotearc.app",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/yaohuangguan/remote-arc.git",
+    directory: "packages/cli"
+  },
+  bugs: {
+    url: "https://github.com/yaohuangguan/remote-arc/issues"
+  },
+  keywords: [
+    "mcp",
+    "chatgpt",
+    "claude",
+    "codex",
+    "remote-computer",
+    "developer-tools"
+  ]
+};
+
+// src/go-launcher.ts
+var GO_VERSION = package_default.version;
+var platforms = {
+  win32: "windows",
+  darwin: "darwin",
+  linux: "linux"
+};
+var architectures = { x64: "amd64", arm64: "arm64" };
+function goAsset(platform = process.platform, arch = process.arch) {
+  const target = platforms[platform], cpu = architectures[arch];
+  if (!target || !cpu)
+    throw new Error(
+      `Go agent binaries are unavailable for ${platform}/${arch}.`
+    );
+  return `remotelink-go-v${GO_VERSION}-${target}-${cpu}${platform === "win32" ? ".exe" : ""}`;
+}
+function digest(b) {
+  return createHash("sha256").update(b).digest("hex");
+}
+async function exists(file) {
+  try {
+    return (await fs.stat(file)).isFile();
+  } catch {
+    return false;
+  }
+}
+function verifyVersion(binary) {
+  const child = spawnSync(binary, ["--version"], {
+    windowsHide: true,
+    encoding: "utf8",
+    timeout: 1e4,
+    maxBuffer: 4096
+  });
+  if (child.error || child.status !== 0 || child.stdout.trim() !== GO_VERSION)
+    throw new Error(
+      `The Go agent must match remotelink ${GO_VERSION}. Build the matching binary or reinstall this release.`
+    );
+}
+async function resolveGoBinary() {
+  const explicit = process.env.REMOTEARC_GO_BINARY;
+  if (explicit) {
+    if (!path.isAbsolute(explicit) || !await exists(explicit))
+      throw new Error(
+        "REMOTEARC_GO_BINARY must be an absolute path to a Go agent binary."
+      );
+    verifyVersion(explicit);
+    return explicit;
+  }
+  const asset = goAsset();
+  const manifestPath = fileURLToPath(
+    new URL("./go-binaries.json", import.meta.url)
+  );
+  let manifest;
+  try {
+    manifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+  } catch {
+    throw new Error(
+      "This npm release has no Go binary manifest. Use REMOTEARC_GO_BINARY with a matching local build, or install a native Go release."
+    );
+  }
+  const checksum = manifest.version === GO_VERSION ? manifest.checksums[asset] : void 0;
+  if (!checksum || !/^[a-f0-9]{64}$/.test(checksum))
+    throw new Error(
+      "No verified Go binary is listed for this platform in the installed release."
+    );
+  const home = process.env.REMOTEARC_HOME || os.homedir();
+  const dir = path.join(home, ".remotearc", "agent", "downloads", GO_VERSION);
+  const binary = path.join(dir, asset);
+  const bundled = fileURLToPath(new URL(`./bin/${asset}`, import.meta.url));
+  for (const candidate of [bundled, binary]) {
+    if (await exists(candidate) && digest(await fs.readFile(candidate)) === checksum) {
+      verifyVersion(candidate);
+      return candidate;
+    }
+  }
+  const releaseURL = `https://github.com/yaohuangguan/remote-arc/releases/download/go-agent-v${GO_VERSION}/${asset}`;
+  const response = await fetch(releaseURL, {
+    signal: AbortSignal.timeout(12e4)
+  });
+  if (!response.ok || !response.body)
+    throw new Error(
+      `Cannot download the Go agent (HTTP ${response.status}). The TS agent remains available with --ts.`
+    );
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    size += value.length;
+    if (size > 100 * 1024 * 1024) {
+      await reader.cancel();
+      throw new Error("Go binary exceeds the download size limit.");
+    }
+    chunks.push(Buffer.from(value));
+  }
+  const bytes = Buffer.concat(chunks);
+  if (digest(bytes) !== checksum)
+    throw new Error(
+      "Go binary checksum does not match the installed npm release."
+    );
+  await fs.mkdir(dir, { recursive: true, mode: 448 });
+  const temporary = binary + "." + randomUUID() + ".tmp";
+  try {
+    await fs.writeFile(temporary, bytes, { mode: 448, flag: "wx" });
+    verifyVersion(temporary);
+    try {
+      await fs.rename(temporary, binary);
+    } catch (error) {
+      if (!await exists(binary) || digest(await fs.readFile(binary)) !== checksum)
+        throw error;
+    }
+  } finally {
+    await fs.rm(temporary, { force: true });
+  }
+  verifyVersion(binary);
+  return binary;
+}
+async function launchGo(args) {
+  const binary = await resolveGoBinary();
+  const child = spawn(binary, args, { stdio: "inherit", windowsHide: true });
+  const stop = (signal) => {
+    if (process.platform === "win32") {
+      void localGoControl("POST", "/stop", child.pid).catch(() => void 0);
+    } else child.kill(signal);
+  };
+  const interrupt = () => stop("SIGINT"), terminate = () => stop("SIGTERM");
+  process.on("SIGINT", interrupt);
+  process.on("SIGTERM", terminate);
+  try {
+    const code = await new Promise((resolve, reject) => {
+      child.once("error", reject);
+      child.once("exit", (code2, signal) => resolve(code2 ?? (signal ? 1 : 0)));
+    });
+    process.exitCode = code;
+  } finally {
+    process.off("SIGINT", interrupt);
+    process.off("SIGTERM", terminate);
+  }
+}
+async function localGoControl(method, endpoint, expectedPid) {
+  const home = process.env.REMOTEARC_HOME || os.homedir();
+  const config = JSON.parse(
+    await fs.readFile(
+      path.join(home, ".remotearc", "agent", "control.json"),
+      "utf8"
+    )
+  );
+  const url = new URL(config.url);
+  if (config.engine !== "go" || url.protocol !== "http:" || url.hostname !== "127.0.0.1" || !url.port || url.username || url.password || url.pathname !== "/" || url.search || url.hash || !/^[a-f0-9]{64}$/.test(config.token) || expectedPid !== void 0 && config.pid !== expectedPid)
+    throw new Error("Invalid local Go control endpoint.");
+  const response = await fetch(new URL(endpoint, url), {
+    method,
+    headers: { Authorization: "Bearer " + config.token },
+    signal: AbortSignal.timeout(3e3),
+    redirect: "error"
+  });
+  if (!response.ok) throw new Error("Local Go agent control request failed.");
+  return response.json();
+}
+async function assertTSOwnership(args) {
+  if (args.some((arg) => ["--help", "-h", "--version", "-v"].includes(arg)))
+    return;
+  const home = process.env.REMOTEARC_HOME || os.homedir();
+  try {
+    const lock2 = await fs.stat(
+      path.join(home, ".remotearc", "agent", "execution.lock")
+    );
+    if (Date.now() - lock2.mtimeMs > 15e3) return;
+    const status = await localGoControl("GET", "/status").catch(() => null);
+    if (status?.engine === "go")
+      throw new Error(
+        "A Go agent owns execution. Use --go --stop before launching --ts; pairing and active operations have been preserved."
+      );
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+}
+
 // src/keep-awake.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 var HELPER_SECONDS = 210;
 var windowsScript = `
 Add-Type -TypeDefinition 'using System; using System.Runtime.InteropServices; public static class RemoteArcPower { [DllImport("kernel32.dll")] public static extern uint SetThreadExecutionState(uint flags); }'
@@ -5298,7 +5542,7 @@ try { Start-Sleep -Seconds ${HELPER_SECONDS} } finally { [RemoteArcPower]::SetTh
 function createTaskKeepAwakeManager(options = {}) {
   const platform = options.platform || process.platform;
   const clock = options.now || Date.now;
-  const launch = options.spawn || spawn;
+  const launch = options.spawn || spawn2;
   const leases = /* @__PURE__ */ new Map();
   let helper = null;
   let helperUntil = 0;
@@ -5365,15 +5609,15 @@ function createTaskKeepAwakeManager(options = {}) {
 }
 
 // src/goal-workspace.ts
-import fs4 from "fs/promises";
-import path4 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
 
 // ../execution-core/src/filesystem.ts
 import crypto from "crypto";
-import fs from "fs/promises";
-import path from "path";
+import fs2 from "fs/promises";
+import path2 from "path";
 var MAX_DIRECTORY_ENTRIES = 2e3;
 var DEFAULT_READ_LINES = 240;
 var MAX_TEXT_FILE_BYTES = 20 * 1024 * 1024;
@@ -5389,14 +5633,14 @@ async function listDirectory(targetPath, depth = 2, canReveal) {
   let protectedEntries = 0;
   async function walk(directory, level, prefix) {
     if (entriesSeen >= MAX_DIRECTORY_ENTRIES) return;
-    const entries = await fs.readdir(directory, { withFileTypes: true });
+    const entries = await fs2.readdir(directory, { withFileTypes: true });
     entries.sort((a, b) => {
       if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
       return a.name.localeCompare(b.name);
     });
     for (const entry of entries) {
       if (entriesSeen >= MAX_DIRECTORY_ENTRIES) break;
-      const absolute = path.join(directory, entry.name);
+      const absolute = path2.join(directory, entry.name);
       if (canReveal && !await canReveal(absolute)) {
         protectedEntries += 1;
         continue;
@@ -5409,7 +5653,7 @@ async function listDirectory(targetPath, depth = 2, canReveal) {
       }
     }
   }
-  const stat = await fs.stat(targetPath);
+  const stat = await fs2.stat(targetPath);
   if (!stat.isDirectory()) throw new Error("Path is not a directory: " + targetPath);
   await walk(targetPath, 1, "");
   if (entriesSeen >= MAX_DIRECTORY_ENTRIES) {
@@ -5424,14 +5668,14 @@ Depth: ${maxDepth}
 ${lines.join("\n") || "(empty)"}${protectionNote}`;
 }
 async function readTextFile(targetPath, offset, length) {
-  const stat = await fs.stat(targetPath);
+  const stat = await fs2.stat(targetPath);
   if (!stat.isFile()) throw new Error("Path is not a file: " + targetPath);
   if (stat.size > MAX_TEXT_FILE_BYTES) {
     throw new Error(
       `File is too large for read_file (${printableSize(stat.size)} > 20 MB). Use a terminal command or a more targeted tool instead.`
     );
   }
-  const buffer = await fs.readFile(targetPath);
+  const buffer = await fs2.readFile(targetPath);
   const sample = buffer.subarray(0, Math.min(buffer.length, 8192));
   if (sample.includes(0)) {
     throw new Error("Binary file detected. read_file currently supports text files only.");
@@ -5461,7 +5705,7 @@ function assertBinaryRevision(expected, actual) {
   }
 }
 function binaryMimeType(targetPath, header) {
-  const extension2 = path.extname(targetPath).toLowerCase();
+  const extension2 = path2.extname(targetPath).toLowerCase();
   const office = {
     ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
     ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
@@ -5502,7 +5746,7 @@ function binaryMimeType(targetPath, header) {
   return known[extension2] || "application/octet-stream";
 }
 async function readBinaryFile(targetPath, offset = 0, length = BINARY_DEFAULT_BYTES, expectedRevision) {
-  const stat = await fs.stat(targetPath);
+  const stat = await fs2.stat(targetPath);
   if (!stat.isFile()) throw new Error("Path is not a file: " + targetPath);
   const fileRevision = binaryFileRevision(stat);
   assertBinaryRevision(expectedRevision, fileRevision);
@@ -5527,7 +5771,7 @@ async function readBinaryFile(targetPath, offset = 0, length = BINARY_DEFAULT_BY
     };
   }
   const toRead = Math.min(requested, stat.size - byteOffset);
-  const handle = await fs.open(targetPath, "r");
+  const handle = await fs2.open(targetPath, "r");
   try {
     const headerBuffer = Buffer.allocUnsafe(Math.min(16, stat.size));
     const headerResult = await handle.read(
@@ -5540,7 +5784,7 @@ async function readBinaryFile(targetPath, offset = 0, length = BINARY_DEFAULT_BY
     const buffer = Buffer.allocUnsafe(toRead);
     const result = await handle.read(buffer, 0, toRead, byteOffset);
     const chunk = buffer.subarray(0, result.bytesRead);
-    const afterStat = await fs.stat(targetPath);
+    const afterStat = await fs2.stat(targetPath);
     const afterRevision = binaryFileRevision(afterStat);
     if (afterRevision !== fileRevision) {
       throw new Error(
@@ -5564,7 +5808,7 @@ async function readBinaryFile(targetPath, offset = 0, length = BINARY_DEFAULT_BY
   }
 }
 async function getFileInfo(targetPath) {
-  const stat = await fs.lstat(targetPath);
+  const stat = await fs2.lstat(targetPath);
   return {
     path: targetPath,
     type: stat.isFile() ? "file" : stat.isDirectory() ? "directory" : stat.isSymbolicLink() ? "symlink" : "other",
@@ -5577,27 +5821,27 @@ async function getFileInfo(targetPath) {
   };
 }
 async function atomicWriteText(targetPath, content) {
-  const directory = path.dirname(targetPath);
-  await fs.mkdir(directory, { recursive: true });
-  const temporary = path.join(
+  const directory = path2.dirname(targetPath);
+  await fs2.mkdir(directory, { recursive: true });
+  const temporary = path2.join(
     directory,
-    "." + path.basename(targetPath) + ".remotearc-" + crypto.randomUUID() + ".tmp"
+    "." + path2.basename(targetPath) + ".remotearc-" + crypto.randomUUID() + ".tmp"
   );
   try {
-    await fs.writeFile(temporary, content, "utf8");
-    await fs.rename(temporary, targetPath);
+    await fs2.writeFile(temporary, content, "utf8");
+    await fs2.rename(temporary, targetPath);
   } finally {
-    await fs.rm(temporary, { force: true }).catch(() => void 0);
+    await fs2.rm(temporary, { force: true }).catch(() => void 0);
   }
 }
 async function writeTextFile(targetPath, content, mode = "rewrite") {
-  await fs.mkdir(path.dirname(targetPath), { recursive: true });
+  await fs2.mkdir(path2.dirname(targetPath), { recursive: true });
   if (mode === "append") {
-    await fs.appendFile(targetPath, content, "utf8");
+    await fs2.appendFile(targetPath, content, "utf8");
   } else {
     await atomicWriteText(targetPath, content);
   }
-  const stat = await fs.stat(targetPath);
+  const stat = await fs2.stat(targetPath);
   return {
     path: targetPath,
     mode,
@@ -5608,7 +5852,7 @@ async function writeTextFile(targetPath, content, mode = "rewrite") {
 }
 async function editTextBlock(filePath, oldString, newString, expectedReplacements = 1) {
   if (!oldString) throw new Error("old_string cannot be empty.");
-  const current = await fs.readFile(filePath, "utf8");
+  const current = await fs2.readFile(filePath, "utf8");
   const parts = current.split(oldString);
   const replacements = parts.length - 1;
   if (replacements !== expectedReplacements) {
@@ -5627,14 +5871,14 @@ async function editTextBlock(filePath, oldString, newString, expectedReplacement
   };
 }
 async function browseDirectories(targetPath, canReveal) {
-  const stat = await fs.stat(targetPath);
+  const stat = await fs2.stat(targetPath);
   if (!stat.isDirectory()) throw new Error("Path is not a directory: " + targetPath);
-  const entries = await fs.readdir(targetPath, { withFileTypes: true });
+  const entries = await fs2.readdir(targetPath, { withFileTypes: true });
   const directories = [];
   let protectedEntries = 0;
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const absolute = path.join(targetPath, entry.name);
+    const absolute = path2.join(targetPath, entry.name);
     if (canReveal && !await canReveal(absolute)) {
       protectedEntries += 1;
       continue;
@@ -5649,7 +5893,7 @@ async function browseDirectories(targetPath, canReveal) {
   directories.sort((a, b) => a.name.localeCompare(b.name));
   return {
     path: targetPath,
-    parent: path.dirname(targetPath) === targetPath ? null : path.dirname(targetPath),
+    parent: path2.dirname(targetPath) === targetPath ? null : path2.dirname(targetPath),
     directories,
     protected_entries_omitted: protectedEntries,
     truncated: directories.length >= 300
@@ -5657,7 +5901,7 @@ async function browseDirectories(targetPath, canReveal) {
 }
 
 // ../execution-core/src/process.ts
-import { execFile, spawn as spawn2 } from "child_process";
+import { execFile, spawn as spawn3 } from "child_process";
 import crypto2 from "crypto";
 import process2 from "process";
 var MAX_CAPTURE_BYTES = 2 * 1024 * 1024;
@@ -5687,7 +5931,7 @@ async function terminateTree(child) {
   if (!child.pid) return;
   if (process2.platform === "win32") {
     await new Promise((resolve) => {
-      const killer = spawn2(
+      const killer = spawn3(
         "taskkill.exe",
         ["/PID", String(child.pid), "/T", "/F"],
         { windowsHide: true, stdio: "ignore" }
@@ -5713,7 +5957,7 @@ async function runShellCommand(command, timeoutMs = 5e3, cwd) {
   const timeout = Math.max(100, Math.min(12e4, Math.trunc(timeoutMs || 5e3)));
   const startedAt = Date.now();
   return await new Promise((resolve, reject) => {
-    const child = spawn2(command, {
+    const child = spawn3(command, {
       shell: true,
       cwd,
       windowsHide: true,
@@ -5782,7 +6026,7 @@ async function startBackgroundProcess(command, cwd, maxDurationSeconds) {
       "Remote Arc already has the maximum number of managed background processes on this device."
     );
   }
-  const child = spawn2(command, {
+  const child = spawn3(command, {
     shell: true,
     cwd,
     windowsHide: true,
@@ -5916,20 +6160,20 @@ function listManagedProcesses() {
 // ../execution-core/src/safety.ts
 import crypto3 from "crypto";
 import { createReadStream } from "fs";
-import fs2 from "fs/promises";
-import os from "os";
-import path2 from "path";
+import fs3 from "fs/promises";
+import os2 from "os";
+import path3 from "path";
 var RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
 var MAX_SNAPSHOT_BYTES = 20 * 1024 * 1024;
 var MAX_UNDO_BYTES = 200 * 1024 * 1024;
-var undoRoot = () => process.env.REMOTEARC_UNDO_ROOT || path2.join(os.homedir(), ".remotearc", "undo");
+var undoRoot = () => process.env.REMOTEARC_UNDO_ROOT || path3.join(os2.homedir(), ".remotearc", "undo");
 async function ensureUndoRoot() {
-  await fs2.mkdir(undoRoot(), { recursive: true, mode: 448 });
+  await fs3.mkdir(undoRoot(), { recursive: true, mode: 448 });
 }
 async function readManifest(directory) {
   try {
     return JSON.parse(
-      await fs2.readFile(path2.join(directory, "manifest.json"), "utf8")
+      await fs3.readFile(path3.join(directory, "manifest.json"), "utf8")
     );
   } catch {
     return null;
@@ -5937,8 +6181,8 @@ async function readManifest(directory) {
 }
 async function snapshotDirectories() {
   await ensureUndoRoot();
-  const entries = await fs2.readdir(undoRoot(), { withFileTypes: true });
-  return entries.filter((entry) => entry.isDirectory()).map((entry) => path2.join(undoRoot(), entry.name));
+  const entries = await fs3.readdir(undoRoot(), { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => path3.join(undoRoot(), entry.name));
 }
 async function cleanupUndoStore() {
   const now = Date.now();
@@ -5946,12 +6190,12 @@ async function cleanupUndoStore() {
   for (const directory of await snapshotDirectories()) {
     const manifest = await readManifest(directory);
     if (!manifest) {
-      await fs2.rm(directory, { recursive: true, force: true }).catch(() => void 0);
+      await fs3.rm(directory, { recursive: true, force: true }).catch(() => void 0);
       continue;
     }
     const created = Date.parse(manifest.createdAt);
     if (!Number.isFinite(created) || now - created > RETENTION_MS) {
-      await fs2.rm(directory, { recursive: true, force: true }).catch(() => void 0);
+      await fs3.rm(directory, { recursive: true, force: true }).catch(() => void 0);
       continue;
     }
     snapshots.push({ directory, manifest });
@@ -5962,7 +6206,7 @@ async function cleanupUndoStore() {
   let total = snapshots.reduce((sum, item) => sum + item.manifest.bytes, 0);
   for (const item of snapshots) {
     if (total <= MAX_UNDO_BYTES) break;
-    await fs2.rm(item.directory, { recursive: true, force: true }).catch(() => void 0);
+    await fs3.rm(item.directory, { recursive: true, force: true }).catch(() => void 0);
     total -= item.manifest.bytes;
   }
 }
@@ -5979,22 +6223,22 @@ async function createUndoSnapshot(tool, args) {
   let bytes = 0;
   let original = null;
   try {
-    const stat = await fs2.stat(targetPath);
+    const stat = await fs3.stat(targetPath);
     if (!stat.isFile()) return null;
     existed = true;
     mode = stat.mode;
     bytes = stat.size;
     if (bytes > MAX_SNAPSHOT_BYTES) return null;
-    original = await fs2.readFile(targetPath);
+    original = await fs3.readFile(targetPath);
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
     if (code !== "ENOENT") throw error;
   }
   const id = `${Date.now()}-${crypto3.randomUUID().slice(0, 8)}`;
-  const directory = path2.join(undoRoot(), id);
-  await fs2.mkdir(directory, { recursive: true, mode: 448 });
+  const directory = path3.join(undoRoot(), id);
+  await fs3.mkdir(directory, { recursive: true, mode: 448 });
   if (original) {
-    await fs2.writeFile(path2.join(directory, "content.bin"), original, { mode: 384 });
+    await fs3.writeFile(path3.join(directory, "content.bin"), original, { mode: 384 });
   }
   const manifest = {
     id,
@@ -6005,8 +6249,8 @@ async function createUndoSnapshot(tool, args) {
     ...mode !== void 0 ? { mode } : {},
     bytes
   };
-  await fs2.writeFile(
-    path2.join(directory, "manifest.json"),
+  await fs3.writeFile(
+    path3.join(directory, "manifest.json"),
     JSON.stringify(manifest, null, 2) + "\n",
     { mode: 384 }
   );
@@ -6022,8 +6266,8 @@ async function finalizeUndoSnapshot(snapshot) {
   if (!snapshot) return false;
   try {
     snapshot.manifest.postChangeHash = await hashFile(snapshot.manifest.targetPath);
-    await fs2.writeFile(
-      path2.join(snapshot.directory, "manifest.json"),
+    await fs3.writeFile(
+      path3.join(snapshot.directory, "manifest.json"),
       JSON.stringify(snapshot.manifest, null, 2) + "\n",
       { mode: 384 }
     );
@@ -6035,7 +6279,7 @@ async function finalizeUndoSnapshot(snapshot) {
 }
 async function discardUndoSnapshot(snapshot) {
   if (!snapshot) return;
-  await fs2.rm(snapshot.directory, { recursive: true, force: true }).catch(() => void 0);
+  await fs3.rm(snapshot.directory, { recursive: true, force: true }).catch(() => void 0);
 }
 async function undoCandidates() {
   await cleanupUndoStore();
@@ -6100,16 +6344,16 @@ async function restoreUndoCandidate(candidate) {
     );
   }
   if (manifest.existed) {
-    const original = await fs2.readFile(path2.join(directory, "content.bin"));
-    await fs2.mkdir(path2.dirname(manifest.targetPath), { recursive: true });
-    await fs2.writeFile(manifest.targetPath, original);
+    const original = await fs3.readFile(path3.join(directory, "content.bin"));
+    await fs3.mkdir(path3.dirname(manifest.targetPath), { recursive: true });
+    await fs3.writeFile(manifest.targetPath, original);
     if (manifest.mode !== void 0) {
-      await fs2.chmod(manifest.targetPath, manifest.mode).catch(() => void 0);
+      await fs3.chmod(manifest.targetPath, manifest.mode).catch(() => void 0);
     }
   } else {
-    await fs2.rm(manifest.targetPath, { force: true });
+    await fs3.rm(manifest.targetPath, { force: true });
   }
-  await fs2.rm(directory, { recursive: true, force: true });
+  await fs3.rm(directory, { recursive: true, force: true });
   return {
     restored: true,
     action_id: manifest.id,
@@ -6175,9 +6419,9 @@ function assertCommandAllowed(command) {
 }
 
 // ../execution-core/src/policy.ts
-import fs3 from "fs/promises";
-import os2 from "os";
-import path3 from "path";
+import fs4 from "fs/promises";
+import os3 from "os";
+import path4 from "path";
 var SENSITIVE_BASENAMES = /* @__PURE__ */ new Set([
   ".npmrc",
   ".pypirc",
@@ -6189,75 +6433,75 @@ var SENSITIVE_BASENAMES = /* @__PURE__ */ new Set([
 ]);
 var expandPath = (value) => {
   const trimmed = value.trim();
-  if (trimmed === "~") return os2.homedir();
+  if (trimmed === "~") return os3.homedir();
   if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
-    return path3.join(os2.homedir(), trimmed.slice(2));
+    return path4.join(os3.homedir(), trimmed.slice(2));
   }
-  return trimmed.replace(/%USERPROFILE%/gi, os2.homedir()).replace(/\$HOME\b/g, os2.homedir());
+  return trimmed.replace(/%USERPROFILE%/gi, os3.homedir()).replace(/\$HOME\b/g, os3.homedir());
 };
 var comparePath = (value) => {
-  const resolved = path3.resolve(expandPath(value));
+  const resolved = path4.resolve(expandPath(value));
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 };
 async function canonicalTarget(targetPath) {
-  const expanded = path3.resolve(expandPath(targetPath));
+  const expanded = path4.resolve(expandPath(targetPath));
   try {
-    return comparePath(await fs3.realpath(expanded));
+    return comparePath(await fs4.realpath(expanded));
   } catch {
     const missing = [];
     let cursor = expanded;
     while (true) {
       try {
-        const realParent = await fs3.realpath(cursor);
-        return comparePath(path3.join(realParent, ...missing.reverse()));
+        const realParent = await fs4.realpath(cursor);
+        return comparePath(path4.join(realParent, ...missing.reverse()));
       } catch {
-        const parent = path3.dirname(cursor);
+        const parent = path4.dirname(cursor);
         if (parent === cursor) return comparePath(expanded);
-        missing.push(path3.basename(cursor));
+        missing.push(path4.basename(cursor));
         cursor = parent;
       }
     }
   }
 }
 var isInside = (target, root) => {
-  const relative = path3.relative(root, target);
-  return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+  const relative = path4.relative(root, target);
+  return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
 };
 function defaultSensitiveRoots() {
-  const home = os2.homedir();
+  const home = os3.homedir();
   const roots = [
-    path3.join(home, ".ssh"),
-    path3.join(home, ".aws"),
-    path3.join(home, ".gnupg"),
-    path3.join(home, ".azure"),
-    path3.join(home, ".kube"),
-    path3.join(home, ".docker"),
-    path3.join(home, ".config", "gcloud")
+    path4.join(home, ".ssh"),
+    path4.join(home, ".aws"),
+    path4.join(home, ".gnupg"),
+    path4.join(home, ".azure"),
+    path4.join(home, ".kube"),
+    path4.join(home, ".docker"),
+    path4.join(home, ".config", "gcloud")
   ];
   if (process.platform === "darwin") {
     roots.push(
-      path3.join(home, "Library", "Application Support", "Google", "Chrome"),
-      path3.join(home, "Library", "Application Support", "Microsoft Edge"),
-      path3.join(home, "Library", "Application Support", "Firefox")
+      path4.join(home, "Library", "Application Support", "Google", "Chrome"),
+      path4.join(home, "Library", "Application Support", "Microsoft Edge"),
+      path4.join(home, "Library", "Application Support", "Firefox")
     );
   }
   if (process.platform === "win32") {
     const appData = process.env.APPDATA;
     const localAppData = process.env.LOCALAPPDATA;
     if (appData) {
-      roots.push(path3.join(appData, "Mozilla", "Firefox"));
+      roots.push(path4.join(appData, "Mozilla", "Firefox"));
     }
     if (localAppData) {
       roots.push(
-        path3.join(localAppData, "Google", "Chrome", "User Data"),
-        path3.join(localAppData, "Microsoft", "Edge", "User Data")
+        path4.join(localAppData, "Google", "Chrome", "User Data"),
+        path4.join(localAppData, "Microsoft", "Edge", "User Data")
       );
     }
   }
   return roots;
 }
 function looksLikeSensitiveFile(target) {
-  const basename = path3.basename(target).toLowerCase();
+  const basename = path4.basename(target).toLowerCase();
   if (basename === ".env" || basename.startsWith(".env.")) return true;
   if (SENSITIVE_BASENAMES.has(basename)) return true;
   const normalized = target.replace(/\\/g, "/").toLowerCase();
@@ -6752,7 +6996,7 @@ var RemoteArcExecutionCore = class {
 // src/goal-workspace.ts
 var run = promisify(execFile2);
 var pending = /* @__PURE__ */ new Map();
-var samePath = (a, b) => process.platform === "win32" ? path4.resolve(a).toLowerCase() === path4.resolve(b).toLowerCase() : path4.resolve(a) === path4.resolve(b);
+var samePath = (a, b) => process.platform === "win32" ? path5.resolve(a).toLowerCase() === path5.resolve(b).toLowerCase() : path5.resolve(a) === path5.resolve(b);
 var git = async (cwd, args) => (await run("git", ["-c", "core.hooksPath=", "-c", "commit.gpgSign=false", "-C", cwd, ...args], { windowsHide: true, timeout: 2e4, maxBuffer: 1e6, env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_AUTHOR_NAME: "Remote Arc", GIT_AUTHOR_EMAIL: "task@remotearc.local", GIT_COMMITTER_NAME: "Remote Arc", GIT_COMMITTER_EMAIL: "task@remotearc.local" } })).stdout.trim();
 async function goalWorkspace(args, policy = {}) {
   const id = String(args.task_id || ""), operation = String(args.operation_id || ""), action = String(args.action || "");
@@ -6760,12 +7004,12 @@ async function goalWorkspace(args, policy = {}) {
   const prior = pending.get(id) || Promise.resolve();
   const next = prior.catch(() => void 0).then(async () => {
     const root = await enforcePathPolicy(String(args.workspace || ""), policy);
-    const canonical = await fs4.realpath(root);
-    const directory = await enforcePathPolicy(path4.join(canonical, ".remotearc-goals", id), policy);
-    const file = path4.join(directory, "state.json");
+    const canonical = await fs5.realpath(root);
+    const directory = await enforcePathPolicy(path5.join(canonical, ".remotearc-goals", id), policy);
+    const file = path5.join(directory, "state.json");
     let state;
     try {
-      state = JSON.parse(await fs4.readFile(file, "utf8"));
+      state = JSON.parse(await fs5.readFile(file, "utf8"));
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -6773,28 +7017,28 @@ async function goalWorkspace(args, policy = {}) {
     const result = (s) => ({ root: s.root, path: s.path, frontier: s.frontier, generation: s.generation });
     const save = async (s) => {
       const temp = file + ".next";
-      await fs4.writeFile(temp, JSON.stringify(s), { encoding: "utf8", mode: 384 });
-      await fs4.rename(temp, file);
+      await fs5.writeFile(temp, JSON.stringify(s), { encoding: "utf8", mode: 384 });
+      await fs5.rename(temp, file);
     };
     if (state?.operations[operation] && !["status", "fingerprint"].includes(action)) return state.operations[operation];
     if (!state) {
       if (action !== "create") throw new Error("No owned goal workspace. Update the device CLI if this tool is unavailable.");
-      const top = await fs4.realpath(await git(canonical, ["rev-parse", "--show-toplevel"]));
+      const top = await fs5.realpath(await git(canonical, ["rev-parse", "--show-toplevel"]));
       if (!samePath(top, canonical)) throw new Error("Quality isolation requires the repository root.");
       if (await git(canonical, ["status", "--porcelain", "--", ".", ":!.remotearc-goals"])) throw new Error("Quality baseline requires a clean checkout; preserve user edits before starting.");
       const frontier = await git(canonical, ["rev-parse", "HEAD"]);
-      await fs4.mkdir(directory, { recursive: true });
-      const candidate = await enforcePathPolicy(path4.join(directory, "candidate-0"), policy);
+      await fs5.mkdir(directory, { recursive: true });
+      const candidate = await enforcePathPolicy(path5.join(directory, "candidate-0"), policy);
       await git(canonical, ["worktree", "add", "--detach", candidate, frontier]);
       state = { version: 1, task_id: id, root: canonical, path: candidate, frontier, generation: 0, operations: {} };
     } else {
-      const expected = path4.join(directory, "candidate-" + state.generation);
-      if (!samePath(state.path, expected) || !samePath(await fs4.realpath(state.path), expected)) throw new Error("Candidate ownership path changed.");
+      const expected = path5.join(directory, "candidate-" + state.generation);
+      if (!samePath(state.path, expected) || !samePath(await fs5.realpath(state.path), expected)) throw new Error("Candidate ownership path changed.");
       await enforcePathPolicy(state.path, policy);
-      const marker = await fs4.lstat(path4.join(state.path, ".git"));
+      const marker = await fs5.lstat(path5.join(state.path, ".git"));
       if (!marker.isFile() || marker.isSymbolicLink()) throw new Error("Candidate Git identity changed.");
-      const common = await fs4.realpath(await git(state.path, ["rev-parse", "--path-format=absolute", "--git-common-dir"]));
-      const original = await fs4.realpath(await git(canonical, ["rev-parse", "--path-format=absolute", "--git-common-dir"]));
+      const common = await fs5.realpath(await git(state.path, ["rev-parse", "--path-format=absolute", "--git-common-dir"]));
+      const original = await fs5.realpath(await git(canonical, ["rev-parse", "--path-format=absolute", "--git-common-dir"]));
       if (!samePath(common, original)) throw new Error("Candidate belongs to another repository.");
       if (action === "capture") {
         if (args.expected_frontier !== state.frontier) throw new Error("Accepted checkpoint changed. Read context again.");
@@ -6808,7 +7052,7 @@ async function goalWorkspace(args, policy = {}) {
       }
       if (action === "reject") {
         if (args.expected_frontier !== state.frontier) throw new Error("Accepted checkpoint changed. Read context again.");
-        const candidate = await enforcePathPolicy(path4.join(directory, "candidate-" + (state.generation + 1)), policy);
+        const candidate = await enforcePathPolicy(path5.join(directory, "candidate-" + (state.generation + 1)), policy);
         await git(canonical, ["worktree", "add", "--detach", candidate, state.frontier]);
         state.generation++;
         state.path = candidate;
@@ -6834,21 +7078,21 @@ async function goalWorkspace(args, policy = {}) {
 
 // src/agent-runtime.ts
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import fs5 from "fs/promises";
+import fs6 from "fs/promises";
 import { appendFileSync, mkdirSync, renameSync, statSync, openSync, closeSync } from "fs";
-import path5 from "path";
-import { spawn as spawn3 } from "child_process";
+import path6 from "path";
+import { spawn as spawn4 } from "child_process";
 var AGENT_LEASE_STALE_MS = 15e3;
 async function agentLeaseActive(directory) {
-  return (0, import_proper_lockfile.check)(path5.join(directory, "execution"), {
+  return (0, import_proper_lockfile.check)(path6.join(directory, "execution"), {
     realpath: false,
     stale: AGENT_LEASE_STALE_MS
   });
 }
 async function tryAgentLease(directory, role = "execution") {
-  await fs5.mkdir(directory, { recursive: true, mode: 448 });
+  await fs6.mkdir(directory, { recursive: true, mode: 448 });
   try {
-    return await (0, import_proper_lockfile.lock)(path5.join(directory, role), {
+    return await (0, import_proper_lockfile.lock)(path6.join(directory, role), {
       realpath: false,
       stale: AGENT_LEASE_STALE_MS,
       update: 3e3,
@@ -6862,7 +7106,7 @@ async function tryAgentLease(directory, role = "execution") {
 function appendAgentEvent(directory, line) {
   try {
     mkdirSync(directory, { recursive: true, mode: 448 });
-    const file = path5.join(directory, "events.log");
+    const file = path6.join(directory, "events.log");
     if ((statSync(file, { throwIfNoEntry: false })?.size ?? 0) > 5 * 1024 * 1024) {
       renameSync(file, file + ".1");
     }
@@ -6871,10 +7115,10 @@ function appendAgentEvent(directory, line) {
   }
 }
 async function readAgentEvents(directory, cursor) {
-  const file = path5.join(directory, "events.log");
+  const file = path6.join(directory, "events.log");
   let handle;
   try {
-    handle = await fs5.open(file, "r");
+    handle = await fs6.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));
@@ -6890,6 +7134,38 @@ async function readAgentEvents(directory, cursor) {
     await handle?.close();
   }
 }
+async function readAgentEventTail(directory, requestedLimit = 100) {
+  const limit = Math.max(20, Math.min(200, Math.trunc(requestedLimit || 100)));
+  const file = path6.join(directory, "events.log");
+  let handle;
+  try {
+    handle = await fs6.open(file, "r");
+    const stat = await handle.stat();
+    const start = Math.max(0, stat.size - 128 * 1024);
+    const buffer = Buffer.alloc(Math.min(stat.size - start, 128 * 1024));
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
+    let lines = buffer.subarray(0, bytesRead).toString("utf8").split("\n");
+    if (start > 0) lines = lines.slice(1);
+    lines = lines.map((line) => line.trimEnd()).filter(Boolean);
+    return {
+      source: "local-device",
+      lines: lines.slice(-limit),
+      total_bytes: stat.size,
+      truncated: start > 0 || lines.length > limit,
+      updated_at: stat.mtime.toISOString()
+    };
+  } catch {
+    return {
+      source: "local-device",
+      lines: [],
+      total_bytes: 0,
+      truncated: false,
+      updated_at: null
+    };
+  } finally {
+    await handle?.close();
+  }
+}
 async function superviseAgent(options) {
   let delay = options.delayMs ?? 1e3;
   while (!options.signal.aborted && await options.enabled()) {
@@ -6918,28 +7194,28 @@ async function superviseAgent(options) {
   }
 }
 function startSupervisedAgent(node, bundle, logs) {
-  if (!logs) return spawn3(node, [bundle, "--agent"], { stdio: "inherit", windowsHide: true });
+  if (!logs) return spawn4(node, [bundle, "--agent"], { stdio: "inherit", windowsHide: true });
   mkdirSync(logs, { recursive: true, mode: 448 });
-  const out = openSync(path5.join(logs, "agent.log"), "a", 384);
+  const out = openSync(path6.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 });
+    err = openSync(path6.join(logs, "agent-error.log"), "a", 384);
+    return spawn4(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 path7 from "path";
-import fs7 from "fs/promises";
-import { spawn as spawn5 } from "child_process";
-import { randomUUID } from "crypto";
+// src/legacy.ts
+import os5 from "os";
+import path8 from "path";
+import fs8 from "fs/promises";
+import { spawn as spawn6 } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
 import process3 from "process";
 import { createInterface } from "readline/promises";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // ../../node_modules/.pnpm/ws@8.21.3/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -6953,10 +7229,10 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
 // src/background.ts
-import os3 from "os";
-import path6 from "path";
-import fs6 from "fs/promises";
-import { spawn as spawn4 } from "child_process";
+import os4 from "os";
+import path7 from "path";
+import fs7 from "fs/promises";
+import { spawn as spawn5 } from "child_process";
 var LegacyBackgroundAgentError = class extends Error {
 };
 function parseReleaseVersion(value) {
@@ -6979,7 +7255,7 @@ function windowsSupervisorLaunchScript(node, bundle) {
 }
 async function run2(command, args, options = {}) {
   return new Promise((resolve, reject) => {
-    const child = spawn4(command, args, {
+    const child = spawn5(command, args, {
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true
     });
@@ -7022,17 +7298,17 @@ async function run2(command, args, options = {}) {
 }
 function createBackgroundController(options = {}) {
   const platform = options.platform ?? process.platform;
-  const home = options.home ?? os3.homedir();
+  const home = options.home ?? os4.homedir();
   const nodePath = options.nodePath ?? process.execPath;
-  const uid = options.uid ?? process.getuid?.() ?? os3.userInfo().uid;
+  const uid = options.uid ?? process.getuid?.() ?? os4.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 CONFIG_DIR2 = path7.join(home, ".remotearc");
+  const AGENT_DIR = path7.join(CONFIG_DIR2, "agent");
+  const LOG_DIR = path7.join(CONFIG_DIR2, "logs");
+  const AGENT_BUNDLE = path7.join(AGENT_DIR, "remotelink.mjs");
+  const AGENT_VERSION_FILE = path7.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";
@@ -7047,35 +7323,35 @@ function createBackgroundController(options = {}) {
     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)) {
+    await fs7.mkdir(AGENT_DIR, { recursive: true });
+    await fs7.mkdir(LOG_DIR, { recursive: true });
+    if (path7.resolve(sourcePath) !== path7.resolve(AGENT_BUNDLE)) {
       const staging = AGENT_BUNDLE + "." + process.pid + ".tmp";
-      await fs6.copyFile(sourcePath, staging);
-      await fs6.rename(staging, AGENT_BUNDLE);
+      await fs7.copyFile(sourcePath, staging);
+      await fs7.rename(staging, AGENT_BUNDLE);
       if (platform !== "win32") {
-        await fs6.chmod(AGENT_BUNDLE, 448).catch(() => void 0);
+        await fs7.chmod(AGENT_BUNDLE, 448).catch(() => void 0);
       }
     }
     if (version) {
-      await fs6.writeFile(AGENT_VERSION_FILE, version + "\n", { mode: 384 });
+      await fs7.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);
+    return fs7.readFile(AGENT_VERSION_FILE, "utf8").then((value) => value.trim() || null).catch(() => null);
   }
   function macPlistPath() {
-    return path6.join(home, "Library", "LaunchAgents", MAC_LABEL + ".plist");
+    return path7.join(home, "Library", "LaunchAgents", MAC_LABEL + ".plist");
   }
   function linuxUnitPath() {
-    return path6.join(home, ".config", "systemd", "user", LINUX_UNIT);
+    return path7.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");
+    await fs7.mkdir(path7.dirname(plistPath), { recursive: true });
+    const stdoutPath = path7.join(LOG_DIR, "agent.log");
+    const stderrPath = path7.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">
@@ -7104,7 +7380,7 @@ function createBackgroundController(options = {}) {
 </dict>
 </plist>
 `;
-    await fs6.writeFile(plistPath, plist, { mode: 384 });
+    await fs7.writeFile(plistPath, plist, { mode: 384 });
     const domain = `gui/${uid}`;
     const loaded = await runCommand(
       "launchctl",
@@ -7144,7 +7420,7 @@ function createBackgroundController(options = {}) {
     await runCommand("launchctl", ["disable", domain + "/" + MAC_LABEL], {
       ignoreFailure: true
     });
-    await fs6.rm(plistPath, { force: true });
+    await fs7.rm(plistPath, { force: true });
     if (stopCurrent) {
       await runCommand("launchctl", ["bootout", domain + "/" + MAC_LABEL], {
         ignoreFailure: true
@@ -7154,7 +7430,7 @@ function createBackgroundController(options = {}) {
   }
   async function statusMac() {
     const plistPath = macPlistPath();
-    const installed = await fs6.access(plistPath).then(() => true).catch(() => false);
+    const installed = await fs7.access(plistPath).then(() => true).catch(() => false);
     const domain = "gui/" + uid;
     const result = await runCommand(
       "launchctl",
@@ -7182,7 +7458,7 @@ function createBackgroundController(options = {}) {
   async function enableLinux(sourcePath, preserveCurrent, version) {
     await ensureBundle(sourcePath, version);
     const unitPath = linuxUnitPath();
-    await fs6.mkdir(path6.dirname(unitPath), { recursive: true });
+    await fs7.mkdir(path7.dirname(unitPath), { recursive: true });
     const unit = `[Unit]
 Description=Remote Arc background agent
 After=network-online.target
@@ -7200,7 +7476,7 @@ Environment=${unitQuote("HOME=" + home)}
 [Install]
 WantedBy=default.target
 `;
-    await fs6.writeFile(unitPath, unit, { mode: 384 });
+    await fs7.writeFile(unitPath, unit, { mode: 384 });
     await runCommand("systemctl", ["--user", "daemon-reload"]);
     await runCommand("systemctl", ["--user", "enable", "--now", LINUX_UNIT]);
     return backgroundAgentStatus2();
@@ -7211,7 +7487,7 @@ WantedBy=default.target
       stopCurrent ? ["--user", "disable", "--now", LINUX_UNIT] : ["--user", "disable", LINUX_UNIT],
       { ignoreFailure: true }
     );
-    await fs6.rm(linuxUnitPath(), { force: true });
+    await fs7.rm(linuxUnitPath(), { force: true });
     if (stopCurrent) {
       await runCommand("systemctl", ["--user", "daemon-reload"], {
         ignoreFailure: true
@@ -7432,13 +7708,13 @@ var {
   disableBackgroundAgent
 } = createBackgroundController();
 
-// src/index.ts
-var VERSION = "0.4.7";
+// src/legacy.ts
+var VERSION = package_default.version;
 var DEFAULT_ORIGIN = "https://mcp.remotearc.app";
-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 CONFIG_DIR = path8.join(os5.homedir(), ".remotearc");
+var CONFIG_PATH = path8.join(CONFIG_DIR, "config.json");
+var LEGACY_CONFIG_PATH = path8.join(os5.homedir(), ".remote-link", "config.json");
+var SELF_PATH = fileURLToPath2(import.meta.url);
 var RevokedDeviceCredentialError = class extends Error {
   constructor() {
     super("Saved device credential has been revoked.");
@@ -7552,7 +7828,7 @@ 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}
+  appendAgentEvent(path8.join(CONFIG_DIR, "logs"), `${nowTime()}  ${level}  ${message}
 `);
 }
 function banner() {
@@ -7575,11 +7851,11 @@ function modeLabel(mode) {
 }
 async function readConfig() {
   try {
-    return JSON.parse(await fs7.readFile(CONFIG_PATH, "utf8"));
+    return JSON.parse(await fs8.readFile(CONFIG_PATH, "utf8"));
   } catch {
     try {
       const legacy = JSON.parse(
-        await fs7.readFile(LEGACY_CONFIG_PATH, "utf8")
+        await fs8.readFile(LEGACY_CONFIG_PATH, "utf8")
       );
       await writeConfig(legacy);
       logLine("success", "Migrated existing Remote Link pairing to Remote Arc.");
@@ -7590,33 +7866,33 @@ async function readConfig() {
   }
 }
 async function writeConfig(config) {
-  await fs7.mkdir(CONFIG_DIR, { recursive: true, mode: 448 });
-  const staging = CONFIG_PATH + "." + randomUUID() + ".tmp";
+  await fs8.mkdir(CONFIG_DIR, { recursive: true, mode: 448 });
+  const staging = CONFIG_PATH + "." + randomUUID2() + ".tmp";
   try {
-    await fs7.writeFile(staging, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
-    await fs7.rename(staging, CONFIG_PATH);
+    await fs8.writeFile(staging, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+    await fs8.rename(staging, CONFIG_PATH);
   } finally {
-    await fs7.rm(staging, { force: true });
+    await fs8.rm(staging, { force: true });
   }
 }
 async function resetConfig() {
   await Promise.all([
-    fs7.rm(CONFIG_PATH, { force: true }),
-    fs7.rm(LEGACY_CONFIG_PATH, { force: true })
+    fs8.rm(CONFIG_PATH, { force: true }),
+    fs8.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 = spawn5(command, args, {
+  const child = spawn6(command, args, {
     detached: true,
     stdio: "ignore"
   });
   child.unref();
 }
 async function pair(origin, mode) {
-  const deviceName = os4.hostname();
+  const deviceName = os5.hostname();
   const response = await fetch(origin + "/api/device/start", {
     method: "POST",
     headers: { "content-type": "application/json" },
@@ -7624,7 +7900,7 @@ async function pair(origin, mode) {
       device_name: deviceName,
       platform: process3.platform,
       arch: process3.arch,
-      hostname: os4.hostname()
+      hostname: os5.hostname()
     })
   });
   if (!response.ok) {
@@ -7698,7 +7974,7 @@ async function connectAgent(config) {
     `Permission profile: ${isLocalSafeMode(config.mode) ? green("safe local cap") : cyan("dashboard-managed")}`
   );
   const tools = await core.tools();
-  const internalTools = ["background_agent_status", "set_background_agent", "set_task_keep_awake", "goal_workspace"];
+  const internalTools = ["background_agent_status", "set_background_agent", "set_task_keep_awake", "goal_workspace", "agent_execution_log"];
   let keepAwake = createTaskKeepAwakeManager();
   logLine("success", `Local tools ready: ${tools.length} exposed`);
   process3.stdout.write("       " + dim(tools.map((tool) => tool.name).join(" \xB7 ")) + "\n");
@@ -7798,7 +8074,7 @@ async function connectAgent(config) {
               name: config.deviceName,
               platform: process3.platform,
               arch: process3.arch,
-              hostname: os4.hostname(),
+              hostname: os5.hostname(),
               agentVersion: VERSION,
               pid: process3.pid,
               backgroundProcess: argFlag("--agent"),
@@ -7900,6 +8176,11 @@ async function connectAgent(config) {
                 enabled: status.enabled,
                 desired_enabled: config.backgroundEnabled ?? null
               };
+            } else if (message.tool === "agent_execution_log") {
+              result = await readAgentEventTail(
+                path8.join(CONFIG_DIR, "logs"),
+                Number(message.arguments?.limit || 100)
+              );
             } else if (message.tool === "set_background_agent") {
               const enabled = message.arguments?.enabled;
               if (typeof enabled !== "boolean") {
@@ -8021,6 +8302,8 @@ async function main() {
         "  npx remotelink",
         "",
         "Options:",
+        "  --go            Select the complete native Go device runtime",
+        "  --ts            Select the TS device runtime (transition default)",
         "  --safe          Hard local read-only cap; dashboard cannot enable write tools",
         "  --developer     Legacy alias for dashboard-managed capabilities",
         "  --foreground    Stay attached without installing or repairing recovery",
@@ -8083,7 +8366,7 @@ async function main() {
     }
     logLine("info", `Using paired device identity ${dim(config.deviceId.slice(0, 8))}\u2026`);
     if (supervisorMode) {
-      const release2 = await tryAgentLease(path7.join(CONFIG_DIR, "agent"), "supervisor");
+      const release2 = await tryAgentLease(path8.join(CONFIG_DIR, "agent"), "supervisor");
       if (!release2) return;
       const abort2 = new AbortController();
       const stop = () => abort2.abort();
@@ -8093,7 +8376,7 @@ async function main() {
         await superviseAgent({
           enabled: async () => (await readConfig())?.backgroundEnabled === true,
           signal: abort2.signal,
-          start: () => startSupervisedAgent(process3.execPath, SELF_PATH, path7.join(CONFIG_DIR, "logs"))
+          start: () => startSupervisedAgent(process3.execPath, SELF_PATH, path8.join(CONFIG_DIR, "logs"))
         });
       } finally {
         process3.off("SIGINT", stop);
@@ -8154,7 +8437,7 @@ async function main() {
     try {
       while (!abort.signal.aborted && !release) {
         if (agentMode && (await readConfig())?.backgroundEnabled !== true) return;
-        release = await tryAgentLease(path7.join(CONFIG_DIR, "agent"));
+        release = await tryAgentLease(path8.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.");
@@ -8166,7 +8449,7 @@ async function main() {
             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);
+          const events = await readAgentEvents(path8.join(CONFIG_DIR, "logs"), cursor);
           cursor = events.cursor;
           if (events.text) process3.stdout.write(events.text);
           if (Date.now() - lastApprovalPoll >= 4e3) {
@@ -8196,11 +8479,28 @@ async function main() {
     config = null;
   }
 }
-main().catch((error) => {
-  logLine(
-    "error",
-    "Fatal: " + (error instanceof Error ? error.message : String(error))
+async function runLegacy() {
+  await main();
+}
+
+// src/index.ts
+async function main2() {
+  const args = process.argv.slice(2);
+  if (args.includes("--go") && args.includes("--ts"))
+    throw new Error("Choose one agent runtime: --go or --ts.");
+  const go = args.includes("--go");
+  const forwarded = args.filter(
+    (argument) => argument !== "--go" && argument !== "--ts"
+  );
+  if (go) return launchGo(forwarded);
+  await assertTSOwnership(forwarded);
+  process.argv = [...process.argv.slice(0, 2), ...forwarded];
+  await runLegacy();
+}
+main2().catch((error) => {
+  process.stderr.write(
+    "Remote Arc: " + (error instanceof Error ? error.message : String(error)) + "\n"
   );
-  process3.exit(1);
+  process.exitCode = 1;
 });
 //# sourceMappingURL=index.js.map