@uipath/vertical-solutions-tool 1.0.2 → 1.1.0

package/dist/tool.js

@@ -46,533 +46,837 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// ../../node_modules/commander/lib/error.js
-var require_error = __commonJS((exports) => {
-  class CommanderError extends Error {
-    constructor(exitCode, code, message) {
-      super(message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-      this.code = code;
-      this.exitCode = exitCode;
-      this.nestedError = undefined;
-    }
+// ../../node_modules/is-inside-container/node_modules/is-docker/index.js
+import fs from "node:fs";
+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 isDockerCached;
+var init_is_docker = () => {};
 
-  class InvalidArgumentError extends CommanderError {
-    constructor(message) {
-      super(1, "commander.invalidArgument", message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-    }
+// ../../node_modules/is-inside-container/index.js
+import fs2 from "node:fs";
+function isInsideContainer() {
+  if (cachedResult === undefined) {
+    cachedResult = hasContainerEnv() || isDocker();
   }
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
+  return cachedResult;
+}
+var cachedResult, hasContainerEnv = () => {
+  try {
+    fs2.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+var init_is_inside_container = __esm(() => {
+  init_is_docker();
 });
 
-// ../../node_modules/commander/lib/argument.js
-var require_argument = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
-
-  class Argument {
-    constructor(name, description) {
-      this.description = description || "";
-      this.variadic = false;
-      this.parseArg = undefined;
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.argChoices = undefined;
-      switch (name[0]) {
-        case "<":
-          this.required = true;
-          this._name = name.slice(1, -1);
-          break;
-        case "[":
-          this.required = false;
-          this._name = name.slice(1, -1);
-          break;
-        default:
-          this.required = true;
-          this._name = name;
-          break;
-      }
-      if (this._name.endsWith("...")) {
-        this.variadic = true;
-        this._name = this._name.slice(0, -3);
-      }
-    }
-    name() {
-      return this._name;
-    }
-    _collectValue(value, previous) {
-      if (previous === this.defaultValue || !Array.isArray(previous)) {
-        return [value];
-      }
-      previous.push(value);
-      return previous;
-    }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
-    }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
-    }
-    choices(values) {
-      this.argChoices = values.slice();
-      this.parseArg = (arg, previous) => {
-        if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-        }
-        if (this.variadic) {
-          return this._collectValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    argRequired() {
-      this.required = true;
-      return this;
-    }
-    argOptional() {
-      this.required = false;
-      return this;
+// ../../node_modules/wsl-utils/node_modules/is-wsl/index.js
+import process2 from "node:process";
+import os from "node:os";
+import fs3 from "node:fs";
+var isWsl = () => {
+  if (process2.platform !== "linux") {
+    return false;
+  }
+  if (os.release().toLowerCase().includes("microsoft")) {
+    if (isInsideContainer()) {
+      return false;
     }
+    return true;
   }
-  function humanReadableArgName(arg) {
-    const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
-    return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+  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();
   }
-  exports.Argument = Argument;
-  exports.humanReadableArgName = humanReadableArgName;
+  return false;
+}, is_wsl_default;
+var init_is_wsl = __esm(() => {
+  init_is_inside_container();
+  is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
 });
 
-// ../../node_modules/commander/lib/help.js
-var require_help = __commonJS((exports) => {
-  var { humanReadableArgName } = require_argument();
+// ../../node_modules/powershell-utils/index.js
+import process3 from "node:process";
+import { Buffer as Buffer2 } from "node:buffer";
+import { promisify } from "node:util";
+import childProcess from "node:child_process";
+var execFile, powerShellPath = () => `${process3.env.SYSTEMROOT || process3.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`, executePowerShell = async (command, options = {}) => {
+  const {
+    powerShellPath: psPath,
+    ...execFileOptions
+  } = options;
+  const encodedCommand = executePowerShell.encodeCommand(command);
+  return execFile(psPath ?? powerShellPath(), [
+    ...executePowerShell.argumentsPrefix,
+    encodedCommand
+  ], {
+    encoding: "utf8",
+    ...execFileOptions
+  });
+};
+var init_powershell_utils = __esm(() => {
+  execFile = promisify(childProcess.execFile);
+  executePowerShell.argumentsPrefix = [
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-EncodedCommand"
+  ];
+  executePowerShell.encodeCommand = (command) => Buffer2.from(command, "utf16le").toString("base64");
+  executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
+});
 
-  class Help {
-    constructor() {
-      this.helpWidth = undefined;
-      this.minWidthToWrap = 40;
-      this.sortSubcommands = false;
-      this.sortOptions = false;
-      this.showGlobalOptions = false;
-    }
-    prepareContext(contextOptions) {
-      this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
-    }
-    visibleCommands(cmd) {
-      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
-      const helpCommand = cmd._getHelpCommand();
-      if (helpCommand && !helpCommand._hidden) {
-        visibleCommands.push(helpCommand);
-      }
-      if (this.sortSubcommands) {
-        visibleCommands.sort((a, b) => {
-          return a.name().localeCompare(b.name());
-        });
-      }
-      return visibleCommands;
-    }
-    compareOptions(a, b) {
-      const getSortKey = (option) => {
-        return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
-      };
-      return getSortKey(a).localeCompare(getSortKey(b));
-    }
-    visibleOptions(cmd) {
-      const visibleOptions = cmd.options.filter((option) => !option.hidden);
-      const helpOption = cmd._getHelpOption();
-      if (helpOption && !helpOption.hidden) {
-        const removeShort = helpOption.short && cmd._findOption(helpOption.short);
-        const removeLong = helpOption.long && cmd._findOption(helpOption.long);
-        if (!removeShort && !removeLong) {
-          visibleOptions.push(helpOption);
-        } else if (helpOption.long && !removeLong) {
-          visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
-        } else if (helpOption.short && !removeShort) {
-          visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
-        }
-      }
-      if (this.sortOptions) {
-        visibleOptions.sort(this.compareOptions);
-      }
-      return visibleOptions;
-    }
-    visibleGlobalOptions(cmd) {
-      if (!this.showGlobalOptions)
-        return [];
-      const globalOptions = [];
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
-        globalOptions.push(...visibleOptions);
-      }
-      if (this.sortOptions) {
-        globalOptions.sort(this.compareOptions);
-      }
-      return globalOptions;
-    }
-    visibleArguments(cmd) {
-      if (cmd._argsDescription) {
-        cmd.registeredArguments.forEach((argument) => {
-          argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
-        });
-      }
-      if (cmd.registeredArguments.find((argument) => argument.description)) {
-        return cmd.registeredArguments;
-      }
-      return [];
-    }
-    subcommandTerm(cmd) {
-      const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
-      return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
-    }
-    optionTerm(option) {
-      return option.flags;
-    }
-    argumentTerm(argument) {
-      return argument.name();
-    }
-    longestSubcommandTermLength(cmd, helper) {
-      return helper.visibleCommands(cmd).reduce((max, command) => {
-        return Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command))));
-      }, 0);
-    }
-    longestOptionTermLength(cmd, helper) {
-      return helper.visibleOptions(cmd).reduce((max, option) => {
-        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
-      }, 0);
-    }
-    longestGlobalOptionTermLength(cmd, helper) {
-      return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
-      }, 0);
-    }
-    longestArgumentTermLength(cmd, helper) {
-      return helper.visibleArguments(cmd).reduce((max, argument) => {
-        return Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument))));
-      }, 0);
-    }
-    commandUsage(cmd) {
-      let cmdName = cmd._name;
-      if (cmd._aliases[0]) {
-        cmdName = cmdName + "|" + cmd._aliases[0];
-      }
-      let ancestorCmdNames = "";
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
-      }
-      return ancestorCmdNames + cmdName + " " + cmd.usage();
-    }
-    commandDescription(cmd) {
-      return cmd.description();
+// ../../node_modules/wsl-utils/utilities.js
+function parseMountPointFromConfig(content) {
+  for (const line of content.split(`
+`)) {
+    if (/^\s*#/.test(line)) {
+      continue;
     }
-    subcommandDescription(cmd) {
-      return cmd.summary() || cmd.description();
+    const match = /^\s*root\s*=\s*(?<mountPoint>"[^"]*"|'[^']*'|[^#]*)/.exec(line);
+    if (!match) {
+      continue;
     }
-    optionDescription(option) {
-      const extraInfo = [];
-      if (option.argChoices) {
-        extraInfo.push(`choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
-      }
-      if (option.defaultValue !== undefined) {
-        const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
-        if (showDefault) {
-          extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
-        }
-      }
-      if (option.presetArg !== undefined && option.optional) {
-        extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
-      }
-      if (option.envVar !== undefined) {
-        extraInfo.push(`env: ${option.envVar}`);
-      }
-      if (extraInfo.length > 0) {
-        const extraDescription = `(${extraInfo.join(", ")})`;
-        if (option.description) {
-          return `${option.description} ${extraDescription}`;
-        }
-        return extraDescription;
-      }
-      return option.description;
+    return match.groups.mountPoint.trim().replaceAll(/^["']|["']$/g, "");
+  }
+}
+
+// ../../node_modules/wsl-utils/index.js
+import { promisify as promisify2 } from "node:util";
+import childProcess2 from "node:child_process";
+import fs4, { constants as fsConstants } from "node:fs/promises";
+var execFile2, wslDrivesMountPoint, powerShellPathFromWsl = async () => {
+  const mountPoint = await wslDrivesMountPoint();
+  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+}, powerShellPath2, canAccessPowerShellPromise, canAccessPowerShell = async () => {
+  canAccessPowerShellPromise ??= (async () => {
+    try {
+      const psPath = await powerShellPath2();
+      await fs4.access(psPath, fsConstants.X_OK);
+      return true;
+    } catch {
+      return false;
     }
-    argumentDescription(argument) {
-      const extraInfo = [];
-      if (argument.argChoices) {
-        extraInfo.push(`choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
+  })();
+  return canAccessPowerShellPromise;
+}, 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();
+}, convertWslPathToWindows = async (path) => {
+  if (/^[a-z]+:\/\//i.test(path)) {
+    return path;
+  }
+  try {
+    const { stdout } = await execFile2("wslpath", ["-aw", path], { encoding: "utf8" });
+    return stdout.trim();
+  } catch {
+    return path;
+  }
+};
+var init_wsl_utils = __esm(() => {
+  init_is_wsl();
+  init_powershell_utils();
+  init_is_wsl();
+  execFile2 = promisify2(childProcess2.execFile);
+  wslDrivesMountPoint = (() => {
+    const defaultMountPoint = "/mnt/";
+    let mountPoint;
+    return async function() {
+      if (mountPoint) {
+        return mountPoint;
       }
-      if (argument.defaultValue !== undefined) {
-        extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
+      const configFilePath = "/etc/wsl.conf";
+      let isConfigFileExists = false;
+      try {
+        await fs4.access(configFilePath, fsConstants.F_OK);
+        isConfigFileExists = true;
+      } catch {}
+      if (!isConfigFileExists) {
+        return defaultMountPoint;
       }
-      if (extraInfo.length > 0) {
-        const extraDescription = `(${extraInfo.join(", ")})`;
-        if (argument.description) {
-          return `${argument.description} ${extraDescription}`;
-        }
-        return extraDescription;
+      const configContent = await fs4.readFile(configFilePath, { encoding: "utf8" });
+      const parsedMountPoint = parseMountPointFromConfig(configContent);
+      if (parsedMountPoint === undefined) {
+        return defaultMountPoint;
       }
-      return argument.description;
-    }
-    formatItemList(heading, items, helper) {
-      if (items.length === 0)
-        return [];
-      return [helper.styleTitle(heading), ...items, ""];
-    }
-    groupItems(unsortedItems, visibleItems, getGroup) {
-      const result = new Map;
-      unsortedItems.forEach((item) => {
-        const group = getGroup(item);
-        if (!result.has(group))
-          result.set(group, []);
-      });
-      visibleItems.forEach((item) => {
-        const group = getGroup(item);
-        if (!result.has(group)) {
-          result.set(group, []);
-        }
-        result.get(group).push(item);
-      });
+      mountPoint = parsedMountPoint;
+      mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+      return mountPoint;
+    };
+  })();
+  powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
+});
+
+// ../../node_modules/open/node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define2 = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define2(result);
       return result;
+    },
+    set(value) {
+      define2(value);
     }
-    formatHelp(cmd, helper) {
-      const termWidth = helper.padWidth(cmd, helper);
-      const helpWidth = helper.helpWidth ?? 80;
-      function callFormatItem(term, description) {
-        return helper.formatItem(term, termWidth, description, helper);
-      }
-      let output = [
-        `${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`,
-        ""
-      ];
-      const commandDescription = helper.commandDescription(cmd);
-      if (commandDescription.length > 0) {
-        output = output.concat([
-          helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth),
-          ""
-        ]);
-      }
-      const argumentList = helper.visibleArguments(cmd).map((argument) => {
-        return callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument)));
-      });
-      output = output.concat(this.formatItemList("Arguments:", argumentList, helper));
-      const optionGroups = this.groupItems(cmd.options, helper.visibleOptions(cmd), (option) => option.helpGroupHeading ?? "Options:");
-      optionGroups.forEach((options, group) => {
-        const optionList = options.map((option) => {
-          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
-        });
-        output = output.concat(this.formatItemList(group, optionList, helper));
-      });
-      if (helper.showGlobalOptions) {
-        const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
-        });
-        output = output.concat(this.formatItemList("Global Options:", globalOptionList, helper));
-      }
-      const commandGroups = this.groupItems(cmd.commands, helper.visibleCommands(cmd), (sub) => sub.helpGroup() || "Commands:");
-      commandGroups.forEach((commands, group) => {
-        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(str) {
-      return stripColor(str).length;
-    }
-    styleTitle(str) {
-      return str;
-    }
-    styleUsage(str) {
-      return str.split(" ").map((word) => {
-        if (word === "[options]")
-          return this.styleOptionText(word);
-        if (word === "[command]")
-          return this.styleSubcommandText(word);
-        if (word[0] === "[" || word[0] === "<")
-          return this.styleArgumentText(word);
-        return this.styleCommandText(word);
-      }).join(" ");
+  });
+  return object;
+}
+
+// ../../node_modules/default-browser-id/index.js
+import { promisify as promisify3 } from "node:util";
+import process4 from "node:process";
+import { execFile as execFile3 } from "node:child_process";
+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 execFileAsync;
+var init_default_browser_id = __esm(() => {
+  execFileAsync = promisify3(execFile3);
+});
+
+// ../../node_modules/run-applescript/index.js
+import process5 from "node:process";
+import { promisify as promisify4 } from "node:util";
+import { execFile as execFile4, execFileSync } from "node:child_process";
+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();
+}
+var execFileAsync2;
+var init_run_applescript = __esm(() => {
+  execFileAsync2 = promisify4(execFile4);
+});
+
+// ../../node_modules/bundle-name/index.js
+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 init_bundle_name = __esm(() => {
+  init_run_applescript();
+});
+
+// ../../node_modules/default-browser/windows.js
+import { promisify as promisify5 } from "node:util";
+import { execFile as execFile5 } from "node:child_process";
+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 execFileAsync3, windowsBrowserProgIds, _windowsBrowserProgIdMap, UnknownBrowserError;
+var init_windows = __esm(() => {
+  execFileAsync3 = promisify5(execFile5);
+  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" }
+  };
+  _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+  UnknownBrowserError = class UnknownBrowserError extends Error {
+  };
+});
+
+// ../../node_modules/default-browser/index.js
+import { promisify as promisify6 } from "node:util";
+import process6 from "node:process";
+import { execFile as execFile6 } from "node:child_process";
+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 execFileAsync4, titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+var init_default_browser = __esm(() => {
+  init_default_browser_id();
+  init_bundle_name();
+  init_windows();
+  init_windows();
+  execFileAsync4 = promisify6(execFile6);
+});
+
+// ../../node_modules/is-in-ssh/index.js
+import process7 from "node:process";
+var isInSsh, is_in_ssh_default;
+var init_is_in_ssh = __esm(() => {
+  isInSsh = Boolean(process7.env.SSH_CONNECTION || process7.env.SSH_CLIENT || process7.env.SSH_TTY);
+  is_in_ssh_default = isInSsh;
+});
+
+// ../../node_modules/open/index.js
+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";
+function detectArchBinary(binary) {
+  if (typeof binary === "string" || Array.isArray(binary)) {
+    return binary;
+  }
+  const { [arch]: archBinary } = binary;
+  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 fallbackAttemptSymbol, __dirname2, localXdgOpenPath, platform, arch, 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);
     }
-    styleCommandDescription(str) {
-      return this.styleDescriptionText(str);
+  }
+  throw new AggregateError(errors, "Failed to open in all supported apps");
+}, 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();
     }
-    styleOptionDescription(str) {
-      return this.styleDescriptionText(str);
+    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
+        }
+      });
     }
-    styleSubcommandDescription(str) {
-      return this.styleDescriptionText(str);
+    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");
     }
-    styleArgumentDescription(str) {
-      return this.styleDescriptionText(str);
+    if (options.background) {
+      cliArguments.push("--background");
     }
-    styleDescriptionText(str) {
-      return str;
+    if (options.newInstance) {
+      cliArguments.push("--new");
     }
-    styleOptionTerm(str) {
-      return this.styleOptionText(str);
+    if (app) {
+      cliArguments.push("-a", app);
     }
-    styleSubcommandTerm(str) {
-      return str.split(" ").map((word) => {
-        if (word === "[options]")
-          return this.styleOptionText(word);
-        if (word[0] === "[" || word[0] === "<")
-          return this.styleArgumentText(word);
-        return this.styleSubcommandText(word);
-      }).join(" ");
+  } else if (platform === "win32" || shouldUseWindowsInWsl) {
+    command = await powerShellPath2();
+    cliArguments.push(...executePowerShell.argumentsPrefix);
+    if (!is_wsl_default) {
+      childProcessOptions.windowsVerbatimArguments = true;
     }
-    styleArgumentTerm(str) {
-      return this.styleArgumentText(str);
+    if (is_wsl_default && options.target) {
+      options.target = await convertWslPathToWindows(options.target);
     }
-    styleOptionText(str) {
-      return str;
+    const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
+    if (options.wait) {
+      encodedArguments.push("-Wait");
     }
-    styleArgumentText(str) {
-      return str;
+    if (app) {
+      encodedArguments.push(executePowerShell.escapeArgument(app));
+      if (options.target) {
+        appArguments.push(options.target);
+      }
+    } else if (options.target) {
+      encodedArguments.push(executePowerShell.escapeArgument(options.target));
     }
-    styleSubcommandText(str) {
-      return str;
+    if (appArguments.length > 0) {
+      appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
+      encodedArguments.push("-ArgumentList", appArguments.join(","));
     }
-    styleCommandText(str) {
-      return str;
+    options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
     }
-    padWidth(cmd, helper) {
-      return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
+  } 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;
     }
-    preformatted(str) {
-      return /\n[^\S\r\n]/.test(str);
+    if (appArguments.length > 0) {
+      cliArguments.push(...appArguments);
     }
-    formatItem(term, termWidth, description, helper) {
-      const itemIndent = 2;
-      const itemIndentStr = " ".repeat(itemIndent);
-      if (!description)
-        return itemIndentStr + term;
-      const paddedTerm = term.padEnd(termWidth + term.length - helper.displayWidth(term));
-      const spacerWidth = 2;
-      const helpWidth = this.helpWidth ?? 80;
-      const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
-      let formattedDescription;
-      if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) {
-        formattedDescription = description;
-      } else {
-        const wrappedDescription = helper.boxWrap(description, remainingWidth);
-        formattedDescription = wrappedDescription.replace(/\n/g, `
-` + " ".repeat(termWidth + spacerWidth));
-      }
-      return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
-${itemIndentStr}`);
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+      childProcessOptions.detached = true;
     }
-    boxWrap(str, width) {
-      if (width < this.minWidthToWrap)
-        return str;
-      const rawLines = str.split(/\r\n|\n/);
-      const chunkPattern = /[\s]*[^\s]+/g;
-      const wrappedLines = [];
-      rawLines.forEach((line) => {
-        const chunks = line.match(chunkPattern);
-        if (chunks === null) {
-          wrappedLines.push("");
+  }
+  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((resolve, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("close", (exitCode) => {
+        if (!options.allowNonzeroExitCode && exitCode !== 0) {
+          reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        let sumChunks = [chunks.shift()];
-        let sumWidth = this.displayWidth(sumChunks[0]);
-        chunks.forEach((chunk) => {
-          const visibleWidth = this.displayWidth(chunk);
-          if (sumWidth + visibleWidth <= width) {
-            sumChunks.push(chunk);
-            sumWidth += visibleWidth;
+        resolve(subprocess);
+      });
+    });
+  }
+  if (isFallbackAttempt) {
+    return new Promise((resolve, 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;
           }
-          wrappedLines.push(sumChunks.join(""));
-          const nextChunk = chunk.trimStart();
-          sumChunks = [nextChunk];
-          sumWidth = this.displayWidth(nextChunk);
+          subprocess.unref();
+          resolve(subprocess);
         });
-        wrappedLines.push(sumChunks.join(""));
       });
-      return wrappedLines.join(`
-`);
-    }
+    });
   }
-  function stripColor(str) {
-    const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
-    return str.replace(sgrPattern, "");
+  subprocess.unref();
+  return new Promise((resolve, reject) => {
+    subprocess.once("error", reject);
+    subprocess.once("spawn", () => {
+      subprocess.off("error", reject);
+      resolve(subprocess);
+    });
+  });
+}, open = (target, options) => {
+  if (typeof target !== "string") {
+    throw new TypeError("Expected a `target`");
   }
-  exports.Help = Help;
-  exports.stripColor = stripColor;
+  return baseOpen({
+    ...options,
+    target
+  });
+}, apps, open_default;
+var init_open = __esm(() => {
+  init_wsl_utils();
+  init_powershell_utils();
+  init_default_browser();
+  init_is_inside_container();
+  init_is_in_ssh();
+  fallbackAttemptSymbol = Symbol("fallbackAttempt");
+  __dirname2 = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : "";
+  localXdgOpenPath = path.join(__dirname2, "xdg-open");
+  ({ platform, arch } = process8);
+  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"
+  }));
+  open_default = open;
 });
 
-// ../../node_modules/commander/lib/option.js
-var require_option = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
+// ../filesystem/src/node.ts
+import { existsSync } from "node:fs";
+import * as fs6 from "node:fs/promises";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
 
-  class Option {
-    constructor(flags, description) {
-      this.flags = flags;
-      this.description = description || "";
-      this.required = flags.includes("<");
-      this.optional = flags.includes("[");
-      this.variadic = /\w\.\.\.[>\]]$/.test(flags);
-      this.mandatory = false;
-      const optionFlags = splitOptionFlags(flags);
-      this.short = optionFlags.shortFlag;
-      this.long = optionFlags.longFlag;
-      this.negate = false;
-      if (this.long) {
-        this.negate = this.long.startsWith("--no-");
-      }
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.presetArg = undefined;
-      this.envVar = undefined;
-      this.parseArg = undefined;
-      this.hidden = false;
-      this.argChoices = undefined;
-      this.conflictsWith = [];
-      this.implied = undefined;
-      this.helpGroupHeading = undefined;
+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);
     }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
+  };
+  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;
     }
-    preset(arg) {
-      this.presetArg = arg;
-      return this;
+  }
+  async writeFile(filePath, data) {
+    const dir = path2.dirname(filePath);
+    if (dir) {
+      await fs6.mkdir(dir, { recursive: true });
     }
-    conflicts(names) {
-      this.conflictsWith = this.conflictsWith.concat(names);
-      return this;
+    await fs6.writeFile(filePath, data);
+  }
+  async appendFile(filePath, data) {
+    const dir = path2.dirname(filePath);
+    if (dir) {
+      await fs6.mkdir(dir, { recursive: true });
     }
-    implies(impliedOptionValues) {
-      let newImplied = impliedOptionValues;
-      if (typeof impliedOptionValues === "string") {
-        newImplied = { [impliedOptionValues]: 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 realpath(filePath) {
+    try {
+      return await fs6.realpath(filePath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return filePath;
+      throw error;
+    }
+  }
+  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);
+        }
       }
-      this.implied = Object.assign(this.implied || {}, newImplied);
-      return this;
     }
-    env(name) {
-      this.envVar = name;
-      return this;
+  }
+  isEnoent(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+  }
+}
+var init_node = __esm(() => {
+  init_open();
+});
+// ../filesystem/src/index.ts
+var fsInstance, getFileSystem = () => fsInstance;
+var init_src = __esm(() => {
+  init_node();
+  init_node();
+  fsInstance = new NodeFileSystem;
+});
+
+// ../../node_modules/commander/lib/error.js
+var require_error = __commonJS((exports) => {
+  class CommanderError extends Error {
+    constructor(exitCode, code, message) {
+      super(message);
+      Error.captureStackTrace(this, this.constructor);
+      this.name = this.constructor.name;
+      this.code = code;
+      this.exitCode = exitCode;
+      this.nestedError = undefined;
     }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
+  }
+
+  class InvalidArgumentError extends CommanderError {
+    constructor(message) {
+      super(1, "commander.invalidArgument", message);
+      Error.captureStackTrace(this, this.constructor);
+      this.name = this.constructor.name;
     }
-    makeOptionMandatory(mandatory = true) {
-      this.mandatory = !!mandatory;
-      return this;
+  }
+  exports.CommanderError = CommanderError;
+  exports.InvalidArgumentError = InvalidArgumentError;
+});
+
+// ../../node_modules/commander/lib/argument.js
+var require_argument = __commonJS((exports) => {
+  var { InvalidArgumentError } = require_error();
+
+  class Argument {
+    constructor(name, description) {
+      this.description = description || "";
+      this.variadic = false;
+      this.parseArg = undefined;
+      this.defaultValue = undefined;
+      this.defaultValueDescription = undefined;
+      this.argChoices = undefined;
+      switch (name[0]) {
+        case "<":
+          this.required = true;
+          this._name = name.slice(1, -1);
+          break;
+        case "[":
+          this.required = false;
+          this._name = name.slice(1, -1);
+          break;
+        default:
+          this.required = true;
+          this._name = name;
+          break;
+      }
+      if (this._name.endsWith("...")) {
+        this.variadic = true;
+        this._name = this._name.slice(0, -3);
+      }
     }
-    hideHelp(hide = true) {
-      this.hidden = !!hide;
-      return this;
+    name() {
+      return this._name;
     }
     _collectValue(value, previous) {
       if (previous === this.defaultValue || !Array.isArray(previous)) {
@@ -581,6 +885,15 @@ var require_option = __commonJS((exports) => {
       previous.push(value);
       return previous;
     }
+    default(value, description) {
+      this.defaultValue = value;
+      this.defaultValueDescription = description;
+      return this;
+    }
+    argParser(fn) {
+      this.parseArg = fn;
+      return this;
+    }
     choices(values) {
       this.argChoices = values.slice();
       this.parseArg = (arg, previous) => {
@@ -594,189 +907,650 @@ var require_option = __commonJS((exports) => {
       };
       return this;
     }
-    name() {
-      if (this.long) {
-        return this.long.replace(/^--/, "");
-      }
-      return this.short.replace(/^-/, "");
-    }
-    attributeName() {
-      if (this.negate) {
-        return camelcase(this.name().replace(/^no-/, ""));
-      }
-      return camelcase(this.name());
-    }
-    helpGroup(heading) {
-      this.helpGroupHeading = heading;
+    argRequired() {
+      this.required = true;
       return this;
     }
-    is(arg) {
-      return this.short === arg || this.long === arg;
-    }
-    isBoolean() {
-      return !this.required && !this.optional && !this.negate;
+    argOptional() {
+      this.required = false;
+      return this;
     }
   }
+  function humanReadableArgName(arg) {
+    const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
+    return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+  }
+  exports.Argument = Argument;
+  exports.humanReadableArgName = humanReadableArgName;
+});
 
-  class DualOptions {
-    constructor(options) {
-      this.positiveOptions = new Map;
-      this.negativeOptions = new Map;
-      this.dualOptions = new Set;
-      options.forEach((option) => {
-        if (option.negate) {
-          this.negativeOptions.set(option.attributeName(), option);
-        } else {
-          this.positiveOptions.set(option.attributeName(), option);
-        }
-      });
-      this.negativeOptions.forEach((value, key) => {
-        if (this.positiveOptions.has(key)) {
-          this.dualOptions.add(key);
-        }
-      });
+// ../../node_modules/commander/lib/help.js
+var require_help = __commonJS((exports) => {
+  var { humanReadableArgName } = require_argument();
+
+  class Help {
+    constructor() {
+      this.helpWidth = undefined;
+      this.minWidthToWrap = 40;
+      this.sortSubcommands = false;
+      this.sortOptions = false;
+      this.showGlobalOptions = false;
     }
-    valueFromOption(value, option) {
-      const optionKey = option.attributeName();
-      if (!this.dualOptions.has(optionKey))
-        return true;
-      const preset = this.negativeOptions.get(optionKey).presetArg;
-      const negativeValue = preset !== undefined ? preset : false;
-      return option.negate === (negativeValue === value);
+    prepareContext(contextOptions) {
+      this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
     }
-  }
-  function camelcase(str) {
-    return str.split("-").reduce((str2, word) => {
-      return str2 + word[0].toUpperCase() + word.slice(1);
-    });
-  }
-  function splitOptionFlags(flags) {
-    let shortFlag;
-    let longFlag;
-    const shortFlagExp = /^-[^-]$/;
-    const longFlagExp = /^--[^-]/;
-    const flagParts = flags.split(/[ |,]+/).concat("guard");
-    if (shortFlagExp.test(flagParts[0]))
-      shortFlag = flagParts.shift();
-    if (longFlagExp.test(flagParts[0]))
-      longFlag = flagParts.shift();
-    if (!shortFlag && shortFlagExp.test(flagParts[0]))
-      shortFlag = flagParts.shift();
-    if (!shortFlag && longFlagExp.test(flagParts[0])) {
-      shortFlag = longFlag;
-      longFlag = flagParts.shift();
+    visibleCommands(cmd) {
+      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
+      const helpCommand = cmd._getHelpCommand();
+      if (helpCommand && !helpCommand._hidden) {
+        visibleCommands.push(helpCommand);
+      }
+      if (this.sortSubcommands) {
+        visibleCommands.sort((a, b) => {
+          return a.name().localeCompare(b.name());
+        });
+      }
+      return visibleCommands;
     }
-    if (flagParts[0].startsWith("-")) {
-      const unsupportedFlag = flagParts[0];
-      const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
-      if (/^-[^-][^-]/.test(unsupportedFlag))
-        throw new Error(`${baseError}
-- a short flag is a single dash and a single character
-  - either use a single dash and a single character (for a short flag)
-  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`);
-      if (shortFlagExp.test(unsupportedFlag))
-        throw new Error(`${baseError}
-- too many short flags`);
-      if (longFlagExp.test(unsupportedFlag))
-        throw new Error(`${baseError}
-- too many long flags`);
-      throw new Error(`${baseError}
-- unrecognised flag format`);
+    compareOptions(a, b) {
+      const getSortKey = (option) => {
+        return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
+      };
+      return getSortKey(a).localeCompare(getSortKey(b));
     }
-    if (shortFlag === undefined && longFlag === undefined)
-      throw new Error(`option creation failed due to no flags found in '${flags}'.`);
-    return { shortFlag, longFlag };
-  }
-  exports.Option = Option;
-  exports.DualOptions = DualOptions;
-});
-
-// ../../node_modules/commander/lib/suggestSimilar.js
-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 i = 0;i <= a.length; i++) {
-      d[i] = [i];
+    visibleOptions(cmd) {
+      const visibleOptions = cmd.options.filter((option) => !option.hidden);
+      const helpOption = cmd._getHelpOption();
+      if (helpOption && !helpOption.hidden) {
+        const removeShort = helpOption.short && cmd._findOption(helpOption.short);
+        const removeLong = helpOption.long && cmd._findOption(helpOption.long);
+        if (!removeShort && !removeLong) {
+          visibleOptions.push(helpOption);
+        } else if (helpOption.long && !removeLong) {
+          visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
+        } else if (helpOption.short && !removeShort) {
+          visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
+        }
+      }
+      if (this.sortOptions) {
+        visibleOptions.sort(this.compareOptions);
+      }
+      return visibleOptions;
     }
-    for (let j = 0;j <= b.length; j++) {
-      d[0][j] = j;
+    visibleGlobalOptions(cmd) {
+      if (!this.showGlobalOptions)
+        return [];
+      const globalOptions = [];
+      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+        const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
+        globalOptions.push(...visibleOptions);
+      }
+      if (this.sortOptions) {
+        globalOptions.sort(this.compareOptions);
+      }
+      return globalOptions;
     }
-    for (let j = 1;j <= b.length; j++) {
-      for (let i = 1;i <= a.length; i++) {
-        let cost = 1;
-        if (a[i - 1] === b[j - 1]) {
-          cost = 0;
-        } else {
-          cost = 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);
-        }
+    visibleArguments(cmd) {
+      if (cmd._argsDescription) {
+        cmd.registeredArguments.forEach((argument) => {
+          argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
+        });
       }
+      if (cmd.registeredArguments.find((argument) => argument.description)) {
+        return cmd.registeredArguments;
+      }
+      return [];
     }
-    return d[a.length][b.length];
-  }
-  function suggestSimilar(word, candidates) {
-    if (!candidates || candidates.length === 0)
-      return "";
-    candidates = Array.from(new Set(candidates));
-    const searchingOptions = word.startsWith("--");
-    if (searchingOptions) {
-      word = word.slice(2);
-      candidates = candidates.map((candidate) => candidate.slice(2));
+    subcommandTerm(cmd) {
+      const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
+      return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
     }
-    let similar = [];
-    let bestDistance = maxDistance;
-    const minSimilarity = 0.4;
-    candidates.forEach((candidate) => {
-      if (candidate.length <= 1)
-        return;
-      const distance = editDistance(word, candidate);
-      const length = Math.max(word.length, candidate.length);
-      const similarity = (length - distance) / length;
-      if (similarity > minSimilarity) {
-        if (distance < bestDistance) {
-          bestDistance = distance;
-          similar = [candidate];
-        } else if (distance === bestDistance) {
-          similar.push(candidate);
-        }
+    optionTerm(option) {
+      return option.flags;
+    }
+    argumentTerm(argument) {
+      return argument.name();
+    }
+    longestSubcommandTermLength(cmd, helper) {
+      return helper.visibleCommands(cmd).reduce((max, command) => {
+        return Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command))));
+      }, 0);
+    }
+    longestOptionTermLength(cmd, helper) {
+      return helper.visibleOptions(cmd).reduce((max, option) => {
+        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
+      }, 0);
+    }
+    longestGlobalOptionTermLength(cmd, helper) {
+      return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
+        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
+      }, 0);
+    }
+    longestArgumentTermLength(cmd, helper) {
+      return helper.visibleArguments(cmd).reduce((max, argument) => {
+        return Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument))));
+      }, 0);
+    }
+    commandUsage(cmd) {
+      let cmdName = cmd._name;
+      if (cmd._aliases[0]) {
+        cmdName = cmdName + "|" + cmd._aliases[0];
       }
-    });
-    similar.sort((a, b) => a.localeCompare(b));
-    if (searchingOptions) {
-      similar = similar.map((candidate) => `--${candidate}`);
+      let ancestorCmdNames = "";
+      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+        ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
+      }
+      return ancestorCmdNames + cmdName + " " + cmd.usage();
     }
-    if (similar.length > 1) {
-      return `
-(Did you mean one of ${similar.join(", ")}?)`;
+    commandDescription(cmd) {
+      return cmd.description();
     }
-    if (similar.length === 1) {
-      return `
-(Did you mean ${similar[0]}?)`;
+    subcommandDescription(cmd) {
+      return cmd.summary() || cmd.description();
     }
-    return "";
-  }
-  exports.suggestSimilar = suggestSimilar;
-});
-
-// ../../node_modules/commander/lib/command.js
-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, humanReadableArgName } = require_argument();
-  var { CommanderError } = require_error();
-  var { Help, stripColor } = require_help();
-  var { Option, DualOptions } = require_option();
-  var { suggestSimilar } = require_suggestSimilar();
-
+    optionDescription(option) {
+      const extraInfo = [];
+      if (option.argChoices) {
+        extraInfo.push(`choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
+      }
+      if (option.defaultValue !== undefined) {
+        const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
+        if (showDefault) {
+          extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
+        }
+      }
+      if (option.presetArg !== undefined && option.optional) {
+        extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
+      }
+      if (option.envVar !== undefined) {
+        extraInfo.push(`env: ${option.envVar}`);
+      }
+      if (extraInfo.length > 0) {
+        const extraDescription = `(${extraInfo.join(", ")})`;
+        if (option.description) {
+          return `${option.description} ${extraDescription}`;
+        }
+        return extraDescription;
+      }
+      return option.description;
+    }
+    argumentDescription(argument) {
+      const extraInfo = [];
+      if (argument.argChoices) {
+        extraInfo.push(`choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
+      }
+      if (argument.defaultValue !== undefined) {
+        extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
+      }
+      if (extraInfo.length > 0) {
+        const extraDescription = `(${extraInfo.join(", ")})`;
+        if (argument.description) {
+          return `${argument.description} ${extraDescription}`;
+        }
+        return extraDescription;
+      }
+      return argument.description;
+    }
+    formatItemList(heading, items, helper) {
+      if (items.length === 0)
+        return [];
+      return [helper.styleTitle(heading), ...items, ""];
+    }
+    groupItems(unsortedItems, visibleItems, getGroup) {
+      const result = new Map;
+      unsortedItems.forEach((item) => {
+        const group = getGroup(item);
+        if (!result.has(group))
+          result.set(group, []);
+      });
+      visibleItems.forEach((item) => {
+        const group = getGroup(item);
+        if (!result.has(group)) {
+          result.set(group, []);
+        }
+        result.get(group).push(item);
+      });
+      return result;
+    }
+    formatHelp(cmd, helper) {
+      const termWidth = helper.padWidth(cmd, helper);
+      const helpWidth = helper.helpWidth ?? 80;
+      function callFormatItem(term, description) {
+        return helper.formatItem(term, termWidth, description, helper);
+      }
+      let output = [
+        `${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`,
+        ""
+      ];
+      const commandDescription = helper.commandDescription(cmd);
+      if (commandDescription.length > 0) {
+        output = output.concat([
+          helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth),
+          ""
+        ]);
+      }
+      const argumentList = helper.visibleArguments(cmd).map((argument) => {
+        return callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument)));
+      });
+      output = output.concat(this.formatItemList("Arguments:", argumentList, helper));
+      const optionGroups = this.groupItems(cmd.options, helper.visibleOptions(cmd), (option) => option.helpGroupHeading ?? "Options:");
+      optionGroups.forEach((options, group) => {
+        const optionList = options.map((option) => {
+          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
+        });
+        output = output.concat(this.formatItemList(group, optionList, helper));
+      });
+      if (helper.showGlobalOptions) {
+        const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
+          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
+        });
+        output = output.concat(this.formatItemList("Global Options:", globalOptionList, helper));
+      }
+      const commandGroups = this.groupItems(cmd.commands, helper.visibleCommands(cmd), (sub) => sub.helpGroup() || "Commands:");
+      commandGroups.forEach((commands, group) => {
+        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(str) {
+      return stripColor(str).length;
+    }
+    styleTitle(str) {
+      return str;
+    }
+    styleUsage(str) {
+      return str.split(" ").map((word) => {
+        if (word === "[options]")
+          return this.styleOptionText(word);
+        if (word === "[command]")
+          return this.styleSubcommandText(word);
+        if (word[0] === "[" || word[0] === "<")
+          return this.styleArgumentText(word);
+        return this.styleCommandText(word);
+      }).join(" ");
+    }
+    styleCommandDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleOptionDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleSubcommandDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleArgumentDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleDescriptionText(str) {
+      return str;
+    }
+    styleOptionTerm(str) {
+      return this.styleOptionText(str);
+    }
+    styleSubcommandTerm(str) {
+      return str.split(" ").map((word) => {
+        if (word === "[options]")
+          return this.styleOptionText(word);
+        if (word[0] === "[" || word[0] === "<")
+          return this.styleArgumentText(word);
+        return this.styleSubcommandText(word);
+      }).join(" ");
+    }
+    styleArgumentTerm(str) {
+      return this.styleArgumentText(str);
+    }
+    styleOptionText(str) {
+      return str;
+    }
+    styleArgumentText(str) {
+      return str;
+    }
+    styleSubcommandText(str) {
+      return str;
+    }
+    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(str) {
+      return /\n[^\S\r\n]/.test(str);
+    }
+    formatItem(term, termWidth, description, helper) {
+      const itemIndent = 2;
+      const itemIndentStr = " ".repeat(itemIndent);
+      if (!description)
+        return itemIndentStr + term;
+      const paddedTerm = term.padEnd(termWidth + term.length - helper.displayWidth(term));
+      const spacerWidth = 2;
+      const helpWidth = this.helpWidth ?? 80;
+      const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
+      let formattedDescription;
+      if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) {
+        formattedDescription = description;
+      } else {
+        const wrappedDescription = helper.boxWrap(description, remainingWidth);
+        formattedDescription = wrappedDescription.replace(/\n/g, `
+` + " ".repeat(termWidth + spacerWidth));
+      }
+      return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
+${itemIndentStr}`);
+    }
+    boxWrap(str, width) {
+      if (width < this.minWidthToWrap)
+        return str;
+      const rawLines = str.split(/\r\n|\n/);
+      const chunkPattern = /[\s]*[^\s]+/g;
+      const wrappedLines = [];
+      rawLines.forEach((line) => {
+        const chunks = line.match(chunkPattern);
+        if (chunks === null) {
+          wrappedLines.push("");
+          return;
+        }
+        let sumChunks = [chunks.shift()];
+        let sumWidth = this.displayWidth(sumChunks[0]);
+        chunks.forEach((chunk) => {
+          const visibleWidth = this.displayWidth(chunk);
+          if (sumWidth + visibleWidth <= width) {
+            sumChunks.push(chunk);
+            sumWidth += visibleWidth;
+            return;
+          }
+          wrappedLines.push(sumChunks.join(""));
+          const nextChunk = chunk.trimStart();
+          sumChunks = [nextChunk];
+          sumWidth = this.displayWidth(nextChunk);
+        });
+        wrappedLines.push(sumChunks.join(""));
+      });
+      return wrappedLines.join(`
+`);
+    }
+  }
+  function stripColor(str) {
+    const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
+    return str.replace(sgrPattern, "");
+  }
+  exports.Help = Help;
+  exports.stripColor = stripColor;
+});
+
+// ../../node_modules/commander/lib/option.js
+var require_option = __commonJS((exports) => {
+  var { InvalidArgumentError } = require_error();
+
+  class Option {
+    constructor(flags, description) {
+      this.flags = flags;
+      this.description = description || "";
+      this.required = flags.includes("<");
+      this.optional = flags.includes("[");
+      this.variadic = /\w\.\.\.[>\]]$/.test(flags);
+      this.mandatory = false;
+      const optionFlags = splitOptionFlags(flags);
+      this.short = optionFlags.shortFlag;
+      this.long = optionFlags.longFlag;
+      this.negate = false;
+      if (this.long) {
+        this.negate = this.long.startsWith("--no-");
+      }
+      this.defaultValue = undefined;
+      this.defaultValueDescription = undefined;
+      this.presetArg = undefined;
+      this.envVar = undefined;
+      this.parseArg = undefined;
+      this.hidden = false;
+      this.argChoices = undefined;
+      this.conflictsWith = [];
+      this.implied = undefined;
+      this.helpGroupHeading = undefined;
+    }
+    default(value, description) {
+      this.defaultValue = value;
+      this.defaultValueDescription = description;
+      return this;
+    }
+    preset(arg) {
+      this.presetArg = arg;
+      return this;
+    }
+    conflicts(names) {
+      this.conflictsWith = this.conflictsWith.concat(names);
+      return this;
+    }
+    implies(impliedOptionValues) {
+      let newImplied = impliedOptionValues;
+      if (typeof impliedOptionValues === "string") {
+        newImplied = { [impliedOptionValues]: true };
+      }
+      this.implied = Object.assign(this.implied || {}, newImplied);
+      return this;
+    }
+    env(name) {
+      this.envVar = name;
+      return this;
+    }
+    argParser(fn) {
+      this.parseArg = fn;
+      return this;
+    }
+    makeOptionMandatory(mandatory = true) {
+      this.mandatory = !!mandatory;
+      return this;
+    }
+    hideHelp(hide = true) {
+      this.hidden = !!hide;
+      return this;
+    }
+    _collectValue(value, previous) {
+      if (previous === this.defaultValue || !Array.isArray(previous)) {
+        return [value];
+      }
+      previous.push(value);
+      return previous;
+    }
+    choices(values) {
+      this.argChoices = values.slice();
+      this.parseArg = (arg, previous) => {
+        if (!this.argChoices.includes(arg)) {
+          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
+        }
+        if (this.variadic) {
+          return this._collectValue(arg, previous);
+        }
+        return arg;
+      };
+      return this;
+    }
+    name() {
+      if (this.long) {
+        return this.long.replace(/^--/, "");
+      }
+      return this.short.replace(/^-/, "");
+    }
+    attributeName() {
+      if (this.negate) {
+        return camelcase(this.name().replace(/^no-/, ""));
+      }
+      return camelcase(this.name());
+    }
+    helpGroup(heading) {
+      this.helpGroupHeading = heading;
+      return this;
+    }
+    is(arg) {
+      return this.short === arg || this.long === arg;
+    }
+    isBoolean() {
+      return !this.required && !this.optional && !this.negate;
+    }
+  }
+
+  class DualOptions {
+    constructor(options) {
+      this.positiveOptions = new Map;
+      this.negativeOptions = new Map;
+      this.dualOptions = new Set;
+      options.forEach((option) => {
+        if (option.negate) {
+          this.negativeOptions.set(option.attributeName(), option);
+        } else {
+          this.positiveOptions.set(option.attributeName(), option);
+        }
+      });
+      this.negativeOptions.forEach((value, key) => {
+        if (this.positiveOptions.has(key)) {
+          this.dualOptions.add(key);
+        }
+      });
+    }
+    valueFromOption(value, option) {
+      const optionKey = option.attributeName();
+      if (!this.dualOptions.has(optionKey))
+        return true;
+      const preset = this.negativeOptions.get(optionKey).presetArg;
+      const negativeValue = preset !== undefined ? preset : false;
+      return option.negate === (negativeValue === value);
+    }
+  }
+  function camelcase(str) {
+    return str.split("-").reduce((str2, word) => {
+      return str2 + word[0].toUpperCase() + word.slice(1);
+    });
+  }
+  function splitOptionFlags(flags) {
+    let shortFlag;
+    let longFlag;
+    const shortFlagExp = /^-[^-]$/;
+    const longFlagExp = /^--[^-]/;
+    const flagParts = flags.split(/[ |,]+/).concat("guard");
+    if (shortFlagExp.test(flagParts[0]))
+      shortFlag = flagParts.shift();
+    if (longFlagExp.test(flagParts[0]))
+      longFlag = flagParts.shift();
+    if (!shortFlag && shortFlagExp.test(flagParts[0]))
+      shortFlag = flagParts.shift();
+    if (!shortFlag && longFlagExp.test(flagParts[0])) {
+      shortFlag = longFlag;
+      longFlag = flagParts.shift();
+    }
+    if (flagParts[0].startsWith("-")) {
+      const unsupportedFlag = flagParts[0];
+      const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
+      if (/^-[^-][^-]/.test(unsupportedFlag))
+        throw new Error(`${baseError}
+- a short flag is a single dash and a single character
+  - either use a single dash and a single character (for a short flag)
+  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`);
+      if (shortFlagExp.test(unsupportedFlag))
+        throw new Error(`${baseError}
+- too many short flags`);
+      if (longFlagExp.test(unsupportedFlag))
+        throw new Error(`${baseError}
+- too many long flags`);
+      throw new Error(`${baseError}
+- unrecognised flag format`);
+    }
+    if (shortFlag === undefined && longFlag === undefined)
+      throw new Error(`option creation failed due to no flags found in '${flags}'.`);
+    return { shortFlag, longFlag };
+  }
+  exports.Option = Option;
+  exports.DualOptions = DualOptions;
+});
+
+// ../../node_modules/commander/lib/suggestSimilar.js
+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 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 i = 1;i <= a.length; i++) {
+        let cost = 1;
+        if (a[i - 1] === b[j - 1]) {
+          cost = 0;
+        } else {
+          cost = 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);
+        }
+      }
+    }
+    return d[a.length][b.length];
+  }
+  function suggestSimilar(word, candidates) {
+    if (!candidates || candidates.length === 0)
+      return "";
+    candidates = Array.from(new Set(candidates));
+    const searchingOptions = word.startsWith("--");
+    if (searchingOptions) {
+      word = word.slice(2);
+      candidates = candidates.map((candidate) => candidate.slice(2));
+    }
+    let similar = [];
+    let bestDistance = maxDistance;
+    const minSimilarity = 0.4;
+    candidates.forEach((candidate) => {
+      if (candidate.length <= 1)
+        return;
+      const distance = editDistance(word, candidate);
+      const length = Math.max(word.length, candidate.length);
+      const similarity = (length - distance) / length;
+      if (similarity > minSimilarity) {
+        if (distance < bestDistance) {
+          bestDistance = distance;
+          similar = [candidate];
+        } else if (distance === bestDistance) {
+          similar.push(candidate);
+        }
+      }
+    });
+    similar.sort((a, b) => a.localeCompare(b));
+    if (searchingOptions) {
+      similar = similar.map((candidate) => `--${candidate}`);
+    }
+    if (similar.length > 1) {
+      return `
+(Did you mean one of ${similar.join(", ")}?)`;
+    }
+    if (similar.length === 1) {
+      return `
+(Did you mean ${similar[0]}?)`;
+    }
+    return "";
+  }
+  exports.suggestSimilar = suggestSimilar;
+});
+
+// ../../node_modules/commander/lib/command.js
+var require_command = __commonJS((exports) => {
+  var EventEmitter = __require("node:events").EventEmitter;
+  var childProcess4 = __require("node:child_process");
+  var path3 = __require("node:path");
+  var fs7 = __require("node:fs");
+  var process9 = __require("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();
+
   class Command extends EventEmitter {
     constructor(name) {
       super();
@@ -813,13 +1587,13 @@ var require_command = __commonJS((exports) => {
       this._showSuggestionAfterError = true;
       this._savedState = null;
       this._outputConfiguration = {
-        writeOut: (str) => process2.stdout.write(str),
-        writeErr: (str) => process2.stderr.write(str),
+        writeOut: (str) => process9.stdout.write(str),
+        writeErr: (str) => process9.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: () => process9.stdout.isTTY ? process9.stdout.columns : undefined,
+        getErrHelpWidth: () => process9.stderr.isTTY ? process9.stderr.columns : undefined,
+        getOutHasColors: () => useColor() ?? (process9.stdout.isTTY && process9.stdout.hasColors?.()),
+        getErrHasColors: () => useColor() ?? (process9.stderr.isTTY && process9.stderr.hasColors?.()),
         stripColor: (str) => stripColor(str)
       };
       this._hidden = false;
@@ -1027,7 +1801,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (this._exitCallback) {
         this._exitCallback(new CommanderError(exitCode, code, message));
       }
-      process2.exit(exitCode);
+      process9.exit(exitCode);
     }
     action(fn) {
       const listener = (args) => {
@@ -1224,16 +1998,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       parseOptions = parseOptions || {};
       if (argv === undefined && parseOptions.from === undefined) {
-        if (process2.versions?.electron) {
+        if (process9.versions?.electron) {
           parseOptions.from = "electron";
         }
-        const execArgv = process2.execArgv ?? [];
+        const execArgv = process9.execArgv ?? [];
         if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
           parseOptions.from = "eval";
         }
       }
       if (argv === undefined) {
-        argv = process2.argv;
+        argv = process9.argv;
       }
       this.rawArgs = argv.slice();
       let userArgs;
@@ -1244,7 +2018,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           userArgs = argv.slice(2);
           break;
         case "electron":
-          if (process2.defaultApp) {
+          if (process9.defaultApp) {
             this._scriptPath = argv[1];
             userArgs = argv.slice(2);
           } else {
@@ -1304,7 +2078,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
@@ -1318,12 +2092,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;
@@ -1335,42 +2109,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 (process9.platform !== "win32") {
         if (launchWithNode) {
           args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-          proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
+          args = incrementNodeInspectorPort(process9.execArgv).concat(args);
+          proc = childProcess4.spawn(process9.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(process9.execArgv).concat(args);
+        proc = childProcess4.spawn(process9.execPath, args, { stdio: "inherit" });
       }
       if (!proc.killed) {
         const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
         signals.forEach((signal) => {
-          process2.on(signal, () => {
+          process9.on(signal, () => {
             if (proc.killed === false && proc.exitCode === null) {
               proc.kill(signal);
             }
@@ -1381,7 +2155,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       proc.on("close", (code) => {
         code = code ?? 1;
         if (!exitCallback) {
-          process2.exit(code);
+          process9.exit(code);
         } else {
           exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
         }
@@ -1393,7 +2167,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           throw new Error(`'${executableFile}' not executable`);
         }
         if (!exitCallback) {
-          process2.exit(1);
+          process9.exit(1);
         } else {
           const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
           wrappedError.nestedError = err;
@@ -1742,11 +2516,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 process9.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()}`, process9.env[option.envVar]);
             } else {
               this.emit(`optionEnv:${option.name()}`);
             }
@@ -1904,1015 +2678,239 @@ 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 = str;
-      return this;
-    }
-    name(str) {
-      if (str === undefined)
-        return this._name;
-      this._name = str;
-      return this;
-    }
-    helpGroup(heading) {
-      if (heading === undefined)
-        return this._helpGroupHeading ?? "";
-      this._helpGroupHeading = heading;
-      return this;
-    }
-    commandsGroup(heading) {
-      if (heading === undefined)
-        return this._defaultCommandGroup ?? "";
-      this._defaultCommandGroup = heading;
-      return this;
-    }
-    optionsGroup(heading) {
-      if (heading === undefined)
-        return this._defaultOptionGroup ?? "";
-      this._defaultOptionGroup = heading;
-      return this;
-    }
-    _initOptionGroup(option) {
-      if (this._defaultOptionGroup && !option.helpGroupHeading)
-        option.helpGroup(this._defaultOptionGroup);
-    }
-    _initCommandGroup(cmd) {
-      if (this._defaultCommandGroup && !cmd.helpGroup())
-        cmd.helpGroup(this._defaultCommandGroup);
-    }
-    nameFromFilename(filename) {
-      this._name = path.basename(filename, path.extname(filename));
-      return this;
-    }
-    executableDir(path2) {
-      if (path2 === undefined)
-        return this._executableDir;
-      this._executableDir = path2;
-      return this;
-    }
-    helpInformation(contextOptions) {
-      const helper = this.createHelp();
-      const context = this._getOutputContext(contextOptions);
-      helper.prepareContext({
-        error: context.error,
-        helpWidth: context.helpWidth,
-        outputHasColors: context.hasColors
-      });
-      const text = helper.formatHelp(this, helper);
-      if (context.hasColors)
-        return text;
-      return this._outputConfiguration.stripColor(text);
-    }
-    _getOutputContext(contextOptions) {
-      contextOptions = contextOptions || {};
-      const error = !!contextOptions.error;
-      let baseWrite;
-      let hasColors;
-      let helpWidth;
-      if (error) {
-        baseWrite = (str) => this._outputConfiguration.writeErr(str);
-        hasColors = this._outputConfiguration.getErrHasColors();
-        helpWidth = this._outputConfiguration.getErrHelpWidth();
-      } else {
-        baseWrite = (str) => this._outputConfiguration.writeOut(str);
-        hasColors = this._outputConfiguration.getOutHasColors();
-        helpWidth = this._outputConfiguration.getOutHelpWidth();
-      }
-      const write = (str) => {
-        if (!hasColors)
-          str = this._outputConfiguration.stripColor(str);
-        return baseWrite(str);
-      };
-      return { error, write, hasColors, helpWidth };
-    }
-    outputHelp(contextOptions) {
-      let deprecatedCallback;
-      if (typeof contextOptions === "function") {
-        deprecatedCallback = contextOptions;
-        contextOptions = undefined;
-      }
-      const outputContext = this._getOutputContext(contextOptions);
-      const eventContext = {
-        error: outputContext.error,
-        write: outputContext.write,
-        command: this
-      };
-      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", eventContext));
-      this.emit("beforeHelp", eventContext);
-      let helpInformation = this.helpInformation({ error: outputContext.error });
-      if (deprecatedCallback) {
-        helpInformation = deprecatedCallback(helpInformation);
-        if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
-          throw new Error("outputHelp callback must return a string or a Buffer");
-        }
-      }
-      outputContext.write(helpInformation);
-      if (this._getHelpOption()?.long) {
-        this.emit(this._getHelpOption().long);
-      }
-      this.emit("afterHelp", eventContext);
-      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", eventContext));
-    }
-    helpOption(flags, description) {
-      if (typeof flags === "boolean") {
-        if (flags) {
-          if (this._helpOption === null)
-            this._helpOption = undefined;
-          if (this._defaultOptionGroup) {
-            this._initOptionGroup(this._getHelpOption());
-          }
-        } else {
-          this._helpOption = null;
-        }
-        return this;
-      }
-      this._helpOption = this.createOption(flags ?? "-h, --help", description ?? "display help for command");
-      if (flags || description)
-        this._initOptionGroup(this._helpOption);
-      return this;
-    }
-    _getHelpOption() {
-      if (this._helpOption === undefined) {
-        this.helpOption(undefined, undefined);
-      }
-      return this._helpOption;
-    }
-    addHelpOption(option) {
-      this._helpOption = option;
-      this._initOptionGroup(option);
-      return this;
-    }
-    help(contextOptions) {
-      this.outputHelp(contextOptions);
-      let exitCode = Number(process2.exitCode ?? 0);
-      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
-        exitCode = 1;
-      }
-      this._exit(exitCode, "commander.help", "(outputHelp)");
-    }
-    addHelpText(position, text) {
-      const allowedValues = ["beforeAll", "before", "after", "afterAll"];
-      if (!allowedValues.includes(position)) {
-        throw new Error(`Unexpected value for position to addHelpText.
-Expecting one of '${allowedValues.join("', '")}'`);
-      }
-      const helpEvent = `${position}Help`;
-      this.on(helpEvent, (context) => {
-        let helpStr;
-        if (typeof text === "function") {
-          helpStr = text({ error: context.error, command: context.command });
-        } else {
-          helpStr = text;
-        }
-        if (helpStr) {
-          context.write(`${helpStr}
-`);
-        }
-      });
-      return this;
-    }
-    _outputHelpIfRequested(args) {
-      const helpOption = this._getHelpOption();
-      const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
-      if (helpRequested) {
-        this.outputHelp();
-        this._exit(0, "commander.helpDisplayed", "(outputHelp)");
-      }
-    }
-  }
-  function incrementNodeInspectorPort(args) {
-    return args.map((arg) => {
-      if (!arg.startsWith("--inspect")) {
-        return arg;
-      }
-      let debugOption;
-      let debugHost = "127.0.0.1";
-      let debugPort = "9229";
-      let match;
-      if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
-        debugOption = match[1];
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
-        debugOption = match[1];
-        if (/^\d+$/.test(match[3])) {
-          debugPort = match[3];
-        } else {
-          debugHost = match[3];
-        }
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
-        debugOption = match[1];
-        debugHost = match[3];
-        debugPort = match[4];
-      }
-      if (debugOption && debugPort !== "0") {
-        return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
-      }
-      return arg;
-    });
-  }
-  function useColor() {
-    if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false")
-      return false;
-    if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== undefined)
-      return true;
-    return;
-  }
-  exports.Command = Command;
-  exports.useColor = useColor;
-});
-
-// ../../node_modules/commander/index.js
-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;
-});
-
-// ../../node_modules/is-inside-container/node_modules/is-docker/index.js
-import fs from "node:fs";
-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 isDockerCached;
-var init_is_docker = () => {};
-
-// ../../node_modules/is-inside-container/index.js
-import fs2 from "node:fs";
-function isInsideContainer() {
-  if (cachedResult === undefined) {
-    cachedResult = hasContainerEnv() || isDocker();
-  }
-  return cachedResult;
-}
-var cachedResult, hasContainerEnv = () => {
-  try {
-    fs2.statSync("/run/.containerenv");
-    return true;
-  } catch {
-    return false;
-  }
-};
-var init_is_inside_container = __esm(() => {
-  init_is_docker();
-});
-
-// ../../node_modules/wsl-utils/node_modules/is-wsl/index.js
-import process2 from "node:process";
-import os from "node:os";
-import fs3 from "node:fs";
-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;
-}, is_wsl_default;
-var init_is_wsl = __esm(() => {
-  init_is_inside_container();
-  is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
-});
-
-// ../../node_modules/powershell-utils/index.js
-import process3 from "node:process";
-import { Buffer as Buffer2 } from "node:buffer";
-import { promisify } from "node:util";
-import childProcess from "node:child_process";
-var execFile, powerShellPath = () => `${process3.env.SYSTEMROOT || process3.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`, executePowerShell = async (command, options = {}) => {
-  const {
-    powerShellPath: psPath,
-    ...execFileOptions
-  } = options;
-  const encodedCommand = executePowerShell.encodeCommand(command);
-  return execFile(psPath ?? powerShellPath(), [
-    ...executePowerShell.argumentsPrefix,
-    encodedCommand
-  ], {
-    encoding: "utf8",
-    ...execFileOptions
-  });
-};
-var init_powershell_utils = __esm(() => {
-  execFile = promisify(childProcess.execFile);
-  executePowerShell.argumentsPrefix = [
-    "-NoProfile",
-    "-NonInteractive",
-    "-ExecutionPolicy",
-    "Bypass",
-    "-EncodedCommand"
-  ];
-  executePowerShell.encodeCommand = (command) => Buffer2.from(command, "utf16le").toString("base64");
-  executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
-});
-
-// ../../node_modules/wsl-utils/utilities.js
-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, "");
-  }
-}
-
-// ../../node_modules/wsl-utils/index.js
-import { promisify as promisify2 } from "node:util";
-import childProcess2 from "node:child_process";
-import fs4, { constants as fsConstants } from "node:fs/promises";
-var execFile2, wslDrivesMountPoint, powerShellPathFromWsl = async () => {
-  const mountPoint = await wslDrivesMountPoint();
-  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
-}, powerShellPath2, canAccessPowerShellPromise, canAccessPowerShell = async () => {
-  canAccessPowerShellPromise ??= (async () => {
-    try {
-      const psPath = await powerShellPath2();
-      await fs4.access(psPath, fsConstants.X_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-  return canAccessPowerShellPromise;
-}, 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();
-}, convertWslPathToWindows = async (path) => {
-  if (/^[a-z]+:\/\//i.test(path)) {
-    return path;
-  }
-  try {
-    const { stdout } = await execFile2("wslpath", ["-aw", path], { encoding: "utf8" });
-    return stdout.trim();
-  } catch {
-    return path;
-  }
-};
-var init_wsl_utils = __esm(() => {
-  init_is_wsl();
-  init_powershell_utils();
-  init_is_wsl();
-  execFile2 = promisify2(childProcess2.execFile);
-  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;
-    };
-  })();
-  powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
-});
-
-// ../../node_modules/open/node_modules/define-lazy-prop/index.js
-function defineLazyProperty(object, propertyName, valueGetter) {
-  const define2 = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
-  Object.defineProperty(object, propertyName, {
-    configurable: true,
-    enumerable: true,
-    get() {
-      const result = valueGetter();
-      define2(result);
-      return result;
-    },
-    set(value) {
-      define2(value);
-    }
-  });
-  return object;
-}
-
-// ../../node_modules/default-browser-id/index.js
-import { promisify as promisify3 } from "node:util";
-import process4 from "node:process";
-import { execFile as execFile3 } from "node:child_process";
-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 execFileAsync;
-var init_default_browser_id = __esm(() => {
-  execFileAsync = promisify3(execFile3);
-});
-
-// ../../node_modules/run-applescript/index.js
-import process5 from "node:process";
-import { promisify as promisify4 } from "node:util";
-import { execFile as execFile4, execFileSync } from "node:child_process";
-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();
-}
-var execFileAsync2;
-var init_run_applescript = __esm(() => {
-  execFileAsync2 = promisify4(execFile4);
-});
-
-// ../../node_modules/bundle-name/index.js
-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 init_bundle_name = __esm(() => {
-  init_run_applescript();
-});
-
-// ../../node_modules/default-browser/windows.js
-import { promisify as promisify5 } from "node:util";
-import { execFile as execFile5 } from "node:child_process";
-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 execFileAsync3, windowsBrowserProgIds, _windowsBrowserProgIdMap, UnknownBrowserError;
-var init_windows = __esm(() => {
-  execFileAsync3 = promisify5(execFile5);
-  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" }
-  };
-  _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
-  UnknownBrowserError = class UnknownBrowserError extends Error {
-  };
-});
-
-// ../../node_modules/default-browser/index.js
-import { promisify as promisify6 } from "node:util";
-import process6 from "node:process";
-import { execFile as execFile6 } from "node:child_process";
-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 execFileAsync4, titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
-var init_default_browser = __esm(() => {
-  init_default_browser_id();
-  init_bundle_name();
-  init_windows();
-  init_windows();
-  execFileAsync4 = promisify6(execFile6);
-});
-
-// ../../node_modules/is-in-ssh/index.js
-import process7 from "node:process";
-var isInSsh, is_in_ssh_default;
-var init_is_in_ssh = __esm(() => {
-  isInSsh = Boolean(process7.env.SSH_CONNECTION || process7.env.SSH_CLIENT || process7.env.SSH_TTY);
-  is_in_ssh_default = isInSsh;
-});
-
-// ../../node_modules/open/index.js
-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";
-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 fallbackAttemptSymbol, __dirname2, localXdgOpenPath, platform, arch, 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");
-}, 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;
+      this._usage = str;
+      return this;
     }
-    if (is_wsl_default && options.target) {
-      options.target = await convertWslPathToWindows(options.target);
+    name(str) {
+      if (str === undefined)
+        return this._name;
+      this._name = str;
+      return this;
     }
-    const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
-    if (options.wait) {
-      encodedArguments.push("-Wait");
+    helpGroup(heading) {
+      if (heading === undefined)
+        return this._helpGroupHeading ?? "";
+      this._helpGroupHeading = heading;
+      return this;
     }
-    if (app) {
-      encodedArguments.push(executePowerShell.escapeArgument(app));
-      if (options.target) {
-        appArguments.push(options.target);
-      }
-    } else if (options.target) {
-      encodedArguments.push(executePowerShell.escapeArgument(options.target));
+    commandsGroup(heading) {
+      if (heading === undefined)
+        return this._defaultCommandGroup ?? "";
+      this._defaultCommandGroup = heading;
+      return this;
     }
-    if (appArguments.length > 0) {
-      appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
-      encodedArguments.push("-ArgumentList", appArguments.join(","));
+    optionsGroup(heading) {
+      if (heading === undefined)
+        return this._defaultOptionGroup ?? "";
+      this._defaultOptionGroup = heading;
+      return this;
     }
-    options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
-    if (!options.wait) {
-      childProcessOptions.stdio = "ignore";
+    _initOptionGroup(option) {
+      if (this._defaultOptionGroup && !option.helpGroupHeading)
+        option.helpGroup(this._defaultOptionGroup);
     }
-  } 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;
+    _initCommandGroup(cmd) {
+      if (this._defaultCommandGroup && !cmd.helpGroup())
+        cmd.helpGroup(this._defaultCommandGroup);
     }
-    if (appArguments.length > 0) {
-      cliArguments.push(...appArguments);
+    nameFromFilename(filename) {
+      this._name = path3.basename(filename, path3.extname(filename));
+      return this;
     }
-    if (!options.wait) {
-      childProcessOptions.stdio = "ignore";
-      childProcessOptions.detached = true;
+    executableDir(path4) {
+      if (path4 === undefined)
+        return this._executableDir;
+      this._executableDir = path4;
+      return this;
     }
-  }
-  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((resolve, reject) => {
-      subprocess.once("error", reject);
-      subprocess.once("close", (exitCode) => {
-        if (!options.allowNonzeroExitCode && exitCode !== 0) {
-          reject(new Error(`Exited with code ${exitCode}`));
-          return;
-        }
-        resolve(subprocess);
-      });
-    });
-  }
-  if (isFallbackAttempt) {
-    return new Promise((resolve, 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();
-          resolve(subprocess);
-        });
+    helpInformation(contextOptions) {
+      const helper = this.createHelp();
+      const context = this._getOutputContext(contextOptions);
+      helper.prepareContext({
+        error: context.error,
+        helpWidth: context.helpWidth,
+        outputHasColors: context.hasColors
       });
-    });
-  }
-  subprocess.unref();
-  return new Promise((resolve, reject) => {
-    subprocess.once("error", reject);
-    subprocess.once("spawn", () => {
-      subprocess.off("error", reject);
-      resolve(subprocess);
-    });
-  });
-}, open = (target, options) => {
-  if (typeof target !== "string") {
-    throw new TypeError("Expected a `target`");
-  }
-  return baseOpen({
-    ...options,
-    target
-  });
-}, apps, open_default;
-var init_open = __esm(() => {
-  init_wsl_utils();
-  init_powershell_utils();
-  init_default_browser();
-  init_is_inside_container();
-  init_is_in_ssh();
-  fallbackAttemptSymbol = Symbol("fallbackAttempt");
-  __dirname2 = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : "";
-  localXdgOpenPath = path.join(__dirname2, "xdg-open");
-  ({ platform, arch } = process8);
-  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"]
+      const text = helper.formatHelp(this, helper);
+      if (context.hasColors)
+        return text;
+      return this._outputConfiguration.stripColor(text);
     }
-  }));
-  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"]
+    _getOutputContext(contextOptions) {
+      contextOptions = contextOptions || {};
+      const error = !!contextOptions.error;
+      let baseWrite;
+      let hasColors;
+      let helpWidth;
+      if (error) {
+        baseWrite = (str) => this._outputConfiguration.writeErr(str);
+        hasColors = this._outputConfiguration.getErrHasColors();
+        helpWidth = this._outputConfiguration.getErrHelpWidth();
+      } else {
+        baseWrite = (str) => this._outputConfiguration.writeOut(str);
+        hasColors = this._outputConfiguration.getOutHasColors();
+        helpWidth = this._outputConfiguration.getOutHelpWidth();
+      }
+      const write = (str) => {
+        if (!hasColors)
+          str = this._outputConfiguration.stripColor(str);
+        return baseWrite(str);
+      };
+      return { error, write, hasColors, helpWidth };
     }
-  }));
-  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"
-  }));
-  open_default = open;
-});
-
-// ../filesystem/src/node.ts
-import { existsSync } from "node:fs";
-import * as fs6 from "node:fs/promises";
-import * as os2 from "node:os";
-import * as path2 from "node:path";
-
-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);
+    outputHelp(contextOptions) {
+      let deprecatedCallback;
+      if (typeof contextOptions === "function") {
+        deprecatedCallback = contextOptions;
+        contextOptions = undefined;
+      }
+      const outputContext = this._getOutputContext(contextOptions);
+      const eventContext = {
+        error: outputContext.error,
+        write: outputContext.write,
+        command: this
+      };
+      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", eventContext));
+      this.emit("beforeHelp", eventContext);
+      let helpInformation = this.helpInformation({ error: outputContext.error });
+      if (deprecatedCallback) {
+        helpInformation = deprecatedCallback(helpInformation);
+        if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
+          throw new Error("outputHelp callback must return a string or a Buffer");
+        }
+      }
+      outputContext.write(helpInformation);
+      if (this._getHelpOption()?.long) {
+        this.emit(this._getHelpOption().long);
+      }
+      this.emit("afterHelp", eventContext);
+      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", eventContext));
     }
-  };
-  async readFile(path3, options) {
-    try {
-      if (options) {
-        return await fs6.readFile(path3, "utf-8");
+    helpOption(flags, description) {
+      if (typeof flags === "boolean") {
+        if (flags) {
+          if (this._helpOption === null)
+            this._helpOption = undefined;
+          if (this._defaultOptionGroup) {
+            this._initOptionGroup(this._getHelpOption());
+          }
+        } else {
+          this._helpOption = null;
+        }
+        return this;
       }
-      return await fs6.readFile(path3);
-    } catch (error) {
-      if (this.isEnoent(error))
-        return null;
-      throw error;
+      this._helpOption = this.createOption(flags ?? "-h, --help", description ?? "display help for command");
+      if (flags || description)
+        this._initOptionGroup(this._helpOption);
+      return this;
     }
-  }
-  async writeFile(filePath, data) {
-    const dir = path2.dirname(filePath);
-    if (dir) {
-      await fs6.mkdir(dir, { recursive: true });
+    _getHelpOption() {
+      if (this._helpOption === undefined) {
+        this.helpOption(undefined, undefined);
+      }
+      return this._helpOption;
     }
-    await fs6.writeFile(filePath, data);
-  }
-  async appendFile(filePath, data) {
-    const dir = path2.dirname(filePath);
-    if (dir) {
-      await fs6.mkdir(dir, { recursive: true });
+    addHelpOption(option) {
+      this._helpOption = option;
+      this._initOptionGroup(option);
+      return this;
     }
-    await fs6.appendFile(filePath, data);
-  }
-  async readdir(dirPath) {
-    try {
-      return await fs6.readdir(dirPath);
-    } catch (error) {
-      if (this.isEnoent(error))
-        return [];
-      throw error;
+    help(contextOptions) {
+      this.outputHelp(contextOptions);
+      let exitCode = Number(process9.exitCode ?? 0);
+      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
+        exitCode = 1;
+      }
+      this._exit(exitCode, "commander.help", "(outputHelp)");
     }
-  }
-  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;
+    addHelpText(position, text) {
+      const allowedValues = ["beforeAll", "before", "after", "afterAll"];
+      if (!allowedValues.includes(position)) {
+        throw new Error(`Unexpected value for position to addHelpText.
+Expecting one of '${allowedValues.join("', '")}'`);
+      }
+      const helpEvent = `${position}Help`;
+      this.on(helpEvent, (context) => {
+        let helpStr;
+        if (typeof text === "function") {
+          helpStr = text({ error: context.error, command: context.command });
+        } else {
+          helpStr = text;
+        }
+        if (helpStr) {
+          context.write(`${helpStr}
+`);
+        }
+      });
+      return this;
     }
-  }
-  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 realpath(filePath) {
-    try {
-      return await fs6.realpath(filePath);
-    } catch (error) {
-      if (this.isEnoent(error))
-        return filePath;
-      throw error;
+    _outputHelpIfRequested(args) {
+      const helpOption = this._getHelpOption();
+      const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
+      if (helpRequested) {
+        this.outputHelp();
+        this._exit(0, "commander.helpDisplayed", "(outputHelp)");
+      }
     }
   }
-  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);
+  function incrementNodeInspectorPort(args) {
+    return args.map((arg) => {
+      if (!arg.startsWith("--inspect")) {
+        return arg;
+      }
+      let debugOption;
+      let debugHost = "127.0.0.1";
+      let debugPort = "9229";
+      let match;
+      if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
+        debugOption = match[1];
+      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
+        debugOption = match[1];
+        if (/^\d+$/.test(match[3])) {
+          debugPort = match[3];
+        } else {
+          debugHost = match[3];
         }
+      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
+        debugOption = match[1];
+        debugHost = match[3];
+        debugPort = match[4];
       }
-    }
+      if (debugOption && debugPort !== "0") {
+        return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
+      }
+      return arg;
+    });
   }
-  isEnoent(error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+  function useColor() {
+    if (process9.env.NO_COLOR || process9.env.FORCE_COLOR === "0" || process9.env.FORCE_COLOR === "false")
+      return false;
+    if (process9.env.FORCE_COLOR || process9.env.CLICOLOR_FORCE !== undefined)
+      return true;
+    return;
   }
-}
-var init_node = __esm(() => {
-  init_open();
+  exports.Command = Command;
+  exports.useColor = useColor;
 });
-// ../filesystem/src/index.ts
-var fsInstance, getFileSystem = () => {
-  return fsInstance;
-};
-var init_src = __esm(() => {
-  init_node();
-  init_node();
-  fsInstance = new NodeFileSystem;
+
+// ../../node_modules/commander/index.js
+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;
 });
 
 // ../../node_modules/cli-width/index.js
@@ -27364,7 +27362,7 @@ var require_src6 = __commonJS((exports) => {
 // package.json
 var package_default = {
   name: "@uipath/vertical-solutions-tool",
-  version: "1.0.2",
+  version: "1.1.0",
   description: "Scaffold and generate Vertical Solution projects.",
   private: false,
   repository: {
@@ -27419,6 +27417,9 @@ var package_default = {
   }
 };
 
+// ../common/src/attachment-binding.ts
+init_src();
+
 // ../common/src/catch-error.ts
 function isPromiseLike(value) {
   return value !== null && typeof value === "object" && typeof value.then === "function";
@@ -32578,15 +32579,26 @@ class SuccessOutput {
     }
   }
 }
-function printOutput(data, format = "json", logFn) {
+function escapeNonAscii(jsonText) {
+  return jsonText.replace(/[\u0080-\uffff]/g, (c) => {
+    const hex = c.charCodeAt(0).toString(16).padStart(4, "0");
+    return `\\u${hex}`;
+  });
+}
+function needsAsciiSafeJson(sink) {
+  return process.platform === "win32" && !sink.capabilities.isInteractive;
+}
+function printOutput(data, format = "json", logFn, asciiSafe = false) {
   if (!data) {
     logFn("Empty response object. No data to display.");
     return;
   }
   switch (format) {
-    case "json":
-      logFn(JSON.stringify(data, null, 2));
+    case "json": {
+      const json2 = JSON.stringify(data, null, 2);
+      logFn(asciiSafe ? escapeNonAscii(json2) : json2);
       break;
+    }
     case "yaml":
       logFn(toYaml(data));
       break;
@@ -32621,7 +32633,7 @@ function printOutput(data, format = "json", logFn) {
 function logOutput(data, format = "json") {
   const sink = getOutputSink();
   printOutput(data, format, (msg) => sink.writeOut(`${msg}
-`));
+`), needsAsciiSafeJson(sink));
 }
 function cellToString(val) {
   return val != null && typeof val === "object" ? JSON.stringify(val) : String(val ?? "");
@@ -32801,7 +32813,9 @@ var OutputFormatter;
     const format = getOutputFormat();
     const sink = getOutputSink();
     if (format === "json") {
-      sink.writeErr(`${JSON.stringify(data)}
+      const json2 = JSON.stringify(data);
+      const safe = needsAsciiSafeJson(sink) ? escapeNonAscii(json2) : json2;
+      sink.writeErr(`${safe}
 `);
     } else {
       for (const [key, value] of Object.entries(data)) {
@@ -32817,9 +32831,10 @@ var OutputFormatter;
       data.Data = applyFilter(data.Data, filter);
     }
     const lines = [];
+    const sink = getOutputSink();
     printOutput(data, getOutputFormat(), (msg) => {
       lines.push(msg);
-    });
+    }, needsAsciiSafeJson(sink));
     return lines.join(`
 `);
   }
@@ -54989,7 +55004,9 @@ var DEFAULT_SCOPES = [
   "AutomationSolutions",
   "StudioWebTypeCacheService",
   "Docs.GPT.Search",
-  "Insights"
+  "Insights",
+  "ReferenceToken",
+  "Audit.Read"
 ];
 var normalizeAndValidateBaseUrl = (rawUrl) => {
   let baseUrl = rawUrl;
@@ -55128,6 +55145,7 @@ var getTokenExpiration = (accessToken) => {
 
 // ../auth/src/envAuth.ts
 var ENV_AUTH_ENABLE_VAR = "UIPATH_CLI_ENABLE_ENV_AUTH";
+var ENFORCE_ROBOT_AUTH_VAR = "UIPATH_CLI_ENFORCE_ROBOT_AUTH";
 var ENV_AUTH_VARS = {
   token: "UIPATH_CLI_AUTH_TOKEN",
   organizationName: "UIPATH_CLI_ORGANIZATION_NAME",
@@ -55143,6 +55161,7 @@ class EnvAuthConfigError extends Error {
   }
 }
 var isEnvAuthEnabled = () => process.env[ENV_AUTH_ENABLE_VAR] === "true";
+var isRobotAuthEnforced = () => process.env[ENFORCE_ROBOT_AUTH_VAR] === "true";
 var requireEnv = (name) => {
   const value = process.env[name];
   if (!value) {
@@ -55184,7 +55203,9 @@ var readAuthFromEnv = () => {
     expiration
   };
 };
+
 // ../auth/src/robotClientFallback.ts
+init_src();
 var DEFAULT_TIMEOUT_MS = 1000;
 var CLOSE_TIMEOUT_MS = 500;
 var NOTICE_SENTINEL = Symbol.for("@uipath/auth/robotFallbackNoticePrinted");
@@ -55196,6 +55217,35 @@ var printNoticeOnce = () => {
   catchError2(() => process.stderr.write(`Using UiPath Robot credentials. Run 'uip login' for a dedicated session.
 `));
 };
+var ROBOT_USER_SERVICES_PIPE = "UiPathUserServices";
+var ROBOT_USER_SERVICES_ALTERNATE_PIPE = `${ROBOT_USER_SERVICES_PIPE}Alternate`;
+var PIPE_NAME_MAX_LENGTH = 103;
+var getRobotIpcPipeNames = async () => {
+  const fs7 = getFileSystem();
+  const username = fs7.env.getenv("USER") ?? fs7.env.getenv("USERNAME");
+  if (!username) {
+    throw new Error("Unable to determine current username");
+  }
+  const tempPath = fs7.env.getenv("TMPDIR") ?? "/tmp/";
+  return [ROBOT_USER_SERVICES_PIPE, ROBOT_USER_SERVICES_ALTERNATE_PIPE].map((baseName) => fs7.path.join(tempPath, `${baseName}_${username}`).substring(0, PIPE_NAME_MAX_LENGTH));
+};
+var defaultIsRobotIpcAvailable = async () => {
+  if (process.platform === "win32") {
+    return true;
+  }
+  const [pipeNamesError, pipeNames] = await catchError2(getRobotIpcPipeNames());
+  if (pipeNamesError || !pipeNames) {
+    return false;
+  }
+  const fs7 = getFileSystem();
+  for (const pipeName of pipeNames) {
+    const [existsError, exists] = await catchError2(fs7.exists(pipeName));
+    if (!existsError && exists === true) {
+      return true;
+    }
+  }
+  return false;
+};
 var withTimeout = (promise2, timeoutMs) => new Promise((resolve2, reject) => {
   const timer = setTimeout(() => reject(new Error(`Robot IPC call timed out after ${timeoutMs}ms`)), timeoutMs);
   promise2.then((value) => {
@@ -55227,14 +55277,20 @@ var defaultLoadModule = async () => {
 var tryRobotClientFallback = async (options = {}) => {
   if (isBrowser())
     return;
-  if (process.env.CI || process.env.GITHUB_ACTIONS) {
-    return;
-  }
-  if (process.env.UIPATH_URL) {
-    return;
+  if (!options.force) {
+    if (process.env.CI || process.env.GITHUB_ACTIONS) {
+      return;
+    }
+    if (process.env.UIPATH_URL) {
+      return;
+    }
   }
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const isRobotIpcAvailable = options.isRobotIpcAvailable ?? defaultIsRobotIpcAvailable;
   const loadModule = options.loadModule ?? defaultLoadModule;
+  if (!await isRobotIpcAvailable()) {
+    return;
+  }
   const mod2 = await loadModule();
   if (!mod2)
     return;
@@ -55502,10 +55558,6 @@ function normalizeTokenRefreshUnavailableFailure() {
   return "token refresh failed before authentication completed";
 }
 var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
-  if (isEnvAuthEnabled()) {
-    return readAuthFromEnv();
-  }
-  const { envFilePath = DEFAULT_ENV_FILENAME, ensureTokenValidityMinutes } = options;
   const {
     resolveEnvFilePath = resolveEnvFilePathAsync,
     loadEnvFile = loadEnvFileAsync,
@@ -55515,6 +55567,34 @@ var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
     resolveConfig = resolveConfigAsync,
     robotFallback = tryRobotClientFallback
   } = deps;
+  if (isRobotAuthEnforced()) {
+    if (isEnvAuthEnabled()) {
+      throw new EnvAuthConfigError(`${ENV_AUTH_ENABLE_VAR}=true and ${ENFORCE_ROBOT_AUTH_VAR}=true ` + `are mutually exclusive. Unset one of them and re-run.`);
+    }
+    const robotCreds = await robotFallback({ force: true });
+    if (!robotCreds) {
+      return {
+        loginStatus: "Not logged in",
+        hint: `${ENFORCE_ROBOT_AUTH_VAR}=true but the UiPath Robot ` + `session is unavailable. Start and sign in to the Assistant, ` + `or unset ${ENFORCE_ROBOT_AUTH_VAR} to fall back to file or ` + `env-var authentication.`
+      };
+    }
+    const expiration2 = getTokenExpiration(robotCreds.accessToken);
+    return {
+      loginStatus: "Logged in",
+      accessToken: robotCreds.accessToken,
+      baseUrl: robotCreds.baseUrl,
+      organizationName: robotCreds.organizationName,
+      organizationId: robotCreds.organizationId,
+      tenantName: robotCreds.tenantName,
+      tenantId: robotCreds.tenantId,
+      expiration: expiration2,
+      source: "robot" /* Robot */
+    };
+  }
+  if (isEnvAuthEnabled()) {
+    return readAuthFromEnv();
+  }
+  const { envFilePath = DEFAULT_ENV_FILENAME, ensureTokenValidityMinutes } = options;
   const { absolutePath } = await resolveEnvFilePath(envFilePath);
   if (absolutePath === undefined) {
     const robotCreds = await robotFallback();
@@ -55681,7 +55761,7 @@ var getAuthContext = async (options = {}) => {
     throw new Error("Tenant ID not available. Ensure UIPATH_TENANT_ID is set.");
   }
   if (options.requireTenantName && tenantName === undefined) {
-    throw new Error("Tenant not provided and UIPATH_TENANT_NAME not set. Please provide a tenant argument or set UIPATH_TENANT_NAME.");
+    throw new Error("Tenant not provided and UIPATH_TENANT_NAME not set. Run 'uip login' to select a tenant, or use 'uip login tenant set <tenant>' to switch tenants.");
   }
   return {
     baseUrl: status.baseUrl,