@swmansion/argent 0.29.1-next.19 → 0.29.1-next.20

package/dist/cli-cmds.mjs

@@ -7377,322 +7377,395 @@ var require_dist = __commonJS({
   }
 });
 
-// ../../node_modules/dotenv/lib/main.js
-var require_main = __commonJS({
-  "../../node_modules/dotenv/lib/main.js"(exports, module) {
-    var fs18 = __require("fs");
-    var path24 = __require("path");
-    var os4 = __require("os");
-    var crypto3 = __require("crypto");
-    var TIPS = [
-      "\u25C8 encrypted .env [www.dotenvx.com]",
-      "\u25C8 secrets for agents [www.dotenvx.com]",
-      "\u2301 auth for agents [www.vestauth.com]",
-      "\u2318 custom filepath { path: '/custom/path/.env' }",
-      "\u2318 enable debugging { debug: true }",
-      "\u2318 override existing { override: true }",
-      "\u2318 suppress logs { quiet: true }",
-      "\u2318 multiple files { path: ['.env.local', '.env'] }"
-    ];
-    function _getRandomTip() {
-      return TIPS[Math.floor(Math.random() * TIPS.length)];
-    }
-    function parseBoolean(value) {
-      if (typeof value === "string") {
-        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
-      }
-      return Boolean(value);
-    }
-    function supportsAnsi() {
-      return process.stdout.isTTY;
-    }
-    function dim2(text2) {
-      return supportsAnsi() ? `\x1B[2m${text2}\x1B[0m` : text2;
-    }
-    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
-    function parse3(src) {
-      const obj = {};
-      let lines = src.toString();
-      lines = lines.replace(/\r\n?/mg, "\n");
-      let match;
-      while ((match = LINE.exec(lines)) != null) {
-        const key = match[1];
-        let value = match[2] || "";
-        value = value.trim();
-        const maybeQuote = value[0];
-        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
-        if (maybeQuote === '"') {
-          value = value.replace(/\\n/g, "\n");
-          value = value.replace(/\\r/g, "\r");
-        }
-        obj[key] = value;
-      }
-      return obj;
-    }
-    function _parseVault(options) {
-      options = options || {};
-      const vaultPath = _vaultPath(options);
-      options.path = vaultPath;
-      const result = DotenvModule.configDotenv(options);
-      if (!result.parsed) {
-        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
-        err.code = "MISSING_DATA";
-        throw err;
+// ../../node_modules/dotenv/dist/index.cjs
+var require_dist2 = __commonJS({
+  "../../node_modules/dotenv/dist/index.cjs"(exports, module) {
+    var j = (e, n3) => () => {
+      try {
+        return n3 || e((n3 = { exports: {} }).exports, n3), n3.exports;
+      } catch (t2) {
+        throw n3 = 0, t2;
       }
-      const keys = _dotenvKey(options).split(",");
-      const length = keys.length;
-      let decrypted;
-      for (let i2 = 0; i2 < length; i2++) {
-        try {
-          const key = keys[i2].trim();
-          const attrs = _instructions(result, key);
-          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
-          break;
-        } catch (error63) {
-          if (i2 + 1 >= length) {
-            throw error63;
-          }
+    };
+    var k = j((xe, U2) => {
+      function G(e) {
+        return typeof e == "string" ? !["false", "0", "no", "off", ""].includes(e.toLowerCase()) : !!e;
+      }
+      function Y(e = process.env) {
+        let n3 = {};
+        for (let t2 of ["ENCODING", "PATH", "QUIET", "DEBUG", "OVERRIDE", "FAST"]) {
+          let o = e[`DOTENV_${t2}`] != null ? e[`DOTENV_${t2}`] : e[`DOTENV_CONFIG_${t2}`];
+          o != null && (n3[t2.toLowerCase()] = t2 === "ENCODING" || t2 === "PATH" ? o : G(o));
         }
+        return n3;
       }
-      return DotenvModule.parse(decrypted);
-    }
-    function _warn(message) {
-      console.error(`\u26A0 ${message}`);
-    }
-    function _debug(message) {
-      console.log(`\u2506 ${message}`);
-    }
-    function _log(message) {
-      console.log(`\u25C7 ${message}`);
-    }
-    function _dotenvKey(options) {
-      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
-        return options.DOTENV_KEY;
+      U2.exports = { parseBoolean: G, optionsFromEnv: Y };
+    });
+    var N = j((ye, x) => {
+      var z2 = __require("fs"), I2 = __require("path"), Z = __require("os"), { URL: ee, fileURLToPath: te } = __require("url"), { parseBoolean: $, optionsFromEnv: B } = k(), re2 = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg, b = new Uint8Array(256);
+      for (let e = 48; e <= 57; e++) b[e] = 1;
+      for (let e = 65; e <= 90; e++) b[e] = 1;
+      for (let e = 97; e <= 122; e++) b[e] = 1;
+      b[45] = 1;
+      b[46] = 1;
+      b[95] = 1;
+      function ne(e) {
+        let n3 = {}, t2 = e.toString();
+        t2 = t2.replace(/\r\n?/mg, `
+`);
+        let o;
+        for (; (o = re2.exec(t2)) != null; ) {
+          let r2 = o[1], s = o[2] || "";
+          s = s.trim();
+          let i2 = s[0];
+          s = s.replace(/^(['"`])([\s\S]*)\1$/mg, "$2"), i2 === '"' && (s = s.replace(/\\n/g, `
+`), s = s.replace(/\\r/g, "\r")), n3[r2] = s;
+        }
+        return n3;
       }
-      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
-        return process.env.DOTENV_KEY;
+      function w(e) {
+        return e <= 32 ? e === 32 || e >= 9 && e <= 13 : e >= 160 && (e === 160 || e === 5760 || e >= 8192 && e <= 8202 || e === 8232 || e === 8233 || e === 8239 || e === 8287 || e === 12288 || e === 65279);
       }
-      return "";
-    }
-    function _instructions(result, dotenvKey) {
-      let uri;
-      try {
-        uri = new URL(dotenvKey);
-      } catch (error63) {
-        if (error63.code === "ERR_INVALID_URL") {
-          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
-          err.code = "INVALID_DOTENV_KEY";
-          throw err;
+      function q(e) {
+        return e === 10 || e === 8232 || e === 8233;
+      }
+      function oe(e) {
+        let n3 = {}, t2 = typeof e == "string" ? e : e.toString();
+        t2.indexOf("\r") !== -1 && (t2 = t2.replace(/\r\n?/g, `
+`));
+        let o = t2.length, r2 = 0;
+        for (; r2 < o; ) {
+          let s = t2.charCodeAt(r2);
+          for (; r2 < o && w(s); ) r2++, s = t2.charCodeAt(r2);
+          if (r2 >= o) break;
+          if (s === 35) {
+            for (; r2 < o && !q(t2.charCodeAt(r2)); ) r2++;
+            continue;
+          }
+          let i2 = -1;
+          if (s === 101 && r2 + 6 < o && t2.charCodeAt(r2 + 1) === 120 && t2.charCodeAt(r2 + 2) === 112 && t2.charCodeAt(r2 + 3) === 111 && t2.charCodeAt(r2 + 4) === 114 && t2.charCodeAt(r2 + 5) === 116) {
+            let v = t2.charCodeAt(r2 + 6);
+            if (w(v)) {
+              let u3 = r2 + 7;
+              for (; u3 < o && w(t2.charCodeAt(u3)); ) u3++;
+              b[t2.charCodeAt(u3)] && (i2 = r2 + 6, r2 = u3);
+            } else s = t2.charCodeAt(r2);
+          }
+          let l2 = r2, d = 0;
+          for (; r2 < o && (d = t2.charCodeAt(r2), b[d]); ) r2++;
+          if (r2 === l2) {
+            for (; r2 < o && !q(t2.charCodeAt(r2)); ) r2++;
+            continue;
+          }
+          let h2 = t2.slice(l2, r2), f = r2;
+          if (r2 >= o && (d = 0), w(d)) do
+            r2++, d = r2 < o ? t2.charCodeAt(r2) : 0;
+          while (w(d));
+          if (d === 61) r2++;
+          else if (d === 58 && r2 === f && r2 + 1 < o && w(t2.charCodeAt(r2 + 1))) r2 += 2;
+          else {
+            for (r2 = i2 === -1 ? f : i2; r2 < o && !q(t2.charCodeAt(r2)); ) r2++;
+            continue;
+          }
+          let c2 = r2, a2 = r2;
+          for (; a2 < o && w(t2.charCodeAt(a2)); ) a2++;
+          let g = t2.charCodeAt(a2), p, y2 = false;
+          if (g === 39 || g === 34 || g === 96) {
+            let v = t2[a2], u3 = t2.indexOf(v, a2 + 1), m = -1, C = -1;
+            for (; u3 !== -1; ) {
+              let O = t2.charCodeAt(u3 - 1) === 92, E = u3 + 1;
+              for (; E < o && !q(t2.charCodeAt(E)) && w(t2.charCodeAt(E)); ) E++;
+              if ((E === o || q(t2.charCodeAt(E)) || t2.charCodeAt(E) === 35) && (m = u3, C = E), !O) break;
+              u3 = t2.indexOf(v, u3 + 1);
+            }
+            if (m !== -1) {
+              if (p = t2.slice(a2 + 1, m), r2 = C, t2.charCodeAt(r2) === 35) for (; r2 < o && !q(t2.charCodeAt(r2)); ) r2++;
+              y2 = true;
+            }
+          }
+          if (!y2) {
+            let v = t2.indexOf(`
+`, c2);
+            v === -1 && (v = o);
+            let u3;
+            if (o < 4096) u3 = t2.indexOf("#", c2), (u3 === -1 || u3 > v) && (u3 = v);
+            else for (u3 = c2; u3 < v && t2.charCodeAt(u3) !== 35; ) u3++;
+            let m = c2, C = u3;
+            for (; m < C && w(t2.charCodeAt(m)); ) m++;
+            for (; C > m && w(t2.charCodeAt(C - 1)); ) C--;
+            let O = t2.charCodeAt(m);
+            if (p = t2.slice(m, C), p.includes("\u2028") || p.includes("\u2029") ? p = p.replace(/^(['"`])([\s\S]*)\1$/mg, "$2") : C - m >= 2 && (O === 39 || O === 34 || O === 96) && t2.charCodeAt(C - 1) === O && (p = t2.slice(m + 1, C - 1)), r2 = u3, u3 < v) for (; r2 < o && !q(t2.charCodeAt(r2)); ) r2++;
+          }
+          g === 34 && (y2 || a2 < r2) && p.indexOf("\\") !== -1 && (p = p.replace(/\\n/g, `
+`).replace(/\\r/g, "\r")), n3[h2] = p;
         }
-        throw error63;
+        return n3;
       }
-      const key = uri.password;
-      if (!key) {
-        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
+      function se(e, n3) {
+        return n3 && $(n3.fast) ? oe(e) : ne(e);
       }
-      const environment = uri.searchParams.get("environment");
-      if (!environment) {
-        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
+      function T(e) {
+        console.log(`\u2506 ${e}`);
       }
-      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
-      const ciphertext = result.parsed[environmentKey];
-      if (!ciphertext) {
-        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
-        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
-        throw err;
+      function ie(e) {
+        console.error(`\u25C7 ${e}`);
       }
-      return { ciphertext, key };
-    }
-    function _vaultPath(options) {
-      let possibleVaultPath = null;
-      if (options && options.path && options.path.length > 0) {
-        if (Array.isArray(options.path)) {
-          for (const filepath of options.path) {
-            if (fs18.existsSync(filepath)) {
-              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
-            }
+      function V(e) {
+        return e[0] === "~" ? I2.join(Z.homedir(), e.slice(1)) : e;
+      }
+      function ce(e = {}) {
+        let n3 = { ...e };
+        for (let t2 of Object.keys(n3)) n3[t2] === void 0 && delete n3[t2];
+        return { ...B(), ...n3 };
+      }
+      function ae(e) {
+        e = ce(e);
+        let n3 = I2.resolve(process.cwd(), ".env"), t2 = "utf8", o = process.env;
+        e && e.processEnv != null && (o = e.processEnv);
+        let r2 = $(e && e.debug);
+        e && e.encoding ? t2 = e.encoding : r2 && T("no encoding is specified (UTF-8 is used by default)");
+        let s = [n3];
+        if (e && e.path) if (!Array.isArray(e.path)) s = [V(e.path)];
+        else {
+          s = [];
+          for (let c2 of e.path) s.push(V(c2));
+        }
+        let i2, l2 = {}, d = { fast: e.fast };
+        for (let c2 of s) try {
+          let a2 = A.parse(z2.readFileSync(c2, { encoding: t2 }), d);
+          A.populate(l2, a2, e);
+        } catch (a2) {
+          r2 && T(`failed to load ${c2} ${a2.message}`), i2 = a2;
+        }
+        let h2 = A.populate(o, l2, e), f = $(Object.prototype.hasOwnProperty.call(e, "quiet") ? e.quiet : B(o).quiet);
+        if (r2 || !f) {
+          let c2 = Object.keys(h2).length, a2 = [];
+          for (let g of s) try {
+            let p = I2.relative(process.cwd(), g instanceof ee ? te(g) : g);
+            a2.push(p);
+          } catch (p) {
+            r2 && T(`failed to load ${g} ${p.message}`), i2 = p;
           }
-        } else {
-          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+          ie(`injected env (${c2}) from ${a2.join(",")}`);
         }
-      } else {
-        possibleVaultPath = path24.resolve(process.cwd(), ".env.vault");
+        return i2 ? { parsed: l2, error: i2 } : { parsed: l2 };
       }
-      if (fs18.existsSync(possibleVaultPath)) {
-        return possibleVaultPath;
+      function le(e) {
+        return A.configDotenv(e);
       }
-      return null;
-    }
-    function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path24.join(os4.homedir(), envPath.slice(1)) : envPath;
-    }
-    function _configVault(options) {
-      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
-      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
-      if (debug || !quiet) {
-        _log("loading env from encrypted .env.vault");
-      }
-      const parsed = DotenvModule._parseVault(options);
-      let processEnv = process.env;
-      if (options && options.processEnv != null) {
-        processEnv = options.processEnv;
-      }
-      DotenvModule.populate(processEnv, parsed, options);
-      return { parsed };
-    }
-    function configDotenv(options) {
-      const dotenvPath = path24.resolve(process.cwd(), ".env");
-      let encoding = "utf8";
-      let processEnv = process.env;
-      if (options && options.processEnv != null) {
-        processEnv = options.processEnv;
-      }
-      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
-      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
-      if (options && options.encoding) {
-        encoding = options.encoding;
-      } else {
-        if (debug) {
-          _debug("no encoding is specified (UTF-8 is used by default)");
+      function fe(e, n3, t2 = {}) {
+        let o = $(t2 && t2.debug), r2 = $(t2 && t2.override), s = {};
+        if (e === null || typeof e != "object" || n3 === null || typeof n3 != "object") {
+          let i2 = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+          throw i2.code = "OBJECT_REQUIRED", i2;
         }
+        for (let i2 of Object.keys(n3)) Object.prototype.hasOwnProperty.call(e, i2) ? (r2 === true && (e[i2] = n3[i2], s[i2] = n3[i2]), o && T(r2 === true ? `"${i2}" is already defined and WAS overwritten` : `"${i2}" is already defined and was NOT overwritten`)) : (e[i2] = n3[i2], s[i2] = n3[i2]);
+        return s;
       }
-      let optionPaths = [dotenvPath];
-      if (options && options.path) {
-        if (!Array.isArray(options.path)) {
-          optionPaths = [_resolveHome(options.path)];
-        } else {
-          optionPaths = [];
-          for (const filepath of options.path) {
-            optionPaths.push(_resolveHome(filepath));
+      var A = { configDotenv: ae, config: le, parse: se, populate: fe };
+      x.exports.configDotenv = A.configDotenv;
+      x.exports.config = A.config;
+      x.exports.parse = A.parse;
+      x.exports.populate = A.populate;
+      x.exports = A;
+    });
+    var M = j((Te, W2) => {
+      var _ = __require("child_process"), ue = __require("fs"), L = __require("path");
+      function de(e) {
+        let n3 = ['"'], t2 = 0;
+        for (let o of e) {
+          if (o === "\\") {
+            t2++;
+            continue;
           }
+          o === '"' ? n3.push("\\".repeat(t2 * 2 + 1), '"') : n3.push("\\".repeat(t2), o), t2 = 0;
         }
+        return n3.push("\\".repeat(t2 * 2), '"'), n3.join("");
       }
-      let lastError;
-      const parsedAll = {};
-      for (const path25 of optionPaths) {
-        try {
-          const parsed = DotenvModule.parse(fs18.readFileSync(path25, { encoding }));
-          DotenvModule.populate(parsedAll, parsed, options);
-        } catch (e) {
-          if (debug) {
-            _debug(`failed to load ${path25} ${e.message}`);
+      function H(e, n3 = 1) {
+        for (let t2 = 0; t2 < n3; t2++) {
+          let o = [];
+          for (let r2 of e) {
+            let s = r2.charCodeAt(0), i2 = s >= 48 && s <= 57 || s >= 65 && s <= 90 || s >= 97 && s <= 122, l2 = "\\/:._-".includes(r2);
+            !i2 && !l2 && s < 128 && o.push("^"), o.push(r2);
           }
-          lastError = e;
+          e = o.join("");
         }
+        return e;
+      }
+      function P(e, n3) {
+        let t2 = Object.keys(e).reverse().find((o) => o.toUpperCase() === n3);
+        return t2 === void 0 ? void 0 : e[t2];
       }
-      const populated = DotenvModule.populate(processEnv, parsedAll, options);
-      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
-      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
-      if (debug || !quiet) {
-        const keysCount = Object.keys(populated).length;
-        const shortPaths = [];
-        for (const filePath of optionPaths) {
+      function pe(e, n3, t2) {
+        let o = (P(n3, "PATHEXT") || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean), s = o.some((l2) => e.toLowerCase().endsWith(l2.toLowerCase())) ? ["", ...o] : [...o, ""], i2 = /[\\/]/.test(e) ? [t2] : [t2, ...(P(n3, "PATH") || "").split(";")];
+        for (let l2 of i2) for (let d of s) {
+          let h2 = L.resolve(t2, l2.replace(/^"|"$/g, ""), e + d);
           try {
-            const relative3 = path24.relative(process.cwd(), filePath);
-            shortPaths.push(relative3);
-          } catch (e) {
-            if (debug) {
-              _debug(`failed to load ${filePath} ${e.message}`);
-            }
-            lastError = e;
+            if (ue.statSync(h2).isFile()) return h2;
+          } catch {
           }
         }
-        _log(`injected env (${keysCount}) from ${shortPaths.join(",")} ${dim2(`// tip: ${_getRandomTip()}`)}`);
       }
-      if (lastError) {
-        return { parsed: parsedAll, error: lastError };
-      } else {
-        return { parsed: parsedAll };
-      }
-    }
-    function config3(options) {
-      if (_dotenvKey(options).length === 0) {
-        return DotenvModule.configDotenv(options);
+      function he(e, n3, t2) {
+        if (process.platform !== "win32") return _.spawn(e, n3, t2);
+        let o = t2.env || process.env, r2 = pe(e, o, t2.cwd || process.cwd());
+        if (r2 && /\.(?:exe|com)$/i.test(r2)) return _.spawn(r2, n3, t2);
+        let s = /\.(?:bat|cmd)$/i.test(r2 || e), i2 = [H(L.normalize(r2 || e))];
+        for (let d of n3) i2.push(H(de(d), s ? 2 : 1));
+        let l2 = i2.join(" ");
+        return _.spawn(P(o, "COMSPEC") || "cmd.exe", ["/d", "/v:off", "/s", "/c", `"${l2}"`], { ...t2, windowsVerbatimArguments: true });
       }
-      const vaultPath = _vaultPath(options);
-      if (!vaultPath) {
-        _warn(`you set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}`);
-        return DotenvModule.configDotenv(options);
+      W2.exports = he;
+    });
+    var X = j(($e, F) => {
+      var ge = __require("fs"), me = __require("os"), Q = __require("path"), ve = __require("child_process"), Ce = M(), R2 = N(), { optionsFromEnv: J } = k();
+      function D() {
+        console.log(["Usage: dotenv run [--help] [-q|--quiet] [--debug] [--override] [--fast] [-f|--file <paths>] [--] <command> [args...]", "", "Run a command with environment variables from a .env file.", "Place dotenv options before the command; all following arguments go to the command.", "", "Options:", "  -f, --file <paths>  .env paths, comma-separated or repeated (default: .env)", "  -q, --quiet suppress the injected env message", "  --debug     enable debug logging", "  --override  override existing environment variables", "  --fast      use the faster character-scanner parser", "", "Environment variables (DOTENV_CONFIG_* names remain as fallbacks):", "  DOTENV_PATH, DOTENV_ENCODING, DOTENV_QUIET,", "  DOTENV_DEBUG, DOTENV_OVERRIDE,", "  DOTENV_FAST"].join(`
+`));
       }
-      return DotenvModule._configVault(options);
-    }
-    function decrypt(encrypted, keyStr) {
-      const key = Buffer.from(keyStr.slice(-64), "hex");
-      let ciphertext = Buffer.from(encrypted, "base64");
-      const nonce = ciphertext.subarray(0, 12);
-      const authTag = ciphertext.subarray(-16);
-      ciphertext = ciphertext.subarray(12, -16);
-      try {
-        const aesgcm = crypto3.createDecipheriv("aes-256-gcm", key, nonce);
-        aesgcm.setAuthTag(authTag);
-        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
-      } catch (error63) {
-        const isRange = error63 instanceof RangeError;
-        const invalidKeyLength = error63.message === "Invalid key length";
-        const decryptionFailed = error63.message === "Unsupported state or unable to authenticate data";
-        if (isRange || invalidKeyLength) {
-          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
-          err.code = "INVALID_DOTENV_KEY";
-          throw err;
-        } else if (decryptionFailed) {
-          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
-          err.code = "DECRYPTION_FAILED";
-          throw err;
-        } else {
-          throw error63;
+      function we(e) {
+        let n3 = [], t2 = false, o, r2, s, i2, l2 = -1;
+        for (let h2 = 0; h2 < e.length; h2++) {
+          let f = e[h2];
+          if (f === "--") {
+            l2 = h2 + 1;
+            break;
+          }
+          if (f === "--help" || f === "-h") return { help: true };
+          if (f === "--quiet" || f === "-q") {
+            o = true;
+            continue;
+          }
+          if (f === "--debug") {
+            r2 = true;
+            continue;
+          }
+          if (f === "--override") {
+            s = true;
+            continue;
+          }
+          if (f === "--fast") {
+            i2 = true;
+            continue;
+          }
+          if (f === "-f" || f === "--file" || f.startsWith("-f=") || f.startsWith("--file=")) {
+            let c2 = f.indexOf("="), a2 = c2 === -1 ? f : f.slice(0, c2), g = c2 === -1 ? e[++h2] : f.slice(c2 + 1);
+            if (!g || g === "--") return { error: `${a2} requires a path` };
+            let p = g.split(",").map((y2) => y2.trim()).filter(Boolean);
+            if (p.length === 0) return { error: `${a2} requires a path` };
+            n3.push(...p), t2 = true;
+            continue;
+          }
+          if (f.startsWith("-")) return { error: `unknown option: ${f}` };
+          l2 = h2;
+          break;
         }
+        let d = l2 === -1 ? [] : e.slice(l2);
+        return { paths: n3, pathSet: t2, quiet: o, debug: r2, override: s, fast: i2, command: d };
       }
-    }
-    function populate(processEnv, parsed, options = {}) {
-      const debug = Boolean(options && options.debug);
-      const override = Boolean(options && options.override);
-      const populated = {};
-      if (typeof parsed !== "object") {
-        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
-        err.code = "OBJECT_REQUIRED";
-        throw err;
+      function Ae(e) {
+        return e[0] === "~" ? Q.join(me.homedir(), e.slice(1)) : e;
       }
-      for (const key of Object.keys(parsed)) {
-        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
-          if (override === true) {
-            processEnv[key] = parsed[key];
-            populated[key] = parsed[key];
+      function Ee(e) {
+        let n3 = J(), t2 = { encoding: n3.encoding || "utf8", quiet: n3.quiet, debug: n3.debug === true, override: n3.override === true, fast: n3.fast === true, paths: [".env"], defaultPath: true };
+        return n3.path != null && (t2.paths = [n3.path], t2.defaultPath = false), e.pathSet && (t2.paths = e.paths, t2.defaultPath = false), e.quiet != null && (t2.quiet = e.quiet), e.debug != null && (t2.debug = e.debug), e.override != null && (t2.override = e.override), e.fast != null && (t2.fast = e.fast), t2;
+      }
+      function be(e) {
+        let n3 = {}, t2 = [], o = { override: e.override, debug: e.debug };
+        for (let s of e.paths) {
+          let i2 = Q.resolve(process.cwd(), Ae(s));
+          try {
+            let l2 = R2.parse(ge.readFileSync(i2, { encoding: e.encoding }), { fast: e.fast });
+            R2.populate(n3, l2, o), t2.push(s);
+          } catch (l2) {
+            if (e.debug && console.log(`\u2506 failed to load ${s} ${l2.message}`), !(e.defaultPath && l2.code === "ENOENT")) throw l2;
           }
-          if (debug) {
-            if (override === true) {
-              _debug(`"${key}" is already defined and WAS overwritten`);
-            } else {
-              _debug(`"${key}" is already defined and was NOT overwritten`);
+        }
+        return { injected: R2.populate(process.env, n3, o), loadedPaths: t2 };
+      }
+      function K(e) {
+        let n3 = e[0];
+        if (n3 === "--help" || n3 === "-h") {
+          D();
+          return;
+        }
+        if (n3 !== "run") {
+          D(), process.exitCode = 1;
+          return;
+        }
+        let t2 = we(e.slice(1));
+        if (t2.help) {
+          D();
+          return;
+        }
+        if (t2.error) {
+          console.error(`dotenv: ${t2.error}`), D(), process.exitCode = 1;
+          return;
+        }
+        if (t2.command.length === 0) {
+          D(), process.exitCode = 1;
+          return;
+        }
+        let o = Ee(t2);
+        try {
+          let c2 = be(o);
+          if (!(o.quiet == null ? J().quiet : o.quiet)) {
+            let g = `\u25C7 injected env (${Object.keys(c2.injected).length})`;
+            c2.loadedPaths.length > 0 && (g += ` from ${c2.loadedPaths.join(", ")}`), console.error(g);
+          }
+        } catch (c2) {
+          console.error(`dotenv: ${c2.message}`), process.exitCode = 1;
+          return;
+        }
+        let r2 = !!process.stdin.isTTY, s = process.platform !== "win32" && !r2, i2 = Ce(t2.command[0], t2.command.slice(1), { stdio: "inherit", detached: s }), l2 = /* @__PURE__ */ new Map(), d = 0;
+        function h2(c2) {
+          if (!(!i2.pid || i2.exitCode !== null || i2.signalCode !== null)) {
+            if (process.platform === "win32") {
+              ve.spawnSync("taskkill", ["/pid", String(i2.pid), "/T", "/F"], { stdio: "ignore" });
+              return;
+            }
+            try {
+              process.kill(s ? -i2.pid : i2.pid, c2);
+            } catch (a2) {
+              if (a2.code !== "ESRCH") throw a2;
             }
           }
-        } else {
-          processEnv[key] = parsed[key];
-          populated[key] = parsed[key];
         }
+        function f() {
+          for (let [c2, a2] of l2) process.removeListener(c2, a2);
+        }
+        for (let c2 of ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"]) {
+          let a2 = () => {
+            if (c2 === "SIGINT") {
+              if (d++, r2 && process.platform !== "win32" && d === 1) return;
+              if (d > 1) {
+                h2(d === 2 ? "SIGTERM" : "SIGKILL");
+                return;
+              }
+            }
+            h2(c2);
+          };
+          l2.set(c2, a2), process.on(c2, a2);
+        }
+        i2.on("error", function(c2) {
+          f(), console.error(`dotenv: ${c2.message}`), process.exitCode = 1;
+        }), i2.on("exit", function(c2, a2) {
+          f(), typeof c2 == "number" ? process.exit(c2) : (setInterval(() => {
+          }, 1e3), process.kill(process.pid, a2));
+        });
       }
-      return populated;
-    }
-    var DotenvModule = {
-      configDotenv,
-      _configVault,
-      _parseVault,
-      config: config3,
-      decrypt,
-      parse: parse3,
-      populate
-    };
-    module.exports.configDotenv = DotenvModule.configDotenv;
-    module.exports._configVault = DotenvModule._configVault;
-    module.exports._parseVault = DotenvModule._parseVault;
-    module.exports.config = DotenvModule.config;
-    module.exports.decrypt = DotenvModule.decrypt;
-    module.exports.parse = DotenvModule.parse;
-    module.exports.populate = DotenvModule.populate;
-    module.exports = DotenvModule;
+      F.exports = K;
+      __require.main === F && K(process.argv.slice(2));
+    });
+    var S = N();
+    var qe = X();
+    module.exports = S;
+    module.exports.config = S.config;
+    module.exports.configDotenv = S.configDotenv;
+    module.exports.parse = S.parse;
+    module.exports.populate = S.populate;
+    __require.main === module && qe(process.argv.slice(2));
   }
 });
 
@@ -31104,7 +31177,7 @@ function updateConfig(mutate, scope = "global", options = {}) {
 }
 
 // ../configuration-core/src/secrets.ts
-var import_dotenv = __toESM(require_main(), 1);
+var import_dotenv = __toESM(require_dist2(), 1);
 import * as fs5 from "node:fs";
 import * as path10 from "node:path";
 var SECRET_ENV_PREFIX = "ARGENT_SECRET_";
@@ -35306,7 +35379,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID2 = randomUUID5();
 function readCliVersion() {
   if (true) {
-    return "0.29.1-next.19";
+    return "0.29.1-next.20";
   }
   return "0.0.0";
 }