@atlashub/smartstack-cli 4.59.0 → 4.61.0

package/dist/index.js

@@ -974,7 +974,7 @@ var require_command = __commonJS({
     var EventEmitter2 = require("events").EventEmitter;
     var childProcess2 = require("child_process");
     var path4 = require("path");
-    var fs21 = require("fs");
+    var fs22 = require("fs");
     var process17 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1907,10 +1907,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path4.resolve(baseDir, baseName);
-          if (fs21.existsSync(localBin)) return localBin;
+          if (fs22.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path4.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext2) => fs21.existsSync(`${localBin}${ext2}`)
+            (ext2) => fs22.existsSync(`${localBin}${ext2}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1922,7 +1922,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs21.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs22.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -3089,54 +3089,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs21) {
+    function patch(fs22) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs21);
-      }
-      if (!fs21.lutimes) {
-        patchLutimes(fs21);
-      }
-      fs21.chown = chownFix(fs21.chown);
-      fs21.fchown = chownFix(fs21.fchown);
-      fs21.lchown = chownFix(fs21.lchown);
-      fs21.chmod = chmodFix(fs21.chmod);
-      fs21.fchmod = chmodFix(fs21.fchmod);
-      fs21.lchmod = chmodFix(fs21.lchmod);
-      fs21.chownSync = chownFixSync(fs21.chownSync);
-      fs21.fchownSync = chownFixSync(fs21.fchownSync);
-      fs21.lchownSync = chownFixSync(fs21.lchownSync);
-      fs21.chmodSync = chmodFixSync(fs21.chmodSync);
-      fs21.fchmodSync = chmodFixSync(fs21.fchmodSync);
-      fs21.lchmodSync = chmodFixSync(fs21.lchmodSync);
-      fs21.stat = statFix(fs21.stat);
-      fs21.fstat = statFix(fs21.fstat);
-      fs21.lstat = statFix(fs21.lstat);
-      fs21.statSync = statFixSync(fs21.statSync);
-      fs21.fstatSync = statFixSync(fs21.fstatSync);
-      fs21.lstatSync = statFixSync(fs21.lstatSync);
-      if (fs21.chmod && !fs21.lchmod) {
-        fs21.lchmod = function(path4, mode, cb) {
+        patchLchmod(fs22);
+      }
+      if (!fs22.lutimes) {
+        patchLutimes(fs22);
+      }
+      fs22.chown = chownFix(fs22.chown);
+      fs22.fchown = chownFix(fs22.fchown);
+      fs22.lchown = chownFix(fs22.lchown);
+      fs22.chmod = chmodFix(fs22.chmod);
+      fs22.fchmod = chmodFix(fs22.fchmod);
+      fs22.lchmod = chmodFix(fs22.lchmod);
+      fs22.chownSync = chownFixSync(fs22.chownSync);
+      fs22.fchownSync = chownFixSync(fs22.fchownSync);
+      fs22.lchownSync = chownFixSync(fs22.lchownSync);
+      fs22.chmodSync = chmodFixSync(fs22.chmodSync);
+      fs22.fchmodSync = chmodFixSync(fs22.fchmodSync);
+      fs22.lchmodSync = chmodFixSync(fs22.lchmodSync);
+      fs22.stat = statFix(fs22.stat);
+      fs22.fstat = statFix(fs22.fstat);
+      fs22.lstat = statFix(fs22.lstat);
+      fs22.statSync = statFixSync(fs22.statSync);
+      fs22.fstatSync = statFixSync(fs22.fstatSync);
+      fs22.lstatSync = statFixSync(fs22.lstatSync);
+      if (fs22.chmod && !fs22.lchmod) {
+        fs22.lchmod = function(path4, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs21.lchmodSync = function() {
+        fs22.lchmodSync = function() {
         };
       }
-      if (fs21.chown && !fs21.lchown) {
-        fs21.lchown = function(path4, uid, gid, cb) {
+      if (fs22.chown && !fs22.lchown) {
+        fs22.lchown = function(path4, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs21.lchownSync = function() {
+        fs22.lchownSync = function() {
         };
       }
       if (platform4 === "win32") {
-        fs21.rename = typeof fs21.rename !== "function" ? fs21.rename : (function(fs$rename) {
+        fs22.rename = typeof fs22.rename !== "function" ? fs22.rename : (function(fs$rename) {
           function rename(from3, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from3, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs21.stat(to, function(stater, st) {
+                  fs22.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from3, to, CB);
                     else
@@ -3152,9 +3152,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs21.rename);
+        })(fs22.rename);
       }
-      fs21.read = typeof fs21.read !== "function" ? fs21.read : (function(fs$read) {
+      fs22.read = typeof fs22.read !== "function" ? fs22.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -3162,22 +3162,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _3, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs21, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs22, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs21, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs22, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs21.read);
-      fs21.readSync = typeof fs21.readSync !== "function" ? fs21.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs22.read);
+      fs22.readSync = typeof fs22.readSync !== "function" ? fs22.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs21, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs22, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -3187,10 +3187,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs21.readSync);
-      function patchLchmod(fs22) {
-        fs22.lchmod = function(path4, mode, callback) {
-          fs22.open(
+      })(fs22.readSync);
+      function patchLchmod(fs23) {
+        fs23.lchmod = function(path4, mode, callback) {
+          fs23.open(
             path4,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -3199,80 +3199,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs22.fchmod(fd, mode, function(err2) {
-                fs22.close(fd, function(err22) {
+              fs23.fchmod(fd, mode, function(err2) {
+                fs23.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs22.lchmodSync = function(path4, mode) {
-          var fd = fs22.openSync(path4, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs23.lchmodSync = function(path4, mode) {
+          var fd = fs23.openSync(path4, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs22.fchmodSync(fd, mode);
+            ret = fs23.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs22.closeSync(fd);
+                fs23.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs22.closeSync(fd);
+              fs23.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs22) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs22.futimes) {
-          fs22.lutimes = function(path4, at, mt, cb) {
-            fs22.open(path4, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs23) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs23.futimes) {
+          fs23.lutimes = function(path4, at, mt, cb) {
+            fs23.open(path4, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs22.futimes(fd, at, mt, function(er2) {
-                fs22.close(fd, function(er22) {
+              fs23.futimes(fd, at, mt, function(er2) {
+                fs23.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs22.lutimesSync = function(path4, at, mt) {
-            var fd = fs22.openSync(path4, constants.O_SYMLINK);
+          fs23.lutimesSync = function(path4, at, mt) {
+            var fd = fs23.openSync(path4, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs22.futimesSync(fd, at, mt);
+              ret = fs23.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs22.closeSync(fd);
+                  fs23.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs22.closeSync(fd);
+                fs23.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs22.futimes) {
-          fs22.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs23.futimes) {
+          fs23.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs22.lutimesSync = function() {
+          fs23.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs21, target, mode, function(er) {
+          return orig.call(fs22, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -3282,7 +3282,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs21, target, mode);
+            return orig.call(fs22, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -3291,7 +3291,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs21, target, uid, gid, function(er) {
+          return orig.call(fs22, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -3301,7 +3301,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs21, target, uid, gid);
+            return orig.call(fs22, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -3321,13 +3321,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs21, target, options, callback) : orig.call(fs21, target, callback);
+          return options ? orig.call(fs22, target, options, callback) : orig.call(fs22, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs21, target, options) : orig.call(fs21, target);
+          var stats = options ? orig.call(fs22, target, options) : orig.call(fs22, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -3357,7 +3357,7 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream2 = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs21) {
+    function legacy(fs22) {
       return {
         ReadStream,
         WriteStream
@@ -3400,7 +3400,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs21.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs22.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -3439,7 +3439,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs21.open;
+          this._open = fs22.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -3475,7 +3475,7 @@ var require_clone = __commonJS({
 var require_graceful_fs = __commonJS({
   "node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
     "use strict";
-    var fs21 = require("fs");
+    var fs22 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -3507,12 +3507,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs21[gracefulQueue]) {
+    if (!fs22[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs21, queue);
-      fs21.close = (function(fs$close) {
+      publishQueue(fs22, queue);
+      fs22.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs21, fd, function(err) {
+          return fs$close.call(fs22, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -3524,40 +3524,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs21.close);
-      fs21.closeSync = (function(fs$closeSync) {
+      })(fs22.close);
+      fs22.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs21, arguments);
+          fs$closeSync.apply(fs22, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs21.closeSync);
+      })(fs22.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs21[gracefulQueue]);
-          require("assert").equal(fs21[gracefulQueue].length, 0);
+          debug(fs22[gracefulQueue]);
+          require("assert").equal(fs22[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs21[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs21));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs21.__patched) {
-      module2.exports = patch(fs21);
-      fs21.__patched = true;
-    }
-    function patch(fs22) {
-      polyfills(fs22);
-      fs22.gracefulify = patch;
-      fs22.createReadStream = createReadStream;
-      fs22.createWriteStream = createWriteStream;
-      var fs$readFile = fs22.readFile;
-      fs22.readFile = readFile;
+      publishQueue(global, fs22[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs22));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs22.__patched) {
+      module2.exports = patch(fs22);
+      fs22.__patched = true;
+    }
+    function patch(fs23) {
+      polyfills(fs23);
+      fs23.gracefulify = patch;
+      fs23.createReadStream = createReadStream;
+      fs23.createWriteStream = createWriteStream;
+      var fs$readFile = fs23.readFile;
+      fs23.readFile = readFile;
       function readFile(path4, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -3573,8 +3573,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs22.writeFile;
-      fs22.writeFile = writeFile;
+      var fs$writeFile = fs23.writeFile;
+      fs23.writeFile = writeFile;
       function writeFile(path4, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -3590,9 +3590,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs22.appendFile;
+      var fs$appendFile = fs23.appendFile;
       if (fs$appendFile)
-        fs22.appendFile = appendFile;
+        fs23.appendFile = appendFile;
       function appendFile(path4, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -3608,9 +3608,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs22.copyFile;
+      var fs$copyFile = fs23.copyFile;
       if (fs$copyFile)
-        fs22.copyFile = copyFile;
+        fs23.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -3628,8 +3628,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs22.readdir;
-      fs22.readdir = readdir2;
+      var fs$readdir = fs23.readdir;
+      fs23.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir2(path4, options, cb) {
         if (typeof options === "function")
@@ -3670,21 +3670,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs22);
+        var legStreams = legacy(fs23);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs22.ReadStream;
+      var fs$ReadStream = fs23.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs22.WriteStream;
+      var fs$WriteStream = fs23.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs22, "ReadStream", {
+      Object.defineProperty(fs23, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -3694,7 +3694,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs22, "WriteStream", {
+      Object.defineProperty(fs23, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -3705,7 +3705,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs22, "FileReadStream", {
+      Object.defineProperty(fs23, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -3716,7 +3716,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs22, "FileWriteStream", {
+      Object.defineProperty(fs23, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -3765,13 +3765,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path4, options) {
-        return new fs22.ReadStream(path4, options);
+        return new fs23.ReadStream(path4, options);
       }
       function createWriteStream(path4, options) {
-        return new fs22.WriteStream(path4, options);
+        return new fs23.WriteStream(path4, options);
       }
-      var fs$open = fs22.open;
-      fs22.open = open2;
+      var fs$open = fs23.open;
+      fs23.open = open2;
       function open2(path4, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -3787,20 +3787,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs22;
+      return fs23;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs21[gracefulQueue].push(elem);
+      fs22[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs21[gracefulQueue].length; ++i) {
-        if (fs21[gracefulQueue][i].length > 2) {
-          fs21[gracefulQueue][i][3] = now;
-          fs21[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs22[gracefulQueue].length; ++i) {
+        if (fs22[gracefulQueue][i].length > 2) {
+          fs22[gracefulQueue][i][3] = now;
+          fs22[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -3808,9 +3808,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs21[gracefulQueue].length === 0)
+      if (fs22[gracefulQueue].length === 0)
         return;
-      var elem = fs21[gracefulQueue].shift();
+      var elem = fs22[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -3832,7 +3832,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs21[gracefulQueue].push(elem);
+          fs22[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -3847,7 +3847,7 @@ var require_fs = __commonJS({
   "node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs21 = require_graceful_fs();
+    var fs22 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -3888,26 +3888,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs21[key] === "function";
+      return typeof fs22[key] === "function";
     });
-    Object.assign(exports2, fs21);
+    Object.assign(exports2, fs22);
     api.forEach((method) => {
-      exports2[method] = u(fs21[method]);
+      exports2[method] = u(fs22[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs21.exists(filename, callback);
+        return fs22.exists(filename, callback);
       }
       return new Promise((resolve2) => {
-        return fs21.exists(filename, resolve2);
+        return fs22.exists(filename, resolve2);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs21.read(fd, buffer, offset, length, position, callback);
+        return fs22.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve2, reject) => {
-        fs21.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs22.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve2({ bytesRead, buffer: buffer2 });
         });
@@ -3915,10 +3915,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs21.write(fd, buffer, ...args);
+        return fs22.write(fd, buffer, ...args);
       }
       return new Promise((resolve2, reject) => {
-        fs21.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs22.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve2({ bytesWritten, buffer: buffer2 });
         });
@@ -3926,10 +3926,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs21.readv(fd, buffers, ...args);
+        return fs22.readv(fd, buffers, ...args);
       }
       return new Promise((resolve2, reject) => {
-        fs21.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs22.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve2({ bytesRead, buffers: buffers2 });
         });
@@ -3937,17 +3937,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs21.writev(fd, buffers, ...args);
+        return fs22.writev(fd, buffers, ...args);
       }
       return new Promise((resolve2, reject) => {
-        fs21.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs22.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve2({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs21.realpath.native === "function") {
-      exports2.realpath.native = u(fs21.realpath.native);
+    if (typeof fs22.realpath.native === "function") {
+      exports2.realpath.native = u(fs22.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -3980,7 +3980,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults2 = { mode: 511 };
@@ -3989,14 +3989,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs21.mkdir(dir, {
+      return fs22.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs21.mkdirSync(dir, {
+      return fs22.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -4028,13 +4028,13 @@ var require_path_exists = __commonJS({
   "node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     function pathExists(path4) {
-      return fs21.access(path4).then(() => true).catch(() => false);
+      return fs22.access(path4).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs21.existsSync
+      pathExistsSync: fs22.existsSync
     };
   }
 });
@@ -4043,16 +4043,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     var u = require_universalify().fromPromise;
     async function utimesMillis(path4, atime, mtime) {
-      const fd = await fs21.open(path4, "r+");
+      const fd = await fs22.open(path4, "r+");
       let closeErr = null;
       try {
-        await fs21.futimes(fd, atime, mtime);
+        await fs22.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs21.close(fd);
+          await fs22.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -4062,9 +4062,9 @@ var require_utimes = __commonJS({
       }
     }
     function utimesMillisSync(path4, atime, mtime) {
-      const fd = fs21.openSync(path4, "r+");
-      fs21.futimesSync(fd, atime, mtime);
-      return fs21.closeSync(fd);
+      const fd = fs22.openSync(path4, "r+");
+      fs22.futimesSync(fd, atime, mtime);
+      return fs22.closeSync(fd);
     }
     module2.exports = {
       utimesMillis: u(utimesMillis),
@@ -4077,11 +4077,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     var path4 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs21.stat(file, { bigint: true }) : (file) => fs21.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs22.stat(file, { bigint: true }) : (file) => fs22.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -4092,7 +4092,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs21.statSync(file, { bigint: true }) : (file) => fs21.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs22.statSync(file, { bigint: true }) : (file) => fs22.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -4154,7 +4154,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path4.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs21.stat(destParent, { bigint: true });
+        destStat = await fs22.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -4170,7 +4170,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path4.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs21.statSync(destParent, { bigint: true });
+        destStat = fs22.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -4237,7 +4237,7 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     var path4 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
@@ -4273,7 +4273,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs21.stat : fs21.lstat;
+      const statFn = opts.dereference ? fs22.stat : fs22.lstat;
       const srcStat = await statFn(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -4285,7 +4285,7 @@ var require_copy = __commonJS({
     async function onFile(srcStat, destStat, src, dest, opts) {
       if (!destStat) return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs21.unlink(dest);
+        await fs22.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -4293,27 +4293,27 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs21.copyFile(src, dest);
+      await fs22.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs21.stat(src);
+        const updatedSrcStat = await fs22.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs21.chmod(dest, srcStat.mode);
+      return fs22.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs21.chmod(dest, srcMode | 128);
+      return fs22.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs21.mkdir(dest);
+        await fs22.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs21.opendir(src), async (item) => {
+      await asyncIteratorConcurrentProcess(await fs22.opendir(src), async (item) => {
         const srcItem = path4.join(src, item.name);
         const destItem = path4.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
@@ -4323,22 +4323,22 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs21.chmod(dest, srcStat.mode);
+        await fs22.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs21.readlink(src);
+      let resolvedSrc = await fs22.readlink(src);
       if (opts.dereference) {
         resolvedSrc = path4.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs21.symlink(resolvedSrc, dest);
+        return fs22.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs21.readlink(dest);
+        resolvedDest = await fs22.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs21.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs22.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
@@ -4352,8 +4352,8 @@ var require_copy = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs21.unlink(dest);
-      return fs21.symlink(resolvedSrc, dest);
+      await fs22.unlink(dest);
+      return fs22.symlink(resolvedSrc, dest);
     }
     module2.exports = copy;
   }
@@ -4363,7 +4363,7 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs21 = require_graceful_fs();
+    var fs22 = require_graceful_fs();
     var path4 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
@@ -4386,11 +4386,11 @@ var require_copy_sync = __commonJS({
       stat.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
       const destParent = path4.dirname(dest);
-      if (!fs21.existsSync(destParent)) mkdirsSync(destParent);
+      if (!fs22.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs21.statSync : fs21.lstatSync;
+      const statSync = opts.dereference ? fs22.statSync : fs22.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -4405,14 +4405,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs21.unlinkSync(dest);
+        fs22.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs21.copyFileSync(src, dest);
+      fs22.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -4427,10 +4427,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs21.chmodSync(dest, srcMode);
+      return fs22.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs21.statSync(src);
+      const updatedSrcStat = fs22.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -4438,12 +4438,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs21.mkdirSync(dest);
+      fs22.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs21.opendirSync(src);
+      const dir = fs22.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -4461,18 +4461,18 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs21.readlinkSync(src);
+      let resolvedSrc = fs22.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path4.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs21.symlinkSync(resolvedSrc, dest);
+        return fs22.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs21.readlinkSync(dest);
+          resolvedDest = fs22.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs21.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs22.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -4490,8 +4490,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs21.unlinkSync(dest);
-      return fs21.symlinkSync(resolvedSrc, dest);
+      fs22.unlinkSync(dest);
+      return fs22.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -4513,13 +4513,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs21 = require_graceful_fs();
+    var fs22 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     function remove(path4, callback) {
-      fs21.rm(path4, { recursive: true, force: true }, callback);
+      fs22.rm(path4, { recursive: true, force: true }, callback);
     }
     function removeSync(path4) {
-      fs21.rmSync(path4, { recursive: true, force: true });
+      fs22.rmSync(path4, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u(remove),
@@ -4533,14 +4533,14 @@ var require_empty = __commonJS({
   "node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     var path4 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs21.readdir(dir);
+        items = await fs22.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
@@ -4549,7 +4549,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs21.readdirSync(dir);
+        items = fs22.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
@@ -4573,51 +4573,51 @@ var require_file = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path4 = require("path");
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs21.stat(file);
+        stats = await fs22.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path4.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs21.stat(dir);
+        dirStats = await fs22.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs21.writeFile(file, "");
+          await fs22.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs21.writeFile(file, "");
+        await fs22.writeFile(file, "");
       } else {
-        await fs21.readdir(dir);
+        await fs22.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs21.statSync(file);
+        stats = fs22.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path4.dirname(file);
       try {
-        if (!fs21.statSync(dir).isDirectory()) {
-          fs21.readdirSync(dir);
+        if (!fs22.statSync(dir).isDirectory()) {
+          fs22.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs21.writeFileSync(file, "");
+      fs22.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -4632,19 +4632,19 @@ var require_link = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path4 = require("path");
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     var mkdir = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs21.lstat(dstpath);
+        dstStat = await fs22.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs21.lstat(srcpath);
+        srcStat = await fs22.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
@@ -4655,26 +4655,26 @@ var require_link = __commonJS({
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs21.link(srcpath, dstpath);
+      await fs22.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs21.lstatSync(dstpath);
+        dstStat = fs22.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs21.lstatSync(srcpath);
+        const srcStat = fs22.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       const dir = path4.dirname(dstpath);
-      const dirExists = fs21.existsSync(dir);
-      if (dirExists) return fs21.linkSync(srcpath, dstpath);
+      const dirExists = fs22.existsSync(dir);
+      if (dirExists) return fs22.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs21.linkSync(srcpath, dstpath);
+      return fs22.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -4688,13 +4688,13 @@ var require_symlink_paths = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
     var path4 = require("path");
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
       if (path4.isAbsolute(srcpath)) {
         try {
-          await fs21.lstat(srcpath);
+          await fs22.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -4714,7 +4714,7 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs21.lstat(srcpath);
+        await fs22.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
@@ -4726,7 +4726,7 @@ var require_symlink_paths = __commonJS({
     }
     function symlinkPathsSync(srcpath, dstpath) {
       if (path4.isAbsolute(srcpath)) {
-        const exists2 = fs21.existsSync(srcpath);
+        const exists2 = fs22.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
@@ -4735,14 +4735,14 @@ var require_symlink_paths = __commonJS({
       }
       const dstdir = path4.dirname(dstpath);
       const relativeToDst = path4.join(dstdir, srcpath);
-      const exists = fs21.existsSync(relativeToDst);
+      const exists = fs22.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs21.existsSync(srcpath);
+      const srcExists = fs22.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
@@ -4760,13 +4760,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs21.lstat(srcpath);
+        stats = await fs22.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -4776,7 +4776,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs21.lstatSync(srcpath);
+        stats = fs22.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -4795,7 +4795,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path4 = require("path");
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -4804,13 +4804,13 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs21.lstat(dstpath);
+        stats = await fs22.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs21.stat(srcpath),
-          fs21.stat(dstpath)
+          fs22.stat(srcpath),
+          fs22.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
@@ -4821,27 +4821,27 @@ var require_symlink = __commonJS({
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs21.symlink(srcpath, dstpath, toType);
+      return fs22.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs21.lstatSync(dstpath);
+        stats = fs22.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs21.statSync(srcpath);
-        const dstStat = fs21.statSync(dstpath);
+        const srcStat = fs22.statSync(srcpath);
+        const dstStat = fs22.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative2 = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative2.toDst;
       type = symlinkTypeSync(relative2.toCwd, type);
       const dir = path4.dirname(dstpath);
-      const exists = fs21.existsSync(dir);
-      if (exists) return fs21.symlinkSync(srcpath, dstpath, type);
+      const exists = fs22.existsSync(dir);
+      if (exists) return fs22.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs21.symlinkSync(srcpath, dstpath, type);
+      return fs22.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -4910,9 +4910,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs21 = options.fs || _fs;
+      const fs22 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs21.readFile)(file, options);
+      let data = await universalify.fromCallback(fs22.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -4932,10 +4932,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs21 = options.fs || _fs;
+      const fs22 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs21.readFileSync(file, options);
+        let content = fs22.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -4948,15 +4948,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs21 = options.fs || _fs;
+      const fs22 = options.fs || _fs;
       const str = stringify2(obj, options);
-      await universalify.fromCallback(fs21.writeFile)(file, str, options);
+      await universalify.fromCallback(fs22.writeFile)(file, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync4(file, obj, options = {}) {
-      const fs21 = options.fs || _fs;
+      const fs22 = options.fs || _fs;
       const str = stringify2(obj, options);
-      return fs21.writeFileSync(file, str, options);
+      return fs22.writeFileSync(file, str, options);
     }
     module2.exports = {
       readFile,
@@ -4987,7 +4987,7 @@ var require_output_file = __commonJS({
   "node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     var path4 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
@@ -4996,14 +4996,14 @@ var require_output_file = __commonJS({
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs21.writeFile(file, data, encoding);
+      return fs22.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
       const dir = path4.dirname(file);
-      if (!fs21.existsSync(dir)) {
+      if (!fs22.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs21.writeFileSync(file, ...args);
+      fs22.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -5062,7 +5062,7 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs21 = require_fs();
+    var fs22 = require_fs();
     var path4 = require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
@@ -5089,7 +5089,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs21.rename(src, dest);
+        await fs22.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -5114,7 +5114,7 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs21 = require_graceful_fs();
+    var fs22 = require_graceful_fs();
     var path4 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
@@ -5139,12 +5139,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs21.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs22.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs21.renameSync(src, dest);
+        fs22.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -19200,7 +19200,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join18(s) {
+        value: function join19(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -28077,10 +28077,10 @@ var require_lib2 = __commonJS({
     exports2.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve2, reject) => {
       let fd;
-      const fs21 = (0, node_1.default)();
+      const fs22 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs21.closeSync(fd);
+          fs22.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -28092,9 +28092,9 @@ var require_lib2 = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs21.openSync(filepath, "r");
+        fd = fs22.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs21.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs22.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -28106,22 +28106,22 @@ var require_lib2 = __commonJS({
         });
         return;
       }
-      fs21.readFile(filepath, handler);
+      fs22.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs21 = (0, node_1.default)();
+      const fs22 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs21.openSync(filepath, "r");
+        const fd = fs22.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs21.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs22.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs21.closeSync(fd);
+        fs22.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs21.readFileSync(filepath));
+      return (0, exports2.detect)(fs22.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -52395,7 +52395,7 @@ var require_msal_node = __commonJS({
     var crypto5 = require("crypto");
     var msalCommon = require_lib6();
     var jwt2 = require_jsonwebtoken();
-    var fs21 = require("fs");
+    var fs22 = require("fs");
     var path4 = require("path");
     var Serializer = class {
       /**
@@ -62094,7 +62094,7 @@ Headers: ${JSON.stringify(headers)}`
         if (!identityEndpoint || !imdsEndpoint) {
           const fileDetectionPath = AZURE_ARC_FILE_DETECTION[process.platform];
           try {
-            fs21.accessSync(fileDetectionPath, fs21.constants.F_OK | fs21.constants.R_OK);
+            fs22.accessSync(fileDetectionPath, fs22.constants.F_OK | fs22.constants.R_OK);
             identityEndpoint = DEFAULT_AZURE_ARC_IDENTITY_ENDPOINT;
             imdsEndpoint = HIMDS_EXECUTABLE_HELPER_STRING;
           } catch (err) {
@@ -62206,7 +62206,7 @@ Headers: ${JSON.stringify(headers)}`
           }
           let secretFileSize;
           try {
-            secretFileSize = await fs21.statSync(secretFilePath).size;
+            secretFileSize = await fs22.statSync(secretFilePath).size;
           } catch (e) {
             throw createManagedIdentityError(unableToReadSecretFile);
           }
@@ -62215,7 +62215,7 @@ Headers: ${JSON.stringify(headers)}`
           }
           let secret;
           try {
-            secret = fs21.readFileSync(secretFilePath, EncodingTypes.UTF8);
+            secret = fs22.readFileSync(secretFilePath, EncodingTypes.UTF8);
           } catch (e) {
             throw createManagedIdentityError(unableToReadSecretFile);
           }
@@ -117204,7 +117204,7 @@ ${projectName}/
 \u2502   \u2514\u2500\u2500 ${projectName}.Api/             # Web API controllers and configuration
 \u251C\u2500\u2500 web/
 \u2502   \u2514\u2500\u2500 ${projectName.toLowerCase()}-web/              # React frontend (Vite + TypeScript + Tailwind)
-\u251C\u2500\u2500 docker-images/                       # Dockerfiles (backend + frontend)
+\u251C\u2500\u2500 docker-images/                       # Dockerfiles + docker-compose (backend + frontend)
 \u2514\u2500\u2500 tests/                               # Unit and integration tests
 \`\`\`
 
@@ -117740,6 +117740,19 @@ async function createDockerFiles(config, state, dryRun) {
     logSafeWriteResult(dockerignoreRelPath, dockerignoreResult);
     recordFile(state, "docker", dockerignoreRelPath, dockerignoreResult.hash);
   }
+  const dockerCompose = await loadTemplate("docker-compose.yml.template", projectName);
+  const composeRelPath = "docker-images/docker-compose.yml";
+  if (dryRun) {
+    logger.info(`Would create ${composeRelPath}`);
+  } else {
+    const composeResult = await safeWriteFile(
+      (0, import_path7.join)(projectDir, composeRelPath),
+      dockerCompose,
+      findKnownHash(state, "docker", composeRelPath)
+    );
+    logSafeWriteResult(composeRelPath, composeResult);
+    recordFile(state, "docker", composeRelPath, composeResult.hash);
+  }
   logger.success("Docker configuration created");
 }
 function checkGitIdentity(cwd) {
@@ -118185,6 +118198,7 @@ var initCommand = new Command("init").description("Initialize a new SmartStack p
       `  3. Start dev server: ${source_default.cyan("npm run dev")}`,
       "",
       source_default.yellow("Docker:"),
+      `  Build & run:    ${source_default.cyan("docker compose -f docker-images/docker-compose.yml up --build")}`,
       `  Build backend:  ${source_default.cyan(`docker build -t smartstack-${projectNameLower}-backend:latest -f docker-images/Dockerfile.backend .`)}`,
       `  Build frontend: ${source_default.cyan(`docker build -t smartstack-${projectNameLower}-frontend:latest -f docker-images/Dockerfile.frontend .`)}`,
       "",
@@ -123277,8 +123291,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs21 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs21);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs22 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs22);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = (0, import_node_url.fileURLToPath)(cwd);
     }
@@ -123836,8 +123850,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs21) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs21 });
+  newRoot(fs22) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs22 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -123865,8 +123879,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs21) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs21 });
+  newRoot(fs22) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs22 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -125378,6 +125392,11 @@ async function syncDockerFiles(projectDir, baseNamespace, dryRun) {
       template: "dockerignore.template",
       dest: (0, import_path8.join)(projectDir, ".dockerignore"),
       label: ".dockerignore"
+    },
+    {
+      template: "docker-compose.yml.template",
+      dest: (0, import_path8.join)(projectDir, "docker-images", "docker-compose.yml"),
+      label: "docker-images/docker-compose.yml"
     }
   ];
   for (const file of files) {
@@ -129948,10 +129967,154 @@ tmuxCommand.command("status").description("Show WSL development environment stat
   }
 });
 
+// src/commands/docker.ts
+var import_child_process12 = require("child_process");
+var import_path18 = require("path");
+var import_fs_extra16 = __toESM(require_lib());
+function checkDocker() {
+  try {
+    const version2 = (0, import_child_process12.spawnSync)("docker", ["--version"], {
+      encoding: "utf-8",
+      shell: true,
+      timeout: 5e3,
+      stdio: "pipe"
+    });
+    if (version2.status !== 0) {
+      return { installed: false, running: false };
+    }
+    const info = (0, import_child_process12.spawnSync)("docker", ["info"], {
+      encoding: "utf-8",
+      shell: true,
+      timeout: 1e4,
+      stdio: "pipe"
+    });
+    return { installed: true, running: info.status === 0 };
+  } catch {
+    return { installed: false, running: false };
+  }
+}
+function requireDocker() {
+  const status = checkDocker();
+  if (!status.installed) {
+    logger.error("Docker is not installed.");
+    console.log();
+    console.log(`  Install Docker Desktop: ${source_default.cyan("https://docs.docker.com/get-docker/")}`);
+    console.log(`  Then restart your terminal and try again.`);
+    console.log();
+    return false;
+  }
+  if (!status.running) {
+    logger.error("Docker is installed but the daemon is not running.");
+    console.log();
+    console.log(`  Start Docker Desktop and wait for it to be ready, then try again.`);
+    console.log();
+    return false;
+  }
+  return true;
+}
+function findComposeFile() {
+  const cwd = process.cwd();
+  const composePath = (0, import_path18.join)(cwd, "docker-images", "docker-compose.yml");
+  if (import_fs_extra16.default.existsSync(composePath)) {
+    return composePath;
+  }
+  return null;
+}
+function requireComposeFile() {
+  const composePath = findComposeFile();
+  if (!composePath) {
+    logger.error("No docker-compose.yml found in docker-images/");
+    console.log();
+    console.log(`  Make sure you are in a SmartStack project root directory.`);
+    console.log(`  Run ${source_default.cyan("ss upgrade")} to generate the Docker files.`);
+    console.log();
+    return null;
+  }
+  return composePath;
+}
+function runCompose(composePath, args) {
+  const result = (0, import_child_process12.spawnSync)("docker", ["compose", "-f", composePath, ...args], {
+    encoding: "utf-8",
+    shell: true,
+    stdio: "inherit",
+    cwd: process.cwd()
+  });
+  return result.status ?? 1;
+}
+var dockerCommand = new Command("docker").description("Build and run SmartStack Docker images").addCommand(
+  new Command("up").description("Build images and start containers").option("-d, --detach", "Run containers in the background").option("--no-build", "Skip image build, use existing images").action(async (options) => {
+    if (!requireDocker()) return;
+    const composePath = requireComposeFile();
+    if (!composePath) return;
+    logger.header("SmartStack Docker Up");
+    const args = ["up"];
+    if (options.build !== false) args.push("--build");
+    if (options.detach) args.push("-d");
+    const code = runCompose(composePath, args);
+    if (code !== 0) {
+      logger.error(`docker compose up exited with code ${code}`);
+      process.exitCode = code;
+    }
+  })
+).addCommand(
+  new Command("down").description("Stop and remove containers").option("-v, --volumes", "Also remove volumes").action(async (options) => {
+    if (!requireDocker()) return;
+    const composePath = requireComposeFile();
+    if (!composePath) return;
+    logger.header("SmartStack Docker Down");
+    const args = ["down"];
+    if (options.volumes) args.push("-v");
+    const code = runCompose(composePath, args);
+    if (code !== 0) {
+      logger.error(`docker compose down exited with code ${code}`);
+      process.exitCode = code;
+    }
+  })
+).addCommand(
+  new Command("build").description("Build images without starting containers").option("--no-cache", "Build without using cache").action(async (options) => {
+    if (!requireDocker()) return;
+    const composePath = requireComposeFile();
+    if (!composePath) return;
+    logger.header("SmartStack Docker Build");
+    const args = ["build"];
+    if (options.cache === false) args.push("--no-cache");
+    const code = runCompose(composePath, args);
+    if (code !== 0) {
+      logger.error(`docker compose build exited with code ${code}`);
+      process.exitCode = code;
+    }
+  })
+).addCommand(
+  new Command("status").description("Show container status").action(async () => {
+    if (!requireDocker()) return;
+    const composePath = requireComposeFile();
+    if (!composePath) return;
+    const code = runCompose(composePath, ["ps", "-a"]);
+    if (code !== 0) {
+      process.exitCode = code;
+    }
+  })
+).addCommand(
+  new Command("logs").description("Show container logs").option("-f, --follow", "Follow log output").option("--tail <lines>", "Number of lines to show from the end", "100").argument("[service]", "Service name (backend or frontend)").action(async (service, options) => {
+    if (!requireDocker()) return;
+    const composePath = requireComposeFile();
+    if (!composePath) return;
+    const args = ["logs", "--tail", options.tail];
+    if (options.follow) args.push("-f");
+    if (service) args.push(service);
+    const code = runCompose(composePath, args);
+    if (code !== 0) {
+      process.exitCode = code;
+    }
+  })
+).action(() => {
+  dockerCommand.outputHelp();
+});
+
 // src/index.ts
 var import_fs6 = require("fs");
-var import_path18 = require("path");
-var pkg = JSON.parse((0, import_fs6.readFileSync)((0, import_path18.join)(__dirname, "..", "package.json"), "utf-8"));
+var import_path19 = require("path");
+var pkg = JSON.parse((0, import_fs6.readFileSync)((0, import_path19.join)(__dirname, "..", "package.json"), "utf-8"));
 var LICENSE_FREE_COMMANDS = ["license", "doctor", "help", "--help", "-h", "--version", "-v"];
 async function main2() {
   const program2 = new Command();
@@ -129971,6 +130134,7 @@ async function main2() {
   program2.addCommand(mcpCommand);
   program2.addCommand(businessAnalyseHandoffCommand);
   program2.addCommand(tmuxCommand);
+  program2.addCommand(dockerCommand);
   const args = process.argv.slice(2);
   const commandName = args[0] || "";
   const requiresLicense = !LICENSE_FREE_COMMANDS.some(