@uipath/rpa-tool 0.2.1 → 0.9.1

package/dist/index.js

@@ -34,8 +34,8 @@ var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports,
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/commander/lib/error.js
-var require_error2 = __commonJS((exports) => {
-  class CommanderError2 extends Error {
+var require_error = __commonJS((exports) => {
+  class CommanderError extends Error {
     constructor(exitCode, code, message) {
       super(message);
       Error.captureStackTrace(this, this.constructor);
@@ -46,22 +46,22 @@ var require_error2 = __commonJS((exports) => {
     }
   }
 
-  class InvalidArgumentError2 extends CommanderError2 {
+  class InvalidArgumentError extends CommanderError {
     constructor(message) {
       super(1, "commander.invalidArgument", message);
       Error.captureStackTrace(this, this.constructor);
       this.name = this.constructor.name;
     }
   }
-  exports.CommanderError = CommanderError2;
-  exports.InvalidArgumentError = InvalidArgumentError2;
+  exports.CommanderError = CommanderError;
+  exports.InvalidArgumentError = InvalidArgumentError;
 });
 
 // node_modules/commander/lib/argument.js
-var require_argument2 = __commonJS((exports) => {
-  var { InvalidArgumentError: InvalidArgumentError2 } = require_error2();
+var require_argument = __commonJS((exports) => {
+  var { InvalidArgumentError } = require_error();
 
-  class Argument2 {
+  class Argument {
     constructor(name, description) {
       this.description = description || "";
       this.variadic = false;
@@ -111,7 +111,7 @@ var require_argument2 = __commonJS((exports) => {
       this.argChoices = values.slice();
       this.parseArg = (arg, previous) => {
         if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError2(`Allowed choices are ${this.argChoices.join(", ")}.`);
+          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
         }
         if (this.variadic) {
           return this._collectValue(arg, previous);
@@ -133,15 +133,15 @@ var require_argument2 = __commonJS((exports) => {
     const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
     return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
   }
-  exports.Argument = Argument2;
+  exports.Argument = Argument;
   exports.humanReadableArgName = humanReadableArgName;
 });
 
 // node_modules/commander/lib/help.js
-var require_help2 = __commonJS((exports) => {
-  var { humanReadableArgName } = require_argument2();
+var require_help = __commonJS((exports) => {
+  var { humanReadableArgName } = require_argument();
 
-  class Help2 {
+  class Help {
     constructor() {
       this.helpWidth = undefined;
       this.minWidthToWrap = 40;
@@ -359,24 +359,24 @@ var require_help2 = __commonJS((exports) => {
         });
         output = output.concat(this.formatItemList("Global Options:", globalOptionList, helper));
       }
-      const commandGroups = this.groupItems(cmd.commands, helper.visibleCommands(cmd), (sub2) => sub2.helpGroup() || "Commands:");
+      const commandGroups = this.groupItems(cmd.commands, helper.visibleCommands(cmd), (sub) => sub.helpGroup() || "Commands:");
       commandGroups.forEach((commands, group) => {
-        const commandList = commands.map((sub2) => {
-          return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(sub2)), helper.styleSubcommandDescription(helper.subcommandDescription(sub2)));
+        const commandList = commands.map((sub) => {
+          return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(sub)), helper.styleSubcommandDescription(helper.subcommandDescription(sub)));
         });
         output = output.concat(this.formatItemList(group, commandList, helper));
       });
       return output.join(`
 `);
     }
-    displayWidth(str2) {
-      return stripColor(str2).length;
+    displayWidth(str) {
+      return stripColor(str).length;
     }
-    styleTitle(str2) {
-      return str2;
+    styleTitle(str) {
+      return str;
     }
-    styleUsage(str2) {
-      return str2.split(" ").map((word) => {
+    styleUsage(str) {
+      return str.split(" ").map((word) => {
         if (word === "[options]")
           return this.styleOptionText(word);
         if (word === "[command]")
@@ -386,26 +386,26 @@ var require_help2 = __commonJS((exports) => {
         return this.styleCommandText(word);
       }).join(" ");
     }
-    styleCommandDescription(str2) {
-      return this.styleDescriptionText(str2);
+    styleCommandDescription(str) {
+      return this.styleDescriptionText(str);
     }
-    styleOptionDescription(str2) {
-      return this.styleDescriptionText(str2);
+    styleOptionDescription(str) {
+      return this.styleDescriptionText(str);
     }
-    styleSubcommandDescription(str2) {
-      return this.styleDescriptionText(str2);
+    styleSubcommandDescription(str) {
+      return this.styleDescriptionText(str);
     }
-    styleArgumentDescription(str2) {
-      return this.styleDescriptionText(str2);
+    styleArgumentDescription(str) {
+      return this.styleDescriptionText(str);
     }
-    styleDescriptionText(str2) {
-      return str2;
+    styleDescriptionText(str) {
+      return str;
     }
-    styleOptionTerm(str2) {
-      return this.styleOptionText(str2);
+    styleOptionTerm(str) {
+      return this.styleOptionText(str);
     }
-    styleSubcommandTerm(str2) {
-      return str2.split(" ").map((word) => {
+    styleSubcommandTerm(str) {
+      return str.split(" ").map((word) => {
         if (word === "[options]")
           return this.styleOptionText(word);
         if (word[0] === "[" || word[0] === "<")
@@ -413,26 +413,26 @@ var require_help2 = __commonJS((exports) => {
         return this.styleSubcommandText(word);
       }).join(" ");
     }
-    styleArgumentTerm(str2) {
-      return this.styleArgumentText(str2);
+    styleArgumentTerm(str) {
+      return this.styleArgumentText(str);
     }
-    styleOptionText(str2) {
-      return str2;
+    styleOptionText(str) {
+      return str;
     }
-    styleArgumentText(str2) {
-      return str2;
+    styleArgumentText(str) {
+      return str;
     }
-    styleSubcommandText(str2) {
-      return str2;
+    styleSubcommandText(str) {
+      return str;
     }
-    styleCommandText(str2) {
-      return str2;
+    styleCommandText(str) {
+      return str;
     }
     padWidth(cmd, helper) {
       return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
     }
-    preformatted(str2) {
-      return /\n[^\S\r\n]/.test(str2);
+    preformatted(str) {
+      return /\n[^\S\r\n]/.test(str);
     }
     formatItem(term, termWidth, description, helper) {
       const itemIndent = 2;
@@ -454,10 +454,10 @@ var require_help2 = __commonJS((exports) => {
       return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
 ${itemIndentStr}`);
     }
-    boxWrap(str2, width) {
+    boxWrap(str, width) {
       if (width < this.minWidthToWrap)
-        return str2;
-      const rawLines = str2.split(/\r\n|\n/);
+        return str;
+      const rawLines = str.split(/\r\n|\n/);
       const chunkPattern = /[\s]*[^\s]+/g;
       const wrappedLines = [];
       rawLines.forEach((line) => {
@@ -486,19 +486,19 @@ ${itemIndentStr}`);
 `);
     }
   }
-  function stripColor(str2) {
+  function stripColor(str) {
     const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
-    return str2.replace(sgrPattern, "");
+    return str.replace(sgrPattern, "");
   }
-  exports.Help = Help2;
+  exports.Help = Help;
   exports.stripColor = stripColor;
 });
 
 // node_modules/commander/lib/option.js
-var require_option2 = __commonJS((exports) => {
-  var { InvalidArgumentError: InvalidArgumentError2 } = require_error2();
+var require_option = __commonJS((exports) => {
+  var { InvalidArgumentError } = require_error();
 
-  class Option2 {
+  class Option {
     constructor(flags, description) {
       this.flags = flags;
       this.description = description || "";
@@ -572,7 +572,7 @@ var require_option2 = __commonJS((exports) => {
       this.argChoices = values.slice();
       this.parseArg = (arg, previous) => {
         if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError2(`Allowed choices are ${this.argChoices.join(", ")}.`);
+          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
         }
         if (this.variadic) {
           return this._collectValue(arg, previous);
@@ -632,9 +632,9 @@ var require_option2 = __commonJS((exports) => {
       return option.negate === (negativeValue === value);
     }
   }
-  function camelcase(str2) {
-    return str2.split("-").reduce((str3, word) => {
-      return str3 + word[0].toUpperCase() + word.slice(1);
+  function camelcase(str) {
+    return str.split("-").reduce((str2, word) => {
+      return str2 + word[0].toUpperCase() + word.slice(1);
     });
   }
   function splitOptionFlags(flags) {
@@ -674,34 +674,34 @@ var require_option2 = __commonJS((exports) => {
       throw new Error(`option creation failed due to no flags found in '${flags}'.`);
     return { shortFlag, longFlag };
   }
-  exports.Option = Option2;
+  exports.Option = Option;
   exports.DualOptions = DualOptions;
 });
 
 // node_modules/commander/lib/suggestSimilar.js
-var require_suggestSimilar2 = __commonJS((exports) => {
+var require_suggestSimilar = __commonJS((exports) => {
   var maxDistance = 3;
   function editDistance(a, b) {
     if (Math.abs(a.length - b.length) > maxDistance)
       return Math.max(a.length, b.length);
     const d = [];
-    for (let i2 = 0;i2 <= a.length; i2++) {
-      d[i2] = [i2];
+    for (let i = 0;i <= a.length; i++) {
+      d[i] = [i];
     }
     for (let j = 0;j <= b.length; j++) {
       d[0][j] = j;
     }
     for (let j = 1;j <= b.length; j++) {
-      for (let i2 = 1;i2 <= a.length; i2++) {
+      for (let i = 1;i <= a.length; i++) {
         let cost = 1;
-        if (a[i2 - 1] === b[j - 1]) {
+        if (a[i - 1] === b[j - 1]) {
           cost = 0;
         } else {
           cost = 1;
         }
-        d[i2][j] = Math.min(d[i2 - 1][j] + 1, d[i2][j - 1] + 1, d[i2 - 1][j - 1] + cost);
-        if (i2 > 1 && j > 1 && a[i2 - 1] === b[j - 2] && a[i2 - 2] === b[j - 1]) {
-          d[i2][j] = Math.min(d[i2][j], d[i2 - 2][j - 2] + 1);
+        d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+          d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
         }
       }
     }
@@ -752,19 +752,19 @@ var require_suggestSimilar2 = __commonJS((exports) => {
 });
 
 // node_modules/commander/lib/command.js
-var require_command2 = __commonJS((exports) => {
+var require_command = __commonJS((exports) => {
   var EventEmitter = __require("node:events").EventEmitter;
   var childProcess = __require("node:child_process");
   var path = __require("node:path");
   var fs = __require("node:fs");
   var process2 = __require("node:process");
-  var { Argument: Argument2, humanReadableArgName } = require_argument2();
-  var { CommanderError: CommanderError2 } = require_error2();
-  var { Help: Help2, stripColor } = require_help2();
-  var { Option: Option2, DualOptions } = require_option2();
-  var { suggestSimilar } = require_suggestSimilar2();
+  var { Argument, humanReadableArgName } = require_argument();
+  var { CommanderError } = require_error();
+  var { Help, stripColor } = require_help();
+  var { Option, DualOptions } = require_option();
+  var { suggestSimilar } = require_suggestSimilar();
 
-  class Command2 extends EventEmitter {
+  class Command extends EventEmitter {
     constructor(name) {
       super();
       this.commands = [];
@@ -800,14 +800,14 @@ var require_command2 = __commonJS((exports) => {
       this._showSuggestionAfterError = true;
       this._savedState = null;
       this._outputConfiguration = {
-        writeOut: (str2) => process2.stdout.write(str2),
-        writeErr: (str2) => process2.stderr.write(str2),
-        outputError: (str2, write) => write(str2),
+        writeOut: (str) => process2.stdout.write(str),
+        writeErr: (str) => process2.stderr.write(str),
+        outputError: (str, write) => write(str),
         getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
         getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
         getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
         getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
-        stripColor: (str2) => stripColor(str2)
+        stripColor: (str) => stripColor(str)
       };
       this._hidden = false;
       this._helpOption = undefined;
@@ -867,10 +867,10 @@ var require_command2 = __commonJS((exports) => {
       return cmd;
     }
     createCommand(name) {
-      return new Command2(name);
+      return new Command(name);
     }
     createHelp() {
-      return Object.assign(new Help2, this.configureHelp());
+      return Object.assign(new Help, this.configureHelp());
     }
     configureHelp(configuration) {
       if (configuration === undefined)
@@ -913,7 +913,7 @@ var require_command2 = __commonJS((exports) => {
       return this;
     }
     createArgument(name, description) {
-      return new Argument2(name, description);
+      return new Argument(name, description);
     }
     argument(name, description, parseArg, defaultValue) {
       const argument = this.createArgument(name, description);
@@ -1012,7 +1012,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     _exit(exitCode, code, message) {
       if (this._exitCallback) {
-        this._exitCallback(new CommanderError2(exitCode, code, message));
+        this._exitCallback(new CommanderError(exitCode, code, message));
       }
       process2.exit(exitCode);
     }
@@ -1032,7 +1032,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return this;
     }
     createOption(flags, description) {
-      return new Option2(flags, description);
+      return new Option(flags, description);
     }
     _callParseArg(target, value, previous, invalidArgumentMessage) {
       try {
@@ -1114,7 +1114,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return this;
     }
     _optionEx(config, flags, description, fn, defaultValue) {
-      if (typeof flags === "object" && flags instanceof Option2) {
+      if (typeof flags === "object" && flags instanceof Option) {
         throw new Error("To add an Option object use addOption() instead of option() or requiredOption()");
       }
       const option = this.createOption(flags, description);
@@ -1370,7 +1370,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (!exitCallback) {
           process2.exit(code);
         } else {
-          exitCallback(new CommanderError2(code, "commander.executeSubCommandAsync", "(close)"));
+          exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
         }
       });
       proc.on("error", (err) => {
@@ -1382,7 +1382,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (!exitCallback) {
           process2.exit(1);
         } else {
-          const wrappedError = new CommanderError2(1, "commander.executeSubCommandAsync", "(error)");
+          const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
           wrappedError.nestedError = err;
           exitCallback(wrappedError);
         }
@@ -1416,8 +1416,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return this._dispatchSubcommand(subcommandName, [], [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"]);
     }
     _checkNumberOfArguments() {
-      this.registeredArguments.forEach((arg, i2) => {
-        if (arg.required && this.args[i2] == null) {
+      this.registeredArguments.forEach((arg, i) => {
+        if (arg.required && this.args[i] == null) {
           this.missingArgument(arg.name());
         }
       });
@@ -1439,11 +1439,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
       };
       this._checkNumberOfArguments();
       const processedArgs = [];
-      this.registeredArguments.forEach((declaredArg, index2) => {
+      this.registeredArguments.forEach((declaredArg, index) => {
         let value = declaredArg.defaultValue;
         if (declaredArg.variadic) {
-          if (index2 < this.args.length) {
-            value = this.args.slice(index2);
+          if (index < this.args.length) {
+            value = this.args.slice(index);
             if (declaredArg.parseArg) {
               value = value.reduce((processed, v) => {
                 return myParseArg(declaredArg, v, processed);
@@ -1452,13 +1452,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } else if (value === undefined) {
             value = [];
           }
-        } else if (index2 < this.args.length) {
-          value = this.args[index2];
+        } else if (index < this.args.length) {
+          value = this.args[index];
           if (declaredArg.parseArg) {
             value = myParseArg(declaredArg, value, declaredArg.defaultValue);
           }
         }
-        processedArgs[index2] = value;
+        processedArgs[index] = value;
       });
       this.processedArgs = processedArgs;
     }
@@ -1470,16 +1470,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     _chainOrCallHooks(promise, event) {
       let result = promise;
-      const hooks2 = [];
+      const hooks = [];
       this._getCommandAndAncestors().reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== undefined).forEach((hookedCommand) => {
         hookedCommand._lifeCycleHooks[event].forEach((callback) => {
-          hooks2.push({ hookedCommand, callback });
+          hooks.push({ hookedCommand, callback });
         });
       });
       if (event === "postAction") {
-        hooks2.reverse();
+        hooks.reverse();
       }
-      hooks2.forEach((hookDetail) => {
+      hooks.forEach((hookDetail) => {
         result = this._chainOrCall(result, () => {
           return hookDetail.callback(hookDetail.hookedCommand, this);
         });
@@ -1616,14 +1616,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
       };
       let activeVariadicOption = null;
       let activeGroup = null;
-      let i2 = 0;
-      while (i2 < args.length || activeGroup) {
-        const arg = activeGroup ?? args[i2++];
+      let i = 0;
+      while (i < args.length || activeGroup) {
+        const arg = activeGroup ?? args[i++];
         activeGroup = null;
         if (arg === "--") {
           if (dest === unknown)
             dest.push(arg);
-          dest.push(...args.slice(i2));
+          dest.push(...args.slice(i));
           break;
         }
         if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) {
@@ -1635,14 +1635,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
           const option = this._findOption(arg);
           if (option) {
             if (option.required) {
-              const value = args[i2++];
+              const value = args[i++];
               if (value === undefined)
                 this.optionMissingArgument(option);
               this.emit(`option:${option.name()}`, value);
             } else if (option.optional) {
               let value = null;
-              if (i2 < args.length && (!maybeOption(args[i2]) || negativeNumberArg(args[i2]))) {
-                value = args[i2++];
+              if (i < args.length && (!maybeOption(args[i]) || negativeNumberArg(args[i]))) {
+                value = args[i++];
               }
               this.emit(`option:${option.name()}`, value);
             } else {
@@ -1665,10 +1665,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
         }
         if (/^--[^=]+=/.test(arg)) {
-          const index2 = arg.indexOf("=");
-          const option = this._findOption(arg.slice(0, index2));
+          const index = arg.indexOf("=");
+          const option = this._findOption(arg.slice(0, index));
           if (option && (option.required || option.optional)) {
-            this.emit(`option:${option.name()}`, arg.slice(index2 + 1));
+            this.emit(`option:${option.name()}`, arg.slice(index + 1));
             continue;
           }
         }
@@ -1678,18 +1678,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
           if (this._findCommand(arg)) {
             operands.push(arg);
-            unknown.push(...args.slice(i2));
+            unknown.push(...args.slice(i));
             break;
           } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
-            operands.push(arg, ...args.slice(i2));
+            operands.push(arg, ...args.slice(i));
             break;
           } else if (this._defaultCommandName) {
-            unknown.push(arg, ...args.slice(i2));
+            unknown.push(arg, ...args.slice(i));
             break;
           }
         }
         if (this._passThroughOptions) {
-          dest.push(arg, ...args.slice(i2));
+          dest.push(arg, ...args.slice(i));
           break;
         }
         dest.push(arg);
@@ -1700,8 +1700,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (this._storeOptionsAsProperties) {
         const result = {};
         const len = this.options.length;
-        for (let i2 = 0;i2 < len; i2++) {
-          const key = this.options[i2].attributeName();
+        for (let i = 0;i < len; i++) {
+          const key = this.options[i].attributeName();
           result[key] = key === this._versionOptionName ? this._version : this[key];
         }
         return result;
@@ -1828,35 +1828,35 @@ Expecting one of '${allowedValues.join("', '")}'`);
       const message = `error: unknown command '${unknownName}'${suggestion}`;
       this.error(message, { code: "commander.unknownCommand" });
     }
-    version(str2, flags, description) {
-      if (str2 === undefined)
+    version(str, flags, description) {
+      if (str === undefined)
         return this._version;
-      this._version = str2;
+      this._version = str;
       flags = flags || "-V, --version";
       description = description || "output the version number";
       const versionOption = this.createOption(flags, description);
       this._versionOptionName = versionOption.attributeName();
       this._registerOption(versionOption);
       this.on("option:" + versionOption.name(), () => {
-        this._outputConfiguration.writeOut(`${str2}
+        this._outputConfiguration.writeOut(`${str}
 `);
-        this._exit(0, "commander.version", str2);
+        this._exit(0, "commander.version", str);
       });
       return this;
     }
-    description(str2, argsDescription) {
-      if (str2 === undefined && argsDescription === undefined)
+    description(str, argsDescription) {
+      if (str === undefined && argsDescription === undefined)
         return this._description;
-      this._description = str2;
+      this._description = str;
       if (argsDescription) {
         this._argsDescription = argsDescription;
       }
       return this;
     }
-    summary(str2) {
-      if (str2 === undefined)
+    summary(str) {
+      if (str === undefined)
         return this._summary;
-      this._summary = str2;
+      this._summary = str;
       return this;
     }
     alias(alias) {
@@ -1882,8 +1882,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
       aliases.forEach((alias) => this.alias(alias));
       return this;
     }
-    usage(str2) {
-      if (str2 === undefined) {
+    usage(str) {
+      if (str === undefined) {
         if (this._usage)
           return this._usage;
         const args = this.registeredArguments.map((arg) => {
@@ -1891,13 +1891,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
         });
         return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
       }
-      this._usage = str2;
+      this._usage = str;
       return this;
     }
-    name(str2) {
-      if (str2 === undefined)
+    name(str) {
+      if (str === undefined)
         return this._name;
-      this._name = str2;
+      this._name = str;
       return this;
     }
     helpGroup(heading) {
@@ -1956,18 +1956,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
       let hasColors;
       let helpWidth;
       if (error) {
-        baseWrite = (str2) => this._outputConfiguration.writeErr(str2);
+        baseWrite = (str) => this._outputConfiguration.writeErr(str);
         hasColors = this._outputConfiguration.getErrHasColors();
         helpWidth = this._outputConfiguration.getErrHelpWidth();
       } else {
-        baseWrite = (str2) => this._outputConfiguration.writeOut(str2);
+        baseWrite = (str) => this._outputConfiguration.writeOut(str);
         hasColors = this._outputConfiguration.getOutHasColors();
         helpWidth = this._outputConfiguration.getOutHelpWidth();
       }
-      const write = (str2) => {
+      const write = (str) => {
         if (!hasColors)
-          str2 = this._outputConfiguration.stripColor(str2);
-        return baseWrite(str2);
+          str = this._outputConfiguration.stripColor(str);
+        return baseWrite(str);
       };
       return { error, write, hasColors, helpWidth };
     }
@@ -2102,36 +2102,153 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return true;
     return;
   }
-  exports.Command = Command2;
+  exports.Command = Command;
   exports.useColor = useColor;
 });
 
 // node_modules/commander/index.js
-var require_commander2 = __commonJS((exports) => {
-  var { Argument: Argument2 } = require_argument2();
-  var { Command: Command2 } = require_command2();
-  var { CommanderError: CommanderError2, InvalidArgumentError: InvalidArgumentError2 } = require_error2();
-  var { Help: Help2 } = require_help2();
-  var { Option: Option2 } = require_option2();
-  exports.program = new Command2;
-  exports.createCommand = (name) => new Command2(name);
-  exports.createOption = (flags, description) => new Option2(flags, description);
-  exports.createArgument = (name, description) => new Argument2(name, description);
-  exports.Command = Command2;
-  exports.Option = Option2;
-  exports.Argument = Argument2;
-  exports.Help = Help2;
-  exports.CommanderError = CommanderError2;
-  exports.InvalidArgumentError = InvalidArgumentError2;
-  exports.InvalidOptionArgumentError = InvalidArgumentError2;
+var require_commander = __commonJS((exports) => {
+  var { Argument } = require_argument();
+  var { Command } = require_command();
+  var { CommanderError, InvalidArgumentError } = require_error();
+  var { Help } = require_help();
+  var { Option } = require_option();
+  exports.program = new Command;
+  exports.createCommand = (name) => new Command(name);
+  exports.createOption = (flags, description) => new Option(flags, description);
+  exports.createArgument = (name, description) => new Argument(name, description);
+  exports.Command = Command;
+  exports.Option = Option;
+  exports.Argument = Argument;
+  exports.Help = Help;
+  exports.CommanderError = CommanderError;
+  exports.InvalidArgumentError = InvalidArgumentError;
+  exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// src/safe-tmpdir.ts
+import {
+  lstatSync,
+  mkdirSync,
+  readlinkSync,
+  symlinkSync,
+  unlinkSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+var SHORT_TMPDIR_PREFIX = "/tmp/uip-";
+var MAX_SAFE_TMPDIR_LEN = 40;
+var cached;
+function safeTmpDir() {
+  if (cached !== undefined)
+    return cached;
+  cached = computeSafeTmpDir();
+  return cached;
+}
+function computeSafeTmpDir() {
+  const real = tmpdir();
+  if (process.platform === "win32" || real.length <= MAX_SAFE_TMPDIR_LEN) {
+    return withTrailingSeparator(real);
+  }
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  const linkPath = `${SHORT_TMPDIR_PREFIX}${uid}`;
+  try {
+    ensureSymlink(linkPath, real);
+    return withTrailingSeparator(linkPath);
+  } catch {
+    return withTrailingSeparator(real);
+  }
+}
+function ensureSymlink(linkPath, target) {
+  const normalizedTarget = target.replace(/[\\/]+$/, "");
+  let st;
+  try {
+    st = lstatSync(linkPath);
+  } catch {}
+  if (st) {
+    if (st.isSymbolicLink()) {
+      const current = readlinkSync(linkPath).replace(/[\\/]+$/, "");
+      if (current === normalizedTarget)
+        return;
+      unlinkSync(linkPath);
+    } else {}
+  }
+  mkdirSync(target, { recursive: true });
+  symlinkSync(normalizedTarget, linkPath, "dir");
+}
+function withTrailingSeparator(p) {
+  return p.endsWith("/") || p.endsWith("\\") ? p : `${p}/`;
+}
+
+// node_modules/commander/esm.mjs
+var import__ = __toESM(require_commander(), 1);
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError,
+  Command,
+  Argument,
+  Option,
+  Help
+} = import__.default;
+
+// src/commander-polyfill.ts
+if (!Command.prototype.trackedAction) {
+  Command.prototype.trackedAction = function(context, fn) {
+    return this.action(async (...args) => {
+      try {
+        await fn(...args);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Result: Failure
+Message: ${message}
+`);
+        context.exit(1);
+      }
+    });
+  };
+}
+
 // node_modules/@uipath/common/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
-import { appendFileSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { existsSync } from "node:fs";
+import * as fs6 from "node:fs/promises";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+import process8 from "node:process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import childProcess3 from "node:child_process";
+import fs5, { constants as fsConstants2 } from "node:fs/promises";
+import { promisify as promisify2 } from "node:util";
+import childProcess2 from "node:child_process";
+import fs4, { constants as fsConstants } from "node:fs/promises";
+import process2 from "node:process";
+import os from "node:os";
+import fs3 from "node:fs";
+import fs2 from "node:fs";
+import fs from "node:fs";
+import process3 from "node:process";
+import { Buffer as Buffer2 } from "node:buffer";
+import { promisify } from "node:util";
+import childProcess from "node:child_process";
+import { promisify as promisify6 } from "node:util";
+import process6 from "node:process";
+import { execFile as execFile6 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+import process4 from "node:process";
+import { execFile as execFile3 } from "node:child_process";
+import process5 from "node:process";
+import { promisify as promisify4 } from "node:util";
+import { execFile as execFile4, execFileSync } from "node:child_process";
+import { promisify as promisify5 } from "node:util";
+import { execFile as execFile5 } from "node:child_process";
+import process7 from "node:process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { execFileSync } from "node:child_process";
 import vm from "vm";
 var __create2 = Object.create;
 var __getProtoOf2 = Object.getPrototypeOf;
@@ -2147,9 +2264,9 @@ var __toESM2 = (mod, isNodeMode, target) => {
   var canCache = mod != null && typeof mod === "object";
   if (canCache) {
     var cache = isNodeMode ? __toESMCache_node2 ??= new WeakMap : __toESMCache_esm2 ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
+    var cached2 = cache.get(mod);
+    if (cached2)
+      return cached2;
   }
   target = mod != null ? __create2(__getProtoOf2(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target;
@@ -2165,9 +2282,9 @@ var __toESM2 = (mod, isNodeMode, target) => {
 };
 var __commonJS2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
-var require_error = __commonJS2((exports) => {
+var require_error2 = __commonJS2((exports) => {
 
-  class CommanderError extends Error {
+  class CommanderError2 extends Error {
     constructor(exitCode, code, message) {
       super(message);
       Error.captureStackTrace(this, this.constructor);
@@ -2178,20 +2295,20 @@ var require_error = __commonJS2((exports) => {
     }
   }
 
-  class InvalidArgumentError extends CommanderError {
+  class InvalidArgumentError2 extends CommanderError2 {
     constructor(message) {
       super(1, "commander.invalidArgument", message);
       Error.captureStackTrace(this, this.constructor);
       this.name = this.constructor.name;
     }
   }
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
+  exports.CommanderError = CommanderError2;
+  exports.InvalidArgumentError = InvalidArgumentError2;
 });
-var require_argument = __commonJS2((exports) => {
-  var { InvalidArgumentError } = require_error();
+var require_argument2 = __commonJS2((exports) => {
+  var { InvalidArgumentError: InvalidArgumentError2 } = require_error2();
 
-  class Argument {
+  class Argument2 {
     constructor(name, description) {
       this.description = description || "";
       this.variadic = false;
@@ -2241,7 +2358,7 @@ var require_argument = __commonJS2((exports) => {
       this.argChoices = values.slice();
       this.parseArg = (arg, previous) => {
         if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
+          throw new InvalidArgumentError2(`Allowed choices are ${this.argChoices.join(", ")}.`);
         }
         if (this.variadic) {
           return this._collectValue(arg, previous);
@@ -2263,13 +2380,13 @@ var require_argument = __commonJS2((exports) => {
     const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
     return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
   }
-  exports.Argument = Argument;
+  exports.Argument = Argument2;
   exports.humanReadableArgName = humanReadableArgName;
 });
-var require_help = __commonJS2((exports) => {
-  var { humanReadableArgName } = require_argument();
+var require_help2 = __commonJS2((exports) => {
+  var { humanReadableArgName } = require_argument2();
 
-  class Help {
+  class Help2 {
     constructor() {
       this.helpWidth = undefined;
       this.minWidthToWrap = 40;
@@ -2618,13 +2735,13 @@ ${itemIndentStr}`);
     const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
     return str.replace(sgrPattern, "");
   }
-  exports.Help = Help;
+  exports.Help = Help2;
   exports.stripColor = stripColor;
 });
-var require_option = __commonJS2((exports) => {
-  var { InvalidArgumentError } = require_error();
+var require_option2 = __commonJS2((exports) => {
+  var { InvalidArgumentError: InvalidArgumentError2 } = require_error2();
 
-  class Option {
+  class Option2 {
     constructor(flags, description) {
       this.flags = flags;
       this.description = description || "";
@@ -2698,7 +2815,7 @@ var require_option = __commonJS2((exports) => {
       this.argChoices = values.slice();
       this.parseArg = (arg, previous) => {
         if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
+          throw new InvalidArgumentError2(`Allowed choices are ${this.argChoices.join(", ")}.`);
         }
         if (this.variadic) {
           return this._collectValue(arg, previous);
@@ -2800,10 +2917,10 @@ var require_option = __commonJS2((exports) => {
       throw new Error(`option creation failed due to no flags found in '${flags}'.`);
     return { shortFlag, longFlag };
   }
-  exports.Option = Option;
+  exports.Option = Option2;
   exports.DualOptions = DualOptions;
 });
-var require_suggestSimilar = __commonJS2((exports) => {
+var require_suggestSimilar2 = __commonJS2((exports) => {
   var maxDistance = 3;
   function editDistance(a, b) {
     if (Math.abs(a.length - b.length) > maxDistance)
@@ -2874,19 +2991,19 @@ var require_suggestSimilar = __commonJS2((exports) => {
   }
   exports.suggestSimilar = suggestSimilar;
 });
-var require_command = __commonJS2((exports) => {
+var require_command2 = __commonJS2((exports) => {
   var EventEmitter = __require2("node:events").EventEmitter;
-  var childProcess = __require2("node:child_process");
-  var path = __require2("node:path");
-  var fs = __require2("node:fs");
-  var process2 = __require2("node:process");
-  var { Argument, humanReadableArgName } = require_argument();
-  var { CommanderError } = require_error();
-  var { Help, stripColor } = require_help();
-  var { Option, DualOptions } = require_option();
-  var { suggestSimilar } = require_suggestSimilar();
+  var childProcess4 = __require2("node:child_process");
+  var path3 = __require2("node:path");
+  var fs7 = __require2("node:fs");
+  var process22 = __require2("node:process");
+  var { Argument: Argument2, humanReadableArgName } = require_argument2();
+  var { CommanderError: CommanderError2 } = require_error2();
+  var { Help: Help2, stripColor } = require_help2();
+  var { Option: Option2, DualOptions } = require_option2();
+  var { suggestSimilar } = require_suggestSimilar2();
 
-  class Command extends EventEmitter {
+  class Command2 extends EventEmitter {
     constructor(name) {
       super();
       this.commands = [];
@@ -2922,13 +3039,13 @@ var require_command = __commonJS2((exports) => {
       this._showSuggestionAfterError = true;
       this._savedState = null;
       this._outputConfiguration = {
-        writeOut: (str) => process2.stdout.write(str),
-        writeErr: (str) => process2.stderr.write(str),
+        writeOut: (str) => process22.stdout.write(str),
+        writeErr: (str) => process22.stderr.write(str),
         outputError: (str, write) => write(str),
-        getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
-        getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
-        getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
-        getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
+        getOutHelpWidth: () => process22.stdout.isTTY ? process22.stdout.columns : undefined,
+        getErrHelpWidth: () => process22.stderr.isTTY ? process22.stderr.columns : undefined,
+        getOutHasColors: () => useColor() ?? (process22.stdout.isTTY && process22.stdout.hasColors?.()),
+        getErrHasColors: () => useColor() ?? (process22.stderr.isTTY && process22.stderr.hasColors?.()),
         stripColor: (str) => stripColor(str)
       };
       this._hidden = false;
@@ -2989,10 +3106,10 @@ var require_command = __commonJS2((exports) => {
       return cmd;
     }
     createCommand(name) {
-      return new Command(name);
+      return new Command2(name);
     }
     createHelp() {
-      return Object.assign(new Help, this.configureHelp());
+      return Object.assign(new Help2, this.configureHelp());
     }
     configureHelp(configuration) {
       if (configuration === undefined)
@@ -3035,7 +3152,7 @@ var require_command = __commonJS2((exports) => {
       return this;
     }
     createArgument(name, description) {
-      return new Argument(name, description);
+      return new Argument2(name, description);
     }
     argument(name, description, parseArg, defaultValue) {
       const argument = this.createArgument(name, description);
@@ -3134,9 +3251,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     _exit(exitCode, code, message) {
       if (this._exitCallback) {
-        this._exitCallback(new CommanderError(exitCode, code, message));
+        this._exitCallback(new CommanderError2(exitCode, code, message));
       }
-      process2.exit(exitCode);
+      process22.exit(exitCode);
     }
     action(fn) {
       const listener = (args) => {
@@ -3154,7 +3271,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return this;
     }
     createOption(flags, description) {
-      return new Option(flags, description);
+      return new Option2(flags, description);
     }
     _callParseArg(target, value, previous, invalidArgumentMessage) {
       try {
@@ -3236,7 +3353,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return this;
     }
     _optionEx(config, flags, description, fn, defaultValue) {
-      if (typeof flags === "object" && flags instanceof Option) {
+      if (typeof flags === "object" && flags instanceof Option2) {
         throw new Error("To add an Option object use addOption() instead of option() or requiredOption()");
       }
       const option = this.createOption(flags, description);
@@ -3333,16 +3450,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       parseOptions = parseOptions || {};
       if (argv === undefined && parseOptions.from === undefined) {
-        if (process2.versions?.electron) {
+        if (process22.versions?.electron) {
           parseOptions.from = "electron";
         }
-        const execArgv = process2.execArgv ?? [];
+        const execArgv = process22.execArgv ?? [];
         if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
           parseOptions.from = "eval";
         }
       }
       if (argv === undefined) {
-        argv = process2.argv;
+        argv = process22.argv;
       }
       this.rawArgs = argv.slice();
       let userArgs;
@@ -3353,7 +3470,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           userArgs = argv.slice(2);
           break;
         case "electron":
-          if (process2.defaultApp) {
+          if (process22.defaultApp) {
             this._scriptPath = argv[1];
             userArgs = argv.slice(2);
           } else {
@@ -3413,7 +3530,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this.processedArgs = [];
     }
     _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-      if (fs.existsSync(executableFile))
+      if (fs7.existsSync(executableFile))
         return;
       const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
       const executableMissing = `'${executableFile}' does not exist
@@ -3427,12 +3544,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
       let launchWithNode = false;
       const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
       function findFile(baseDir, baseName) {
-        const localBin = path.resolve(baseDir, baseName);
-        if (fs.existsSync(localBin))
+        const localBin = path3.resolve(baseDir, baseName);
+        if (fs7.existsSync(localBin))
           return localBin;
-        if (sourceExt.includes(path.extname(baseName)))
+        if (sourceExt.includes(path3.extname(baseName)))
           return;
-        const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
+        const foundExt = sourceExt.find((ext) => fs7.existsSync(`${localBin}${ext}`));
         if (foundExt)
           return `${localBin}${foundExt}`;
         return;
@@ -3444,42 +3561,42 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (this._scriptPath) {
         let resolvedScriptPath;
         try {
-          resolvedScriptPath = fs.realpathSync(this._scriptPath);
+          resolvedScriptPath = fs7.realpathSync(this._scriptPath);
         } catch {
           resolvedScriptPath = this._scriptPath;
         }
-        executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
+        executableDir = path3.resolve(path3.dirname(resolvedScriptPath), executableDir);
       }
       if (executableDir) {
         let localFile = findFile(executableDir, executableFile);
         if (!localFile && !subcommand._executableFile && this._scriptPath) {
-          const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
+          const legacyName = path3.basename(this._scriptPath, path3.extname(this._scriptPath));
           if (legacyName !== this._name) {
             localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
           }
         }
         executableFile = localFile || executableFile;
       }
-      launchWithNode = sourceExt.includes(path.extname(executableFile));
+      launchWithNode = sourceExt.includes(path3.extname(executableFile));
       let proc;
-      if (process2.platform !== "win32") {
+      if (process22.platform !== "win32") {
         if (launchWithNode) {
           args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-          proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
+          args = incrementNodeInspectorPort(process22.execArgv).concat(args);
+          proc = childProcess4.spawn(process22.argv[0], args, { stdio: "inherit" });
         } else {
-          proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
+          proc = childProcess4.spawn(executableFile, args, { stdio: "inherit" });
         }
       } else {
         this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
         args.unshift(executableFile);
-        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-        proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
+        args = incrementNodeInspectorPort(process22.execArgv).concat(args);
+        proc = childProcess4.spawn(process22.execPath, args, { stdio: "inherit" });
       }
       if (!proc.killed) {
         const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
         signals.forEach((signal) => {
-          process2.on(signal, () => {
+          process22.on(signal, () => {
             if (proc.killed === false && proc.exitCode === null) {
               proc.kill(signal);
             }
@@ -3490,9 +3607,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
       proc.on("close", (code) => {
         code = code ?? 1;
         if (!exitCallback) {
-          process2.exit(code);
+          process22.exit(code);
         } else {
-          exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
+          exitCallback(new CommanderError2(code, "commander.executeSubCommandAsync", "(close)"));
         }
       });
       proc.on("error", (err) => {
@@ -3502,9 +3619,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
           throw new Error(`'${executableFile}' not executable`);
         }
         if (!exitCallback) {
-          process2.exit(1);
+          process22.exit(1);
         } else {
-          const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
+          const wrappedError = new CommanderError2(1, "commander.executeSubCommandAsync", "(error)");
           wrappedError.nestedError = err;
           exitCallback(wrappedError);
         }
@@ -3851,11 +3968,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     _parseOptionsEnv() {
       this.options.forEach((option) => {
-        if (option.envVar && option.envVar in process2.env) {
+        if (option.envVar && option.envVar in process22.env) {
           const optionKey = option.attributeName();
           if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
             if (option.required || option.optional) {
-              this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
+              this.emit(`optionEnv:${option.name()}`, process22.env[option.envVar]);
             } else {
               this.emit(`optionEnv:${option.name()}`);
             }
@@ -4049,13 +4166,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
         cmd.helpGroup(this._defaultCommandGroup);
     }
     nameFromFilename(filename) {
-      this._name = path.basename(filename, path.extname(filename));
+      this._name = path3.basename(filename, path3.extname(filename));
       return this;
     }
-    executableDir(path2) {
-      if (path2 === undefined)
+    executableDir(path22) {
+      if (path22 === undefined)
         return this._executableDir;
-      this._executableDir = path2;
+      this._executableDir = path22;
       return this;
     }
     helpInformation(contextOptions) {
@@ -4152,7 +4269,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     help(contextOptions) {
       this.outputHelp(contextOptions);
-      let exitCode = Number(process2.exitCode ?? 0);
+      let exitCode = Number(process22.exitCode ?? 0);
       if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
         exitCode = 1;
       }
@@ -4218,47 +4335,44 @@ Expecting one of '${allowedValues.join("', '")}'`);
     });
   }
   function useColor() {
-    if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false")
+    if (process22.env.NO_COLOR || process22.env.FORCE_COLOR === "0" || process22.env.FORCE_COLOR === "false")
       return false;
-    if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== undefined)
+    if (process22.env.FORCE_COLOR || process22.env.CLICOLOR_FORCE !== undefined)
       return true;
     return;
   }
-  exports.Command = Command;
+  exports.Command = Command2;
   exports.useColor = useColor;
 });
-var require_commander = __commonJS2((exports) => {
-  var { Argument } = require_argument();
-  var { Command } = require_command();
-  var { CommanderError, InvalidArgumentError } = require_error();
-  var { Help } = require_help();
-  var { Option } = require_option();
-  exports.program = new Command;
-  exports.createCommand = (name) => new Command(name);
-  exports.createOption = (flags, description) => new Option(flags, description);
-  exports.createArgument = (name, description) => new Argument(name, description);
-  exports.Command = Command;
-  exports.Option = Option;
-  exports.Argument = Argument;
-  exports.Help = Help;
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-  exports.InvalidOptionArgumentError = InvalidArgumentError;
+var require_commander2 = __commonJS2((exports) => {
+  var { Argument: Argument2 } = require_argument2();
+  var { Command: Command2 } = require_command2();
+  var { CommanderError: CommanderError2, InvalidArgumentError: InvalidArgumentError2 } = require_error2();
+  var { Help: Help2 } = require_help2();
+  var { Option: Option2 } = require_option2();
+  exports.program = new Command2;
+  exports.createCommand = (name) => new Command2(name);
+  exports.createOption = (flags, description) => new Option2(flags, description);
+  exports.createArgument = (name, description) => new Argument2(name, description);
+  exports.Command = Command2;
+  exports.Option = Option2;
+  exports.Argument = Argument2;
+  exports.Help = Help2;
+  exports.CommanderError = CommanderError2;
+  exports.InvalidArgumentError = InvalidArgumentError2;
+  exports.InvalidOptionArgumentError = InvalidArgumentError2;
 });
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
 function catchError(fnOrPromise) {
-  if (fnOrPromise instanceof Promise) {
-    return fnOrPromise.then((data) => [undefined, data]).catch((error) => [
-      error instanceof Error ? error : new Error(String(error)),
-      undefined
-    ]);
+  if (isPromiseLike(fnOrPromise)) {
+    return settlePromiseLike(fnOrPromise);
   }
   try {
     const result = fnOrPromise();
-    if (result instanceof Promise) {
-      return result.then((data) => [undefined, data]).catch((error) => [
-        error instanceof Error ? error : new Error(String(error)),
-        undefined
-      ]);
+    if (isPromiseLike(result)) {
+      return settlePromiseLike(result);
     }
     return [undefined, result];
   } catch (error) {
@@ -4268,20 +4382,31 @@ function catchError(fnOrPromise) {
     ];
   }
 }
-var import__ = __toESM2(require_commander(), 1);
+function settlePromiseLike(thenable) {
+  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [
+    error instanceof Error ? error : new Error(String(error)),
+    undefined
+  ]);
+}
+var import__2 = __toESM2(require_commander2(), 1);
 var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  Command,
-  Argument,
-  Option,
-  Help
-} = import__.default;
+  program: program2,
+  createCommand: createCommand2,
+  createArgument: createArgument2,
+  createOption: createOption2,
+  CommanderError: CommanderError2,
+  InvalidArgumentError: InvalidArgumentError2,
+  InvalidOptionArgumentError: InvalidOptionArgumentError2,
+  Command: Command2,
+  Argument: Argument2,
+  Option: Option2,
+  Help: Help2
+} = import__2.default;
+var examplesByCommand = new WeakMap;
+Command2.prototype.examples = function(examples) {
+  examplesByCommand.set(this, examples);
+  return this;
+};
 var isObject = (obj) => {
   return obj !== null && Object.prototype.toString.call(obj) === "[object Object]";
 };
@@ -8885,6 +9010,669 @@ var dump = dumper.dump;
 var safeLoad = renamed("safeLoad", "load");
 var safeLoadAll = renamed("safeLoadAll", "loadAll");
 var safeDump = renamed("safeDump", "dump");
+var isDockerCached;
+function hasDockerEnv() {
+  try {
+    fs.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === undefined) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+var cachedResult;
+var hasContainerEnv = () => {
+  try {
+    fs2.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+function isInsideContainer() {
+  if (cachedResult === undefined) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+var isWsl = () => {
+  if (process2.platform !== "linux") {
+    return false;
+  }
+  if (os.release().toLowerCase().includes("microsoft")) {
+    if (isInsideContainer()) {
+      return false;
+    }
+    return true;
+  }
+  try {
+    if (fs3.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+      return !isInsideContainer();
+    }
+  } catch {}
+  if (fs3.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs3.existsSync("/run/WSL")) {
+    return !isInsideContainer();
+  }
+  return false;
+};
+var is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+var execFile = promisify(childProcess.execFile);
+var powerShellPath = () => `${process3.env.SYSTEMROOT || process3.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+var executePowerShell = async (command, options = {}) => {
+  const {
+    powerShellPath: psPath,
+    ...execFileOptions
+  } = options;
+  const encodedCommand = executePowerShell.encodeCommand(command);
+  return execFile(psPath ?? powerShellPath(), [
+    ...executePowerShell.argumentsPrefix,
+    encodedCommand
+  ], {
+    encoding: "utf8",
+    ...execFileOptions
+  });
+};
+executePowerShell.argumentsPrefix = [
+  "-NoProfile",
+  "-NonInteractive",
+  "-ExecutionPolicy",
+  "Bypass",
+  "-EncodedCommand"
+];
+executePowerShell.encodeCommand = (command) => Buffer2.from(command, "utf16le").toString("base64");
+executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
+function parseMountPointFromConfig(content) {
+  for (const line of content.split(`
+`)) {
+    if (/^\s*#/.test(line)) {
+      continue;
+    }
+    const match = /^\s*root\s*=\s*(?<mountPoint>"[^"]*"|'[^']*'|[^#]*)/.exec(line);
+    if (!match) {
+      continue;
+    }
+    return match.groups.mountPoint.trim().replaceAll(/^["']|["']$/g, "");
+  }
+}
+var execFile2 = promisify2(childProcess2.execFile);
+var wslDrivesMountPoint = (() => {
+  const defaultMountPoint = "/mnt/";
+  let mountPoint;
+  return async function() {
+    if (mountPoint) {
+      return mountPoint;
+    }
+    const configFilePath = "/etc/wsl.conf";
+    let isConfigFileExists = false;
+    try {
+      await fs4.access(configFilePath, fsConstants.F_OK);
+      isConfigFileExists = true;
+    } catch {}
+    if (!isConfigFileExists) {
+      return defaultMountPoint;
+    }
+    const configContent = await fs4.readFile(configFilePath, { encoding: "utf8" });
+    const parsedMountPoint = parseMountPointFromConfig(configContent);
+    if (parsedMountPoint === undefined) {
+      return defaultMountPoint;
+    }
+    mountPoint = parsedMountPoint;
+    mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+    return mountPoint;
+  };
+})();
+var powerShellPathFromWsl = async () => {
+  const mountPoint = await wslDrivesMountPoint();
+  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+var powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
+var canAccessPowerShellPromise;
+var canAccessPowerShell = async () => {
+  canAccessPowerShellPromise ??= (async () => {
+    try {
+      const psPath = await powerShellPath2();
+      await fs4.access(psPath, fsConstants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  return canAccessPowerShellPromise;
+};
+var wslDefaultBrowser = async () => {
+  const psPath = await powerShellPath2();
+  const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+  const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
+  return stdout.trim();
+};
+var convertWslPathToWindows = async (path3) => {
+  if (/^[a-z]+:\/\//i.test(path3)) {
+    return path3;
+  }
+  try {
+    const { stdout } = await execFile2("wslpath", ["-aw", path3], { encoding: "utf8" });
+    return stdout.trim();
+  } catch {
+    return path3;
+  }
+};
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define(result);
+      return result;
+    },
+    set(value) {
+      define(value);
+    }
+  });
+  return object;
+}
+var execFileAsync = promisify3(execFile3);
+async function defaultBrowserId() {
+  if (process4.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  const browserId = match?.groups.id ?? "com.apple.Safari";
+  if (browserId === "com.apple.safari") {
+    return "com.apple.Safari";
+  }
+  return browserId;
+}
+var execFileAsync2 = promisify4(execFile4);
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+  if (process5.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const execOptions = {};
+  if (signal) {
+    execOptions.signal = signal;
+  }
+  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
+  return stdout.trim();
+}
+async function bundleName(bundleId) {
+  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
+tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+var execFileAsync3 = promisify5(execFile5);
+var windowsBrowserProgIds = {
+  MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+  MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
+  MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
+  AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
+  ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+  ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
+  ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
+  ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
+  BraveHTML: { name: "Brave", id: "com.brave.Browser" },
+  BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
+  BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
+  BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
+  FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+  OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
+  VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
+  "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
+};
+var _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+
+class UnknownBrowserError extends Error {
+}
+async function defaultBrowser(_execFileAsync = execFileAsync3) {
+  const { stdout } = await _execFileAsync("reg", [
+    "QUERY",
+    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+    "/v",
+    "ProgId"
+  ]);
+  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match) {
+    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+  }
+  const { id } = match.groups;
+  const dotIndex = id.lastIndexOf(".");
+  const hyphenIndex = id.lastIndexOf("-");
+  const baseIdByDot = dotIndex === -1 ? undefined : id.slice(0, dotIndex);
+  const baseIdByHyphen = hyphenIndex === -1 ? undefined : id.slice(0, hyphenIndex);
+  return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? { name: id, id };
+}
+var execFileAsync4 = promisify6(execFile6);
+var titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+async function defaultBrowser2() {
+  if (process6.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (process6.platform === "linux") {
+    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (process6.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+var isInSsh = Boolean(process7.env.SSH_CONNECTION || process7.env.SSH_CLIENT || process7.env.SSH_TTY);
+var is_in_ssh_default = isInSsh;
+var fallbackAttemptSymbol = Symbol("fallbackAttempt");
+var __dirname2 = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : "";
+var localXdgOpenPath = path.join(__dirname2, "xdg-open");
+var { platform, arch } = process8;
+var tryEachApp = async (apps, opener) => {
+  if (apps.length === 0) {
+    return;
+  }
+  const errors = [];
+  for (const app of apps) {
+    try {
+      return await opener(app);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  throw new AggregateError(errors, "Failed to open in all supported apps");
+};
+var baseOpen = async (options) => {
+  options = {
+    wait: false,
+    background: false,
+    newInstance: false,
+    allowNonzeroExitCode: false,
+    ...options
+  };
+  const isFallbackAttempt = options[fallbackAttemptSymbol] === true;
+  delete options[fallbackAttemptSymbol];
+  if (Array.isArray(options.app)) {
+    return tryEachApp(options.app, (singleApp) => baseOpen({
+      ...options,
+      app: singleApp,
+      [fallbackAttemptSymbol]: true
+    }));
+  }
+  let { name: app, arguments: appArguments = [] } = options.app ?? {};
+  appArguments = [...appArguments];
+  if (Array.isArray(app)) {
+    return tryEachApp(app, (appName) => baseOpen({
+      ...options,
+      app: {
+        name: appName,
+        arguments: appArguments
+      },
+      [fallbackAttemptSymbol]: true
+    }));
+  }
+  if (app === "browser" || app === "browserPrivate") {
+    const ids = {
+      "com.google.chrome": "chrome",
+      "google-chrome.desktop": "chrome",
+      "com.brave.browser": "brave",
+      "org.mozilla.firefox": "firefox",
+      "firefox.desktop": "firefox",
+      "com.microsoft.msedge": "edge",
+      "com.microsoft.edge": "edge",
+      "com.microsoft.edgemac": "edge",
+      "microsoft-edge.desktop": "edge",
+      "com.apple.safari": "safari"
+    };
+    const flags = {
+      chrome: "--incognito",
+      brave: "--incognito",
+      firefox: "--private-window",
+      edge: "--inPrivate"
+    };
+    let browser;
+    if (is_wsl_default) {
+      const progId = await wslDefaultBrowser();
+      const browserInfo = _windowsBrowserProgIdMap.get(progId);
+      browser = browserInfo ?? {};
+    } else {
+      browser = await defaultBrowser2();
+    }
+    if (browser.id in ids) {
+      const browserName = ids[browser.id.toLowerCase()];
+      if (app === "browserPrivate") {
+        if (browserName === "safari") {
+          throw new Error("Safari doesn't support opening in private mode via command line");
+        }
+        appArguments.push(flags[browserName]);
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name: apps[browserName],
+          arguments: appArguments
+        }
+      });
+    }
+    throw new Error(`${browser.name} is not supported as a default browser`);
+  }
+  let command;
+  const cliArguments = [];
+  const childProcessOptions = {};
+  let shouldUseWindowsInWsl = false;
+  if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
+    shouldUseWindowsInWsl = await canAccessPowerShell();
+  }
+  if (platform === "darwin") {
+    command = "open";
+    if (options.wait) {
+      cliArguments.push("--wait-apps");
+    }
+    if (options.background) {
+      cliArguments.push("--background");
+    }
+    if (options.newInstance) {
+      cliArguments.push("--new");
+    }
+    if (app) {
+      cliArguments.push("-a", app);
+    }
+  } else if (platform === "win32" || shouldUseWindowsInWsl) {
+    command = await powerShellPath2();
+    cliArguments.push(...executePowerShell.argumentsPrefix);
+    if (!is_wsl_default) {
+      childProcessOptions.windowsVerbatimArguments = true;
+    }
+    if (is_wsl_default && options.target) {
+      options.target = await convertWslPathToWindows(options.target);
+    }
+    const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
+    if (options.wait) {
+      encodedArguments.push("-Wait");
+    }
+    if (app) {
+      encodedArguments.push(executePowerShell.escapeArgument(app));
+      if (options.target) {
+        appArguments.push(options.target);
+      }
+    } else if (options.target) {
+      encodedArguments.push(executePowerShell.escapeArgument(options.target));
+    }
+    if (appArguments.length > 0) {
+      appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
+      encodedArguments.push("-ArgumentList", appArguments.join(","));
+    }
+    options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+    }
+  } else {
+    if (app) {
+      command = app;
+    } else {
+      const isBundled = !__dirname2 || __dirname2 === "/";
+      let exeLocalXdgOpen = false;
+      try {
+        await fs5.access(localXdgOpenPath, fsConstants2.X_OK);
+        exeLocalXdgOpen = true;
+      } catch {}
+      const useSystemXdgOpen = process8.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+      command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+    }
+    if (appArguments.length > 0) {
+      cliArguments.push(...appArguments);
+    }
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+      childProcessOptions.detached = true;
+    }
+  }
+  if (platform === "darwin" && appArguments.length > 0) {
+    cliArguments.push("--args", ...appArguments);
+  }
+  if (options.target) {
+    cliArguments.push(options.target);
+  }
+  const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
+  if (options.wait) {
+    return new Promise((resolve2, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("close", (exitCode) => {
+        if (!options.allowNonzeroExitCode && exitCode !== 0) {
+          reject(new Error(`Exited with code ${exitCode}`));
+          return;
+        }
+        resolve2(subprocess);
+      });
+    });
+  }
+  if (isFallbackAttempt) {
+    return new Promise((resolve2, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("spawn", () => {
+        subprocess.once("close", (exitCode) => {
+          subprocess.off("error", reject);
+          if (exitCode !== 0) {
+            reject(new Error(`Exited with code ${exitCode}`));
+            return;
+          }
+          subprocess.unref();
+          resolve2(subprocess);
+        });
+      });
+    });
+  }
+  subprocess.unref();
+  return new Promise((resolve2, reject) => {
+    subprocess.once("error", reject);
+    subprocess.once("spawn", () => {
+      subprocess.off("error", reject);
+      resolve2(subprocess);
+    });
+  });
+};
+var open = (target, options) => {
+  if (typeof target !== "string") {
+    throw new TypeError("Expected a `target`");
+  }
+  return baseOpen({
+    ...options,
+    target
+  });
+};
+function detectArchBinary(binary2) {
+  if (typeof binary2 === "string" || Array.isArray(binary2)) {
+    return binary2;
+  }
+  const { [arch]: archBinary } = binary2;
+  if (!archBinary) {
+    throw new Error(`${arch} is not supported`);
+  }
+  return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl } = {}) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var apps = {
+  browser: "browser",
+  browserPrivate: "browserPrivate"
+};
+defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+  darwin: "google chrome",
+  win32: "chrome",
+  linux: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]
+}, {
+  wsl: {
+    ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+    x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+  }
+}));
+defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+  darwin: "brave browser",
+  win32: "brave",
+  linux: ["brave-browser", "brave"]
+}, {
+  wsl: {
+    ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+    x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+  }
+}));
+defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+  darwin: "firefox",
+  win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+  linux: "firefox"
+}, {
+  wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+}));
+defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+  darwin: "microsoft edge",
+  win32: "msedge",
+  linux: ["microsoft-edge", "microsoft-edge-dev"]
+}, {
+  wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+}));
+defineLazyProperty(apps, "safari", () => detectPlatformBinary({
+  darwin: "Safari"
+}));
+var open_default = open;
+
+class NodeFileSystem {
+  path = {
+    join: path2.join,
+    resolve: path2.resolve,
+    relative: path2.relative,
+    dirname: path2.dirname,
+    isAbsolute: path2.isAbsolute,
+    basename: path2.basename
+  };
+  env = {
+    cwd: process.cwd,
+    homedir: os2.homedir,
+    tmpdir: os2.tmpdir,
+    getenv: (key) => process.env[key]
+  };
+  utils = {
+    open: async (url) => {
+      await open_default(url);
+    }
+  };
+  async readFile(path3, options) {
+    try {
+      if (options) {
+        return await fs6.readFile(path3, "utf-8");
+      }
+      return await fs6.readFile(path3);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+  }
+  async writeFile(filePath, data) {
+    const dir = path2.dirname(filePath);
+    if (dir) {
+      await fs6.mkdir(dir, { recursive: true });
+    }
+    await fs6.writeFile(filePath, data);
+  }
+  async appendFile(filePath, data) {
+    const dir = path2.dirname(filePath);
+    if (dir) {
+      await fs6.mkdir(dir, { recursive: true });
+    }
+    await fs6.appendFile(filePath, data);
+  }
+  async readdir(dirPath) {
+    try {
+      return await fs6.readdir(dirPath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return [];
+      throw error;
+    }
+  }
+  async stat(filePath) {
+    try {
+      const stats = await fs6.stat(filePath);
+      return {
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        size: stats.size,
+        mtimeMs: stats.mtimeMs
+      };
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+  }
+  async exists(filePath) {
+    return existsSync(filePath);
+  }
+  async mkdir(dirPath) {
+    await fs6.mkdir(dirPath, { recursive: true });
+  }
+  async rm(filePath) {
+    await fs6.rm(filePath, { recursive: true, force: true });
+  }
+  async rename(oldPath, newPath) {
+    await fs6.rename(oldPath, newPath);
+  }
+  async getTempDir() {
+    return await fs6.mkdtemp(path2.join(os2.tmpdir(), "uipath-fs-"));
+  }
+  async copyDirectory(sourcePath, destPath) {
+    const sourceStats = await this.stat(sourcePath);
+    if (!sourceStats) {
+      throw new Error(`Source directory does not exist: ${sourcePath}`);
+    }
+    if (!sourceStats.isDirectory()) {
+      throw new Error(`Source path is not a directory: ${sourcePath}`);
+    }
+    await this.mkdir(destPath);
+    const entries = await this.readdir(sourcePath);
+    for (const entry of entries) {
+      const srcEntry = path2.join(sourcePath, entry);
+      const destEntry = path2.join(destPath, entry);
+      const entryStats = await this.stat(srcEntry);
+      if (!entryStats)
+        continue;
+      if (entryStats.isDirectory()) {
+        await this.copyDirectory(srcEntry, destEntry);
+      } else if (entryStats.isFile()) {
+        const content = await this.readFile(srcEntry);
+        if (content !== null) {
+          await this.writeFile(destEntry, content);
+        }
+      }
+    }
+  }
+  isEnoent(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+  }
+}
+var fsInstance = new NodeFileSystem;
+var getFileSystem = () => {
+  return fsInstance;
+};
 var PREFIX = "@uipath/common/";
 var _g = globalThis;
 function singleton(ctorOrName) {
@@ -8915,7 +9703,7 @@ function singleton(ctorOrName) {
 }
 function createStorage() {
   const [error, mod2] = catchError(() => __require2("node:async_hooks"));
-  if (error) {
+  if (error || typeof mod2?.AsyncLocalStorage !== "function") {
     return {
       getStore: () => {
         return;
@@ -8942,8 +9730,8 @@ function getOutputSink() {
   return outputStorage.getStore() ?? sinkSlot.get() ?? CONSOLE_FALLBACK;
 }
 var logFilePathSlot = singleton("logFilePath");
-function setGlobalLogFilePath(path) {
-  logFilePathSlot.set(path);
+function setGlobalLogFilePath(path3) {
+  logFilePathSlot.set(path3);
 }
 function getGlobalLogFilePath() {
   return logFilePathSlot.get("");
@@ -8962,6 +9750,8 @@ class SimpleLogger {
   level;
   logFilePath;
   fileLoggingEnabled;
+  pendingWrites = Promise.resolve();
+  pendingInit = Promise.resolve();
   constructor() {
     this.level = SimpleLogger.resolveLevel();
     this.logFilePath = "";
@@ -8976,7 +9766,7 @@ class SimpleLogger {
   static isNode = typeof process !== "undefined" && !!process.versions?.node;
   static resolveLevel() {
     if (SimpleLogger.isNode) {
-      const explicitLevel = SimpleLogger.parseLevel(process.env?.UIPCLI_LOG_LEVEL ?? "");
+      const explicitLevel = SimpleLogger.parseLevel(process.env?.UIP_LOG_LEVEL ?? "");
       if (explicitLevel !== undefined)
         return explicitLevel;
       const debugVal = process.env?.DEBUG;
@@ -9016,11 +9806,14 @@ class SimpleLogger {
     return this.fileLoggingEnabled || !!getGlobalLogFilePath();
   }
   writeToFile(formatted) {
-    const path = this.logFilePath || getGlobalLogFilePath();
-    if (!path)
+    const path3 = this.logFilePath || getGlobalLogFilePath();
+    if (!path3)
       return;
     const timestamp2 = new Date().toISOString();
-    catchError(() => appendFileSync(path, `${timestamp2} ${formatted}`));
+    this.pendingWrites = Promise.all([
+      this.pendingWrites,
+      this.pendingInit
+    ]).then(() => getFileSystem().appendFile(path3, `${timestamp2} ${formatted}`).catch(() => {}));
   }
   debug(message, ...args) {
     if (this.level > 0)
@@ -9075,16 +9868,25 @@ class SimpleLogger {
       setGlobalLogFilePath("");
     }
   }
-  setLogFile(path) {
-    this.logFilePath = path;
-    setGlobalLogFilePath(path);
-    if (!path)
+  setLogFile(path3) {
+    this.logFilePath = path3;
+    setGlobalLogFilePath(path3);
+    if (!path3)
       return;
-    const [error] = catchError(() => {
-      mkdirSync(dirname(path), { recursive: true });
-      writeFileSync(path, "");
-    });
-    this.fileLoggingEnabled = !error;
+    this.fileLoggingEnabled = true;
+    const fs7 = getFileSystem();
+    this.pendingInit = (async () => {
+      const [error] = await catchError((async () => {
+        await fs7.mkdir(fs7.path.dirname(path3));
+        await fs7.writeFile(path3, "");
+      })());
+      if (error)
+        this.fileLoggingEnabled = false;
+    })();
+  }
+  async flushFile() {
+    await this.pendingInit;
+    await this.pendingWrites;
   }
   getLogFilePath() {
     return this.logFilePath || getGlobalLogFilePath();
@@ -9126,12 +9928,75 @@ function setOutputFormat(format) {
   formatSlot.set(format);
 }
 function getOutputFormat() {
-  return formatSlot.get("table");
+  return formatSlot.get("json");
 }
 function getOutputFilter() {
   return filterSlot.get();
 }
+var CommonTelemetryEvents = {
+  Error: "uip.error"
+};
+function readRegistryValue(keyPath, valueName) {
+  if (process.platform !== "win32") {
+    return "";
+  }
+  const [error, output] = catchError(() => execFileSync2("reg", ["query", keyPath, "/v", valueName], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }));
+  if (error) {
+    return "";
+  }
+  const match = output.match(new RegExp(`${valueName}\\s+REG_SZ\\s+(.+)`));
+  return match?.[1]?.trim() ?? "";
+}
 
+class LoggerTelemetryProvider {
+  analyticsUniqueId;
+  constructor() {
+    this.analyticsUniqueId = readRegistryValue("HKCU\\Software\\UiPath", "AnalyticsUniqueId");
+  }
+  enrich(properties) {
+    return {
+      ...properties,
+      ...this.analyticsUniqueId ? { analyticsUniqueId: this.analyticsUniqueId } : {}
+    };
+  }
+  async trackEvent(eventName, properties) {
+    logger.debug(formatMessage("Event", eventName, this.enrich(properties)));
+  }
+  async trackException(error, properties) {
+    logger.error(formatMessage("Exception", error.message, this.enrich({
+      ...properties,
+      stack: error.stack
+    })));
+  }
+  async trackRequest(name, duration, success, properties) {
+    logger.debug(formatMessage("Request", name, this.enrich({
+      ...properties,
+      duration: `${duration}ms`,
+      success
+    })));
+  }
+  async trackDependency(name, type2, duration, success, properties) {
+    logger.debug(formatMessage("Dependency", name, this.enrich({
+      ...properties,
+      type: type2,
+      duration: `${duration}ms`,
+      success
+    })));
+  }
+}
+function formatMessage(category, name, properties) {
+  let message = `[Telemetry] [${category}] ${name}`;
+  if (properties && Object.keys(properties).length > 0) {
+    const propsStr = Object.entries(properties).filter(([_, value]) => value !== undefined).map(([key, value]) => `${key}=${value}`).join(", ");
+    if (propsStr) {
+      message += ` | ${propsStr}`;
+    }
+  }
+  return message;
+}
 class NodeContextStorage {
   storage = new AsyncLocalStorage;
   run(context, fn) {
@@ -9229,67 +10094,6 @@ class TelemetryService {
     return crypto.randomUUID().replaceAll("-", "");
   }
 }
-function readRegistryValue(keyPath, valueName) {
-  if (process.platform !== "win32") {
-    return "";
-  }
-  const [error, output] = catchError(() => execFileSync("reg", ["query", keyPath, "/v", valueName], {
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  }));
-  if (error) {
-    return "";
-  }
-  const match = output.match(new RegExp(`${valueName}\\s+REG_SZ\\s+(.+)`));
-  return match?.[1]?.trim() ?? "";
-}
-
-class LoggerTelemetryProvider {
-  analyticsUniqueId;
-  constructor() {
-    this.analyticsUniqueId = readRegistryValue("HKCU\\Software\\UiPath", "AnalyticsUniqueId");
-  }
-  enrich(properties) {
-    return {
-      ...properties,
-      ...this.analyticsUniqueId ? { analyticsUniqueId: this.analyticsUniqueId } : {}
-    };
-  }
-  async trackEvent(eventName, properties) {
-    logger.debug(formatMessage("Event", eventName, this.enrich(properties)));
-  }
-  async trackException(error, properties) {
-    logger.error(formatMessage("Exception", error.message, this.enrich({
-      ...properties,
-      stack: error.stack
-    })));
-  }
-  async trackRequest(name, duration, success, properties) {
-    logger.debug(formatMessage("Request", name, this.enrich({
-      ...properties,
-      duration: `${duration}ms`,
-      success
-    })));
-  }
-  async trackDependency(name, type2, duration, success, properties) {
-    logger.debug(formatMessage("Dependency", name, this.enrich({
-      ...properties,
-      type: type2,
-      duration: `${duration}ms`,
-      success
-    })));
-  }
-}
-function formatMessage(category, name, properties) {
-  let message = `[Telemetry] [${category}] ${name}`;
-  if (properties && Object.keys(properties).length > 0) {
-    const propsStr = Object.entries(properties).filter(([_, value]) => value !== undefined).map(([key, value]) => `${key}=${value}`).join(", ");
-    if (propsStr) {
-      message += ` | ${propsStr}`;
-    }
-  }
-  return message;
-}
 var telemetryPropsSlot = singleton("TelemetryDefaultProps");
 var providerSlot = singleton("TelemetryProvider");
 function setGlobalTelemetryProperties(properties) {
@@ -9299,9 +10103,18 @@ function setGlobalTelemetryProperties(properties) {
 function getGlobalTelemetryProperties() {
   return telemetryPropsSlot.get();
 }
+function toOperationUrn(name) {
+  if (URL.canParse(name))
+    return name;
+  const sanitized = encodeURIComponent(name).replace(/%2F/g, "/");
+  return `urn:uip:${sanitized}`;
+}
 async function loadApplicationInsights() {
   const savedDebug = process.env.DEBUG;
   delete process.env.DEBUG;
+  if (process.env.APPLICATION_INSIGHTS_DISABLE_WARNING_LOGS === undefined) {
+    process.env.APPLICATION_INSIGHTS_DISABLE_WARNING_LOGS = "1";
+  }
   const [error, mod2] = await catchError(import("applicationinsights"));
   if (savedDebug !== undefined) {
     process.env.DEBUG = savedDebug;
@@ -9340,6 +10153,11 @@ class NodeAppInsightsTelemetryProvider {
   getSessionId() {
     return this._sessionId;
   }
+  setApplicationVersion(version) {
+    if (!this.client)
+      return;
+    this.client.context.tags[this.client.context.keys.applicationVersion] = version;
+  }
   mergeProperties(properties) {
     const globalProps = getGlobalTelemetryProperties();
     if (!globalProps && !properties)
@@ -9380,14 +10198,17 @@ class NodeAppInsightsTelemetryProvider {
     if (!client)
       return;
     const merged = this.mergeProperties(properties);
-    client.trackRequest({
+    const [trackError] = catchError(() => client.trackRequest({
       name,
-      url: name,
+      url: toOperationUrn(name),
       duration,
       resultCode: success ? "200" : "500",
       success,
       properties: merged
-    });
+    }));
+    if (trackError) {
+      logger.debug(`[AppInsights] trackRequest failed for: ${name}`);
+    }
   }
   async trackDependency(name, type2, duration, success, properties) {
     const client = this.client;
@@ -9409,18 +10230,18 @@ class NodeAppInsightsTelemetryProvider {
       logger.warn(`[AppInsights] flush error (non-fatal): nil client`);
       return;
     }
-    const [error] = await catchError(new Promise((resolve, reject) => {
+    const [error] = await catchError(new Promise((resolve2, reject) => {
       client.flush({
         callback: (response) => {
           if (!response) {
-            resolve();
+            resolve2();
             return;
           }
           const [parseError, parsed] = catchError(() => JSON.parse(response));
           if (parseError || parsed?.errors && parsed.errors.length > 0) {
             reject(new Error(response));
           } else {
-            resolve();
+            resolve2();
           }
         }
       });
@@ -9466,7 +10287,7 @@ async function getOrCreateProvider(connectionString) {
   return initPromise;
 }
 var telemetryInstanceSlot = singleton("TelemetryService");
-var DEFAULT_AI_CONNECTION_STRING = Buffer.from("SW5zdHJ1bWVudGF0aW9uS2V5PTliZDM3NDgyLTgxMGUtNDQyYS1hYWE2LWQzOGVmNjVjNjY3NDtJbmdlc3Rpb25FbmRwb2ludD1odHRwczovL3dlc3RldXJvcGUtNS5pbi5hcHBsaWNhdGlvbmluc2lnaHRzLmF6dXJlLmNvbS87TGl2ZUVuZHBvaW50PWh0dHBzOi8vd2VzdGV1cm9wZS5saXZlZGlhZ25vc3RpY3MubW9uaXRvci5henVyZS5jb20vO0FwcGxpY2F0aW9uSWQ9MzU2OTdlZjEtOGJkMC00ZjE5LWEyN2MtZDg3Y2NhYzY2ZDJj", "base64").toString("utf-8");
+var DEFAULT_AI_CONNECTION_STRING = atob("SW5zdHJ1bWVudGF0aW9uS2V5PTliZDM3NDgyLTgxMGUtNDQyYS1hYWE2LWQzOGVmNjVjNjY3NDtJbmdlc3Rpb25FbmRwb2ludD1odHRwczovL3dlc3RldXJvcGUtNS5pbi5hcHBsaWNhdGlvbmluc2lnaHRzLmF6dXJlLmNvbS87TGl2ZUVuZHBvaW50PWh0dHBzOi8vd2VzdGV1cm9wZS5saXZlZGlhZ25vc3RpY3MubW9uaXRvci5henVyZS5jb20vO0FwcGxpY2F0aW9uSWQ9MzU2OTdlZjEtOGJkMC00ZjE5LWEyN2MtZDg3Y2NhYzY2ZDJj");
 function getConnectionString() {
   return process.env.UIPATH_AI_CONNECTION_STRING || DEFAULT_AI_CONNECTION_STRING;
 }
@@ -9523,16 +10344,19 @@ var telemetry = new Proxy({}, {
     return typeof value === "function" ? value.bind(instance) : value;
   }
 });
-async function telemetryInit(defaultProperties) {
+async function telemetryInit(options) {
   const { provider, name: providerName } = await createTelemetryProvider();
   const instance = new TelemetryService(provider, new NodeContextStorage);
   setGlobalTelemetryInstance(instance);
   _localTelemetryInstance = instance;
-  if (defaultProperties) {
-    setGlobalTelemetryProperties(defaultProperties);
-    telemetry.setDefaultProperties(defaultProperties);
-  }
   const isAppInsights = providerName === "NodeAppInsightsTelemetryProvider";
+  if (options?.version && isAppInsights) {
+    provider.setApplicationVersion(options.version);
+  }
+  if (options?.defaultProperties) {
+    setGlobalTelemetryProperties(options.defaultProperties);
+    telemetry.setDefaultProperties(options.defaultProperties);
+  }
   if (!isAppInsights) {
     logger.debug(`[Telemetry] initialized with fallback provider (${providerName}). applicationinsights package not available.`);
   }
@@ -9542,8 +10366,8 @@ async function telemetryFlushAndShutdown() {
   if (telemetryProviderInstance && "shutdown" in telemetryProviderInstance) {
     const provider = telemetryProviderInstance;
     let timer;
-    const timeout = new Promise((resolve) => {
-      timer = setTimeout(() => resolve("timeout"), FLUSH_SHUTDOWN_TIMEOUT_MS);
+    const timeout = new Promise((resolve2) => {
+      timer = setTimeout(() => resolve2("timeout"), FLUSH_SHUTDOWN_TIMEOUT_MS);
     });
     const result = await Promise.race([
       provider.flush().then(() => provider.shutdown()).then(() => "done"),
@@ -9556,10 +10380,39 @@ async function telemetryFlushAndShutdown() {
     }
   }
 }
-var CommonTelemetryEvents = {
-  Error: "uip.error"
+var RESULTS = {
+  Success: "Success",
+  Failure: "Failure",
+  ConfigError: "ConfigError",
+  AuthenticationError: "AuthenticationError",
+  ValidationError: "ValidationError",
+  TimeoutError: "TimeoutError"
 };
-function printOutput(data, format = "table", logFn) {
+var EXIT_CODES = {
+  Success: 0,
+  Failure: 1,
+  ConfigError: 1,
+  AuthenticationError: 2,
+  ValidationError: 3,
+  TimeoutError: 4
+};
+
+class SuccessOutput {
+  Result = RESULTS.Success;
+  Code;
+  Data;
+  Instructions;
+  Log;
+  constructor(code, data) {
+    this.Code = code;
+    this.Data = data;
+    const logPath = getLogFilePath();
+    if (logPath) {
+      this.Log = logPath;
+    }
+  }
+}
+function printOutput(data, format = "json", logFn) {
   if (!data) {
     logFn("Empty response object. No data to display.");
     return;
@@ -9599,7 +10452,7 @@ function printOutput(data, format = "table", logFn) {
     }
   }
 }
-function logOutput(data, format = "table") {
+function logOutput(data, format = "json") {
   const sink = getOutputSink();
   printOutput(data, format, (msg) => sink.writeOut(`${msg}
 `));
@@ -9755,6 +10608,7 @@ var OutputFormatter;
   OutputFormatter2.success = success;
   function error(data) {
     data.Log ??= getLogFilePath() || undefined;
+    process.exitCode = EXIT_CODES[data.Result] ?? 1;
     telemetry.trackEvent(CommonTelemetryEvents.Error, {
       result: data.Result,
       message: data.Message
@@ -9762,6 +10616,21 @@ var OutputFormatter;
     logOutput(data, getOutputFormat());
   }
   OutputFormatter2.error = error;
+  function emitList(code, items, opts) {
+    const data = {
+      Result: RESULTS.Success,
+      Code: code,
+      Data: items
+    };
+    if (items.length === 0 && opts?.emptyInstructions) {
+      data.Instructions = opts.emptyInstructions;
+    }
+    if (opts?.warning) {
+      data.Warning = opts.warning;
+    }
+    success(data);
+  }
+  OutputFormatter2.emitList = emitList;
   function log(data) {
     const format = getOutputFormat();
     const sink = getOutputSink();
@@ -9790,6 +10659,7 @@ var OutputFormatter;
   }
   OutputFormatter2.formatToString = formatToString;
 })(OutputFormatter ||= {});
+var COMPLETER_SYMBOL = Symbol.for("@uipath/common/completer");
 var guardInstalledSlot = singleton("ConsoleGuardInstalled");
 var savedOriginalsSlot = singleton("ConsoleGuardOriginals");
 var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
@@ -10875,8 +11745,8 @@ JSONPath.prototype._getPreferredOutput = function(ea) {
   const resultType = this.currResultType;
   switch (resultType) {
     case "all": {
-      const path = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);
-      ea.pointer = JSONPath.toPointer(path);
+      const path3 = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);
+      ea.pointer = JSONPath.toPointer(path3);
       ea.path = typeof ea.path === "string" ? ea.path : JSONPath.toPathString(ea.path);
       return ea;
     }
@@ -10899,11 +11769,11 @@ JSONPath.prototype._handleCallback = function(fullRetObj, callback, type2) {
     callback(preferredOutput, type2, fullRetObj);
   }
 };
-JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, callback, hasArrExpr, literalPriority) {
+JSONPath.prototype._trace = function(expr, val, path3, parent, parentPropName, callback, hasArrExpr, literalPriority) {
   let retObj;
   if (!expr.length) {
     retObj = {
-      path,
+      path: path3,
       value: val,
       parent,
       parentProperty: parentPropName,
@@ -10924,28 +11794,28 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
     }
   }
   if ((typeof loc !== "string" || literalPriority) && val && Object.hasOwn(val, loc)) {
-    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr));
+    addRet(this._trace(x, val[loc], push(path3, loc), val, loc, callback, hasArrExpr));
   } else if (loc === "*") {
     this._walk(val, (m) => {
-      addRet(this._trace(x, val[m], push(path, m), val, m, callback, true, true));
+      addRet(this._trace(x, val[m], push(path3, m), val, m, callback, true, true));
     });
   } else if (loc === "..") {
-    addRet(this._trace(x, val, path, parent, parentPropName, callback, hasArrExpr));
+    addRet(this._trace(x, val, path3, parent, parentPropName, callback, hasArrExpr));
     this._walk(val, (m) => {
       if (typeof val[m] === "object") {
-        addRet(this._trace(expr.slice(), val[m], push(path, m), val, m, callback, true));
+        addRet(this._trace(expr.slice(), val[m], push(path3, m), val, m, callback, true));
       }
     });
   } else if (loc === "^") {
     this._hasParentSelector = true;
     return {
-      path: path.slice(0, -1),
+      path: path3.slice(0, -1),
       expr: x,
       isParentSelector: true
     };
   } else if (loc === "~") {
     retObj = {
-      path: push(path, loc),
+      path: push(path3, loc),
       value: parentPropName,
       parent,
       parentProperty: null
@@ -10953,9 +11823,9 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
     this._handleCallback(retObj, callback, "property");
     return retObj;
   } else if (loc === "$") {
-    addRet(this._trace(x, val, path, null, null, callback, hasArrExpr));
+    addRet(this._trace(x, val, path3, null, null, callback, hasArrExpr));
   } else if (/^(-?\d*):(-?\d*):?(\d*)$/u.test(loc)) {
-    addRet(this._slice(loc, x, val, path, parent, parentPropName, callback));
+    addRet(this._slice(loc, x, val, path3, parent, parentPropName, callback));
   } else if (loc.indexOf("?(") === 0) {
     if (this.currEval === false) {
       throw new Error("Eval [?(expr)] prevented in JSONPath expression.");
@@ -10966,15 +11836,15 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
       this._walk(val, (m) => {
         const npath = [nested[2]];
         const nvalue = nested[1] ? val[m][nested[1]] : val[m];
-        const filterResults = this._trace(npath, nvalue, path, parent, parentPropName, callback, true);
+        const filterResults = this._trace(npath, nvalue, path3, parent, parentPropName, callback, true);
         if (filterResults.length > 0) {
-          addRet(this._trace(x, val[m], push(path, m), val, m, callback, true));
+          addRet(this._trace(x, val[m], push(path3, m), val, m, callback, true));
         }
       });
     } else {
       this._walk(val, (m) => {
-        if (this._eval(safeLoc, val[m], m, path, parent, parentPropName)) {
-          addRet(this._trace(x, val[m], push(path, m), val, m, callback, true));
+        if (this._eval(safeLoc, val[m], m, path3, parent, parentPropName)) {
+          addRet(this._trace(x, val[m], push(path3, m), val, m, callback, true));
         }
       });
     }
@@ -10982,7 +11852,7 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
     if (this.currEval === false) {
       throw new Error("Eval [(expr)] prevented in JSONPath expression.");
     }
-    addRet(this._trace(unshift(this._eval(loc, val, path.at(-1), path.slice(0, -1), parent, parentPropName), x), val, path, parent, parentPropName, callback, hasArrExpr));
+    addRet(this._trace(unshift(this._eval(loc, val, path3.at(-1), path3.slice(0, -1), parent, parentPropName), x), val, path3, parent, parentPropName, callback, hasArrExpr));
   } else if (loc[0] === "@") {
     let addType = false;
     const valueType = loc.slice(1, -2);
@@ -11026,7 +11896,7 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
         }
         break;
       case "other":
-        addType = this.currOtherTypeCallback(val, path, parent, parentPropName);
+        addType = this.currOtherTypeCallback(val, path3, parent, parentPropName);
         break;
       case "null":
         if (val === null) {
@@ -11038,7 +11908,7 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
     }
     if (addType) {
       retObj = {
-        path,
+        path: path3,
         value: val,
         parent,
         parentProperty: parentPropName
@@ -11048,14 +11918,14 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
     }
   } else if (loc[0] === "`" && val && Object.hasOwn(val, loc.slice(1))) {
     const locProp = loc.slice(1);
-    addRet(this._trace(x, val[locProp], push(path, locProp), val, locProp, callback, hasArrExpr, true));
+    addRet(this._trace(x, val[locProp], push(path3, locProp), val, locProp, callback, hasArrExpr, true));
   } else if (loc.includes(",")) {
     const parts = loc.split(",");
     for (const part of parts) {
-      addRet(this._trace(unshift(part, x), val, path, parent, parentPropName, callback, true));
+      addRet(this._trace(unshift(part, x), val, path3, parent, parentPropName, callback, true));
     }
   } else if (!literalPriority && val && Object.hasOwn(val, loc)) {
-    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr, true));
+    addRet(this._trace(x, val[loc], push(path3, loc), val, loc, callback, hasArrExpr, true));
   }
   if (this._hasParentSelector) {
     for (let t = 0;t < ret.length; t++) {
@@ -11089,7 +11959,7 @@ JSONPath.prototype._walk = function(val, f) {
     });
   }
 };
-JSONPath.prototype._slice = function(loc, expr, val, path, parent, parentPropName, callback) {
+JSONPath.prototype._slice = function(loc, expr, val, path3, parent, parentPropName, callback) {
   if (!Array.isArray(val)) {
     return;
   }
@@ -11099,14 +11969,14 @@ JSONPath.prototype._slice = function(loc, expr, val, path, parent, parentPropNam
   end = end < 0 ? Math.max(0, end + len) : Math.min(len, end);
   const ret = [];
   for (let i2 = start;i2 < end; i2 += step) {
-    const tmp = this._trace(unshift(i2, expr), val, path, parent, parentPropName, callback, true);
+    const tmp = this._trace(unshift(i2, expr), val, path3, parent, parentPropName, callback, true);
     tmp.forEach((t) => {
       ret.push(t);
     });
   }
   return ret;
 };
-JSONPath.prototype._eval = function(code, _v, _vname, path, parent, parentPropName) {
+JSONPath.prototype._eval = function(code, _v, _vname, path3, parent, parentPropName) {
   this.currSandbox._$_parentProperty = parentPropName;
   this.currSandbox._$_parent = parent;
   this.currSandbox._$_property = _vname;
@@ -11114,7 +11984,7 @@ JSONPath.prototype._eval = function(code, _v, _vname, path, parent, parentPropNa
   this.currSandbox._$_v = _v;
   const containsPath = code.includes("@path");
   if (containsPath) {
-    this.currSandbox._$_path = JSONPath.toPathString(path.concat([_vname]));
+    this.currSandbox._$_path = JSONPath.toPathString(path3.concat([_vname]));
   }
   const scriptCacheKey = this.currEval + "Script:" + code;
   if (!JSONPath.cache[scriptCacheKey]) {
@@ -11219,7 +12089,150 @@ var ScreenLogger;
   ScreenLogger2.progress = progress;
 })(ScreenLogger ||= {});
 var factorySlot = singleton("PackagerFactoryProvider");
+var REDACTED = "[REDACTED]";
+var MAX_VALUE_LENGTH = 200;
+var SENSITIVE_NAME_TOKENS = new Set([
+  "token",
+  "tokens",
+  "secret",
+  "secrets",
+  "password",
+  "passwords",
+  "pwd",
+  "credential",
+  "credentials",
+  "auth",
+  "authentication",
+  "authorization",
+  "authority",
+  "cert",
+  "certificate",
+  "certificates"
+]);
+var SENSITIVE_KEY_PREFIXES = new Set([
+  "api",
+  "access",
+  "client",
+  "private",
+  "public",
+  "signing",
+  "encryption",
+  "session",
+  "master",
+  "shared",
+  "root",
+  "ssh",
+  "rsa",
+  "aes",
+  "hmac",
+  "oauth"
+]);
+var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+var EMAIL_PATTERN = /\b[^\s@]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
+var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
+var USER_HOME_PATTERN = /([/\\])(Users|home)([/\\])([^/\\]+)/gi;
+var URL_PATTERN = /\bhttps?:\/\/[^\s,;]+/gi;
+var URL_TRAILING_PUNCT = /[.,;:!?)\]}>'"]+$/;
+function shortHash(input) {
+  let hash = 2166136261;
+  for (let i2 = 0;i2 < input.length; i2++) {
+    hash ^= input.charCodeAt(i2);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function redactUrl(raw) {
+  try {
+    const url = new URL(raw);
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return `url#${shortHash(raw)}`;
+  }
+}
+function redactValueDetectors(value) {
+  let out = value;
+  out = out.replace(JWT_PATTERN, () => REDACTED);
+  out = out.replace(URL_PATTERN, (match) => {
+    const trailing = match.match(URL_TRAILING_PUNCT)?.[0] ?? "";
+    const core2 = trailing ? match.slice(0, -trailing.length) : match;
+    return `${redactUrl(core2)}${trailing}`;
+  });
+  out = out.replace(USER_HOME_PATTERN, (_match, sep1, folder, sep2) => `${sep1}${folder}${sep2}<user>`);
+  out = out.replace(EMAIL_PATTERN, (match) => `email#${shortHash(match)}`);
+  out = out.replace(UUID_PATTERN, (match) => `uuid#${shortHash(match)}`);
+  out = out.replace(LONG_TOKEN_PATTERN, () => REDACTED);
+  if (out.length > MAX_VALUE_LENGTH) {
+    out = `${out.slice(0, MAX_VALUE_LENGTH)}…`;
+  }
+  return out;
+}
+function nameTokens(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).map((t) => t.toLowerCase()).filter(Boolean);
+}
+function isSensitiveName(name) {
+  const tokens = nameTokens(name);
+  for (let i2 = 0;i2 < tokens.length; i2++) {
+    const token = tokens[i2];
+    if (SENSITIVE_NAME_TOKENS.has(token)) {
+      return true;
+    }
+    if (token === "key" || token === "keys") {
+      const prev = tokens[i2 - 1];
+      if (prev && SENSITIVE_KEY_PREFIXES.has(prev)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function redactProperty(name, value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (isSensitiveName(name)) {
+    return REDACTED;
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return "[OBJECT]";
+  }
+  return redactValueDetectors(value);
+}
+function redactProperties(properties) {
+  const out = {};
+  for (const [name, value] of Object.entries(properties)) {
+    const redacted = redactProperty(name, value);
+    if (redacted !== undefined) {
+      out[name] = redacted;
+    }
+  }
+  return out;
+}
 var pollSignalSlot = singleton("PollSignal");
+function extractCommandParams(cmd) {
+  const params = {};
+  const registered = cmd.registeredArguments ?? [];
+  const processed = cmd.processedArgs ?? [];
+  for (let i2 = 0;i2 < registered.length; i2++) {
+    const value = processed[i2];
+    if (value === undefined) {
+      continue;
+    }
+    const name = registered[i2].name();
+    if (name) {
+      params[name] = value;
+    }
+  }
+  for (const [key, value] of Object.entries(cmd.opts())) {
+    if (value !== undefined) {
+      params[key] = value;
+    }
+  }
+  return params;
+}
 function deriveCommandPath(cmd) {
   const parts = [];
   let current = cmd;
@@ -11235,7 +12248,7 @@ function deriveCommandPath(cmd) {
   }
   return ["uip", ...parts.filter((p) => p !== "uip")].join(".");
 }
-Command.prototype.trackedAction = function(context, fn, properties) {
+Command2.prototype.trackedAction = function(context, fn, properties) {
   const command = this;
   return this.action(async (...args) => {
     const telemetryName = deriveCommandPath(command);
@@ -11247,7 +12260,7 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       errorMessage = error instanceof Error ? error.message : String(error);
       logger.error(`[trackedAction] ${telemetryName} failed: ${errorMessage}`);
       OutputFormatter.error({
-        Result: "Failure",
+        Result: RESULTS.Failure,
         Message: errorMessage,
         Instructions: "An unexpected error occurred. Run with --log-level debug for details."
       });
@@ -11255,31 +12268,16 @@ Command.prototype.trackedAction = function(context, fn, properties) {
     }
     const durationMs = performance.now() - startTime;
     const success = !error && (process.exitCode === undefined || process.exitCode === 0);
-    telemetry.trackEvent(telemetryName, {
+    telemetry.trackEvent(telemetryName, redactProperties({
+      ...extractCommandParams(command),
       ...props,
       duration: String(durationMs),
       success: String(success),
       ...errorMessage ? { errorMessage } : {}
-    });
+    }));
   });
 };
 
-// node_modules/commander/esm.mjs
-var import__2 = __toESM(require_commander2(), 1);
-var {
-  program: program2,
-  createCommand: createCommand2,
-  createArgument: createArgument2,
-  createOption: createOption2,
-  CommanderError: CommanderError2,
-  InvalidArgumentError: InvalidArgumentError2,
-  InvalidOptionArgumentError: InvalidOptionArgumentError2,
-  Command: Command2,
-  Argument: Argument2,
-  Option: Option2,
-  Help: Help2
-} = import__2.default;
-
 // src/argv.ts
 function extractArg(argv, name, defaultValue) {
   const prefix = `--${name}=`;
@@ -11345,10 +12343,11 @@ ${descIndent}${indentedDesc}`;
 // src/index.ts
 import { metadata, registerCommands } from "./tool.js";
 if (process.platform !== "win32") {
-  process.env.TMPDIR = "/tmp/";
+  process.env.TMPDIR = safeTmpDir();
 }
 var projectDir = extractArg(process.argv, "project-dir", process.cwd());
 var studioDir = extractArg(process.argv, "studio-dir");
+var robotDir = extractArg(process.argv, "robot-dir");
 var timeoutRaw = extractArg(process.argv, "timeout", "300");
 var timeoutSeconds = parseInt(timeoutRaw ?? "300", 10);
 var verbose = hasFlag(process.argv, "verbose");
@@ -11361,16 +12360,20 @@ if (hasFlag(process.argv, "use-studio") && hostStudioPid) {
 if (format) {
   setOutputFormat(format);
 }
-var program3 = new Command2;
+var program3 = new Command;
 configureHelpFormat(program3);
-program3.name(metadata.name).version(metadata.version).description(metadata.description).option("--project-dir <path>", "Project directory to match against running Studio instances", process.cwd()).option("--studio-dir <path>", "Path to Studio installation directory (for starting a new instance)").option("--timeout <seconds>", "Timeout in seconds", "300").option("--verbose", "Enable verbose logging (debug level)").option("--format <format>", "Output format (table, json, yaml, plain)");
+program3.name(metadata.name).version(metadata.version).description(metadata.description).option("--project-dir <path>", "Project directory to match against running Studio instances", process.cwd()).option("--studio-dir <path>", "Path to Studio installation directory (for starting a new instance)").option("--robot-dir <path>", "Path to Robot installation directory (bypasses registry/bundle discovery)").option("--timeout <seconds>", "Timeout in seconds", "300").option("--verbose", "Enable verbose logging (debug level)").option("--format <format>", "Output format (table, json, yaml, plain)");
 if (verbose) {
   console.error(`rpa-tool v${metadata.version}`);
 }
-await telemetryInit({ tool: "rpa-tool", version: metadata.version });
+await telemetryInit({
+  version: metadata.version,
+  defaultProperties: { tool: "rpa-tool" }
+});
 await registerCommands(program3, {
   projectDir: projectDir ?? process.cwd(),
   studioDir,
+  robotDir,
   verbose,
   useStudio,
   hostStudioPid,