@uipath/integrationservice-tool 1.0.4 → 1.1.0

package/dist/tool.js

@@ -33,533 +33,837 @@ var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports,
 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)) {
@@ -568,6 +872,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) => {
@@ -581,189 +894,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();
@@ -800,13 +1574,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;
@@ -1014,7 +1788,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) => {
@@ -1211,16 +1985,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;
@@ -1231,7 +2005,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 {
@@ -1291,7 +2065,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
@@ -1305,12 +2079,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;
@@ -1322,42 +2096,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);
             }
@@ -1368,7 +2142,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)"));
         }
@@ -1380,7 +2154,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;
@@ -1729,11 +2503,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()}`);
             }
@@ -1853,1053 +2627,277 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       return this;
     }
-    summary(str) {
-      if (str === undefined)
-        return this._summary;
-      this._summary = str;
-      return this;
-    }
-    alias(alias) {
-      if (alias === undefined)
-        return this._aliases[0];
-      let command = this;
-      if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
-        command = this.commands[this.commands.length - 1];
-      }
-      if (alias === command._name)
-        throw new Error("Command alias can't be the same as its name");
-      const matchingCommand = this.parent?._findCommand(alias);
-      if (matchingCommand) {
-        const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
-        throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
-      }
-      command._aliases.push(alias);
-      return this;
-    }
-    aliases(aliases) {
-      if (aliases === undefined)
-        return this._aliases;
-      aliases.forEach((alias) => this.alias(alias));
-      return this;
-    }
-    usage(str) {
-      if (str === undefined) {
-        if (this._usage)
-          return this._usage;
-        const args = this.registeredArguments.map((arg) => {
-          return humanReadableArgName(arg);
-        });
-        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");
+    summary(str) {
+      if (str === undefined)
+        return this._summary;
+      this._summary = str;
+      return this;
     }
-    if (options.newInstance) {
-      cliArguments.push("--new");
+    alias(alias) {
+      if (alias === undefined)
+        return this._aliases[0];
+      let command = this;
+      if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
+        command = this.commands[this.commands.length - 1];
+      }
+      if (alias === command._name)
+        throw new Error("Command alias can't be the same as its name");
+      const matchingCommand = this.parent?._findCommand(alias);
+      if (matchingCommand) {
+        const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
+        throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
+      }
+      command._aliases.push(alias);
+      return this;
     }
-    if (app) {
-      cliArguments.push("-a", app);
+    aliases(aliases) {
+      if (aliases === undefined)
+        return this._aliases;
+      aliases.forEach((alias) => this.alias(alias));
+      return this;
     }
-  } else if (platform === "win32" || shouldUseWindowsInWsl) {
-    command = await powerShellPath2();
-    cliArguments.push(...executePowerShell.argumentsPrefix);
-    if (!is_wsl_default) {
-      childProcessOptions.windowsVerbatimArguments = true;
+    usage(str) {
+      if (str === undefined) {
+        if (this._usage)
+          return this._usage;
+        const args = this.registeredArguments.map((arg) => {
+          return humanReadableArgName(arg);
+        });
+        return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
+      }
+      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;
 });
 
 // ../auth/src/catch-error.ts
@@ -21138,7 +21136,7 @@ var require_dist = __commonJS((exports) => {
 // package.json
 var package_default = {
   name: "@uipath/integrationservice-tool",
-  version: "1.0.4",
+  version: "1.1.0",
   description: "Manage Integration Service connectors, connections, and triggers.",
   private: false,
   repository: {
@@ -21182,6 +21180,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";
@@ -21209,95 +21210,7 @@ function settlePromiseLike(thenable) {
     undefined
   ]);
 }
-// ../../node_modules/commander/esm.mjs
-var import__ = __toESM(require_commander(), 1);
-var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  Command,
-  Argument,
-  Option,
-  Help
-} = import__.default;
 
-// ../common/src/command-examples.ts
-var examplesByCommand = new WeakMap;
-Command.prototype.examples = function(examples) {
-  examplesByCommand.set(this, examples);
-  return this;
-};
-// ../common/src/singleton.ts
-var PREFIX = "@uipath/common/";
-var _g = globalThis;
-function singleton(ctorOrName) {
-  const name = typeof ctorOrName === "string" ? ctorOrName : ctorOrName.name;
-  const key = Symbol.for(PREFIX + name);
-  return {
-    get(fallback) {
-      return _g[key] ?? fallback;
-    },
-    set(value) {
-      _g[key] = value;
-    },
-    clear() {
-      delete _g[key];
-    },
-    getOrInit(factory, guard) {
-      const existing = _g[key];
-      if (existing != null && typeof existing === "object") {
-        if (!guard || guard(existing)) {
-          return existing;
-        }
-      }
-      const instance = factory();
-      _g[key] = instance;
-      return instance;
-    }
-  };
-}
-
-// ../common/src/output-context.ts
-function createStorage() {
-  const [error, mod] = catchError(() => __require("node:async_hooks"));
-  if (error || typeof mod?.AsyncLocalStorage !== "function") {
-    return {
-      getStore: () => {
-        return;
-      },
-      run: (_store, fn) => fn()
-    };
-  }
-  return new mod.AsyncLocalStorage;
-}
-var storageSingleton = singleton("OutputStorage");
-var sinkSlot = singleton("OutputSink");
-var outputStorage = storageSingleton.getOrInit(createStorage, (v) => ("getStore" in v));
-var CONSOLE_FALLBACK = {
-  writeOut: (str) => process.stdout.write(str),
-  writeErr: (str) => process.stderr.write(str),
-  writeLog: (str) => process.stdout.write(str),
-  capabilities: {
-    isInteractive: false,
-    supportsColor: false,
-    outputWidth: 80
-  }
-};
-function getOutputSink() {
-  return outputStorage.getStore() ?? sinkSlot.get() ?? CONSOLE_FALLBACK;
-}
-// ../common/src/completer.ts
-var COMPLETER_SYMBOL = Symbol.for("@uipath/common/completer");
-// ../common/src/console-guard.ts
-var guardInstalledSlot = singleton("ConsoleGuardInstalled");
-var savedOriginalsSlot = singleton("ConsoleGuardOriginals");
-// ../common/src/constants.ts
-var UIPATH_HOME_DIR = ".uipath";
-var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
 // ../common/src/error-handler.ts
 var DEFAULT_401 = "Unauthorized (401). Run `uip login` to authenticate.";
 var DEFAULT_403 = "Forbidden (403). Ensure the account has the required permissions.";
@@ -21433,6 +21346,95 @@ async function extractErrorMessage(error, options) {
   const { message } = await extractErrorDetails(error, options);
   return message;
 }
+// ../../node_modules/commander/esm.mjs
+var import__ = __toESM(require_commander(), 1);
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError,
+  Command,
+  Argument,
+  Option,
+  Help
+} = import__.default;
+
+// ../common/src/command-examples.ts
+var examplesByCommand = new WeakMap;
+Command.prototype.examples = function(examples) {
+  examplesByCommand.set(this, examples);
+  return this;
+};
+// ../common/src/singleton.ts
+var PREFIX = "@uipath/common/";
+var _g = globalThis;
+function singleton(ctorOrName) {
+  const name = typeof ctorOrName === "string" ? ctorOrName : ctorOrName.name;
+  const key = Symbol.for(PREFIX + name);
+  return {
+    get(fallback) {
+      return _g[key] ?? fallback;
+    },
+    set(value) {
+      _g[key] = value;
+    },
+    clear() {
+      delete _g[key];
+    },
+    getOrInit(factory, guard) {
+      const existing = _g[key];
+      if (existing != null && typeof existing === "object") {
+        if (!guard || guard(existing)) {
+          return existing;
+        }
+      }
+      const instance = factory();
+      _g[key] = instance;
+      return instance;
+    }
+  };
+}
+
+// ../common/src/output-context.ts
+function createStorage() {
+  const [error, mod] = catchError(() => __require("node:async_hooks"));
+  if (error || typeof mod?.AsyncLocalStorage !== "function") {
+    return {
+      getStore: () => {
+        return;
+      },
+      run: (_store, fn) => fn()
+    };
+  }
+  return new mod.AsyncLocalStorage;
+}
+var storageSingleton = singleton("OutputStorage");
+var sinkSlot = singleton("OutputSink");
+var outputStorage = storageSingleton.getOrInit(createStorage, (v) => ("getStore" in v));
+var CONSOLE_FALLBACK = {
+  writeOut: (str) => process.stdout.write(str),
+  writeErr: (str) => process.stderr.write(str),
+  writeLog: (str) => process.stdout.write(str),
+  capabilities: {
+    isInteractive: false,
+    supportsColor: false,
+    outputWidth: 80
+  }
+};
+function getOutputSink() {
+  return outputStorage.getStore() ?? sinkSlot.get() ?? CONSOLE_FALLBACK;
+}
+// ../common/src/completer.ts
+var COMPLETER_SYMBOL = Symbol.for("@uipath/common/completer");
+// ../common/src/console-guard.ts
+var guardInstalledSlot = singleton("ConsoleGuardInstalled");
+var savedOriginalsSlot = singleton("ConsoleGuardOriginals");
+// ../common/src/constants.ts
+var UIPATH_HOME_DIR = ".uipath";
+var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
 // ../../node_modules/@jmespath-community/jmespath/dist/index.mjs
 var isObject = (obj) => {
   return obj !== null && Object.prototype.toString.call(obj) === "[object Object]";
@@ -26477,15 +26479,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;
@@ -26520,7 +26533,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 ?? "");
@@ -26700,7 +26713,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)) {
@@ -26716,9 +26731,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(`
 `);
   }
@@ -28127,6 +28143,46 @@ JSONPath.prototype.safeVm = {
   Script: SafeScript
 };
 JSONPath.prototype.vm = vm;
+// ../common/src/option-aliases.ts
+function resolveDeprecatedOptionAlias({
+  preferredValue,
+  deprecatedValue,
+  preferredFlag,
+  deprecatedFlag
+}) {
+  const hasPreferred = preferredValue !== undefined;
+  const hasDeprecated = deprecatedValue !== undefined;
+  if (hasPreferred && hasDeprecated) {
+    return {
+      value: undefined,
+      usedDeprecated: true,
+      error: {
+        message: `${deprecatedFlag} and ${preferredFlag} are aliases. Use only ${preferredFlag}.`,
+        instructions: `Replace ${deprecatedFlag} with ${preferredFlag}.`
+      }
+    };
+  }
+  return {
+    value: hasPreferred ? preferredValue : deprecatedValue,
+    usedDeprecated: hasDeprecated
+  };
+}
+function warnDeprecatedOptionAlias(deprecatedFlag, preferredFlag) {
+  getOutputSink().writeErr(`[WARN] ${deprecatedFlag} is deprecated. Use ${preferredFlag} instead.
+`);
+}
+var TENANT_SWITCH_COMMAND = "uip login tenant set <tenant>";
+function createHiddenDeprecatedTenantOption(flags = "-t, --tenant <tenant-name>") {
+  return new Option(flags, `Tenant name. Deprecated; use ${TENANT_SWITCH_COMMAND} to switch active tenants.`).hideHelp().argParser((tenant) => {
+    warnDeprecatedTenantOption(tenant);
+    return tenant;
+  });
+}
+function warnDeprecatedTenantOption(tenant) {
+  if (tenant === undefined)
+    return;
+  warnDeprecatedOptionAlias("--tenant", TENANT_SWITCH_COMMAND);
+}
 // ../common/src/option-validators.ts
 function parsePositiveInteger(raw) {
   return parseSafeInteger(raw, 1);
@@ -35050,7 +35106,9 @@ var DEFAULT_SCOPES = [
   "AutomationSolutions",
   "StudioWebTypeCacheService",
   "Docs.GPT.Search",
-  "Insights"
+  "Insights",
+  "ReferenceToken",
+  "Audit.Read"
 ];
 var normalizeAndValidateBaseUrl = (rawUrl) => {
   let baseUrl = rawUrl;
@@ -35189,6 +35247,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",
@@ -35204,6 +35263,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) {
@@ -35245,7 +35305,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");
@@ -35257,6 +35319,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 = (promise, timeoutMs) => new Promise((resolve2, reject) => {
   const timer = setTimeout(() => reject(new Error(`Robot IPC call timed out after ${timeoutMs}ms`)), timeoutMs);
   promise.then((value) => {
@@ -35288,14 +35379,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;
@@ -35563,10 +35660,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,
@@ -35576,6 +35669,34 @@ var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
     resolveConfig: resolveConfig2 = 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();
@@ -35742,7 +35863,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,
@@ -35910,6 +36031,29 @@ async function getWebhookConfig(options, connectionId, elementInstanceId, connec
   }
   return await response.json();
 }
+async function getHttpRequestPreview(options, connectionId) {
+  const { baseUrl, accessToken, organizationId, tenantName } = await getValidatedAuthContext(options);
+  const url = `${baseUrl}/${organizationId}/${tenantName}/elements_/v3/element/instances/${encodeURIComponent(connectionId)}/http-request-preview`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "x-uipath-source": "UiPath.CodingAgent"
+    },
+    body: "{}"
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to fetch http-request preview: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  const json2 = await response.json();
+  if (!json2.url) {
+    throw new Error("http-request-preview response missing 'url' field");
+  }
+  return { url: json2.url };
+}
 function folderOverride(folderKey) {
   if (!folderKey)
     return;
@@ -36558,13 +36702,15 @@ async function writeConnectors(connectors, tenantName) {
   }));
   await writeJson(await buildPath(["connectors.json"], tenantName), compact);
 }
-function connectionsFile(folderKey) {
+function connectionsFile(folderKey, allFolders) {
+  if (allFolders)
+    return "connections.all-folders.json";
   return folderKey ? `connections.folder.${folderKey}.json` : "connections.json";
 }
-async function readConnections(connectorKey, folderKey, tenantName) {
-  return readJson(await buildPath([connectorKey, connectionsFile(folderKey)], tenantName), TTL.connections);
+async function readConnections(connectorKey, folderKey, tenantName, allFolders) {
+  return readJson(await buildPath([connectorKey, connectionsFile(folderKey, allFolders)], tenantName), TTL.connections);
 }
-async function writeConnections(connectorKey, connections, folderKey, tenantName) {
+async function writeConnections(connectorKey, connections, folderKey, tenantName, allFolders) {
   const compact = connections.map((c) => ({
     id: c.id,
     name: c.name,
@@ -36577,7 +36723,7 @@ async function writeConnections(connectorKey, connections, folderKey, tenantName
     folderKey: c.folder?.key,
     createTime: c.createTime
   }));
-  await writeJson(await buildPath([connectorKey, connectionsFile(folderKey)], tenantName), compact);
+  await writeJson(await buildPath([connectorKey, connectionsFile(folderKey, allFolders)], tenantName), compact);
 }
 async function readActivities(connectorKey, tenantName) {
   return readJson(await buildPath([connectorKey, "activities.json"], tenantName), TTL.activities);
@@ -36691,7 +36837,7 @@ var ACTIVITIES_LIST_EXAMPLES = [
 ];
 var registerActivitiesCommand = (program2) => {
   const activities = program2.command("activities").description("Manage UiPath Integration Service activities");
-  activities.command("list").description("List activities for a connector").argument("<connector-key>", "Connector key (e.g., uipath-zoho-desk)").option("-t, --tenant <tenant-name>", "Tenant").option("--refresh", "Force re-fetch from API, ignoring cache").option("--triggers", "List trigger activities only").examples(ACTIVITIES_LIST_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
+  activities.command("list").description("List activities for a connector").argument("<connector-key>", "Connector key (e.g., uipath-zoho-desk)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--refresh", "Force re-fetch from API, ignoring cache").option("--triggers", "List trigger activities only").examples(ACTIVITIES_LIST_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
     const isTriggerMode = options.triggers === true;
     const modeLabel = isTriggerMode ? "trigger" : "non-trigger";
     logger.info(`Listing ${modeLabel} activities for connector: ${connectorKey}${options.refresh ? " [refresh]" : ""}`);
@@ -36878,10 +37024,10 @@ function writePendingAuthorization(connectorKey, connectionId, response) {
   });
 }
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var LIST_CONNECTIONS_AUTH_INSTRUCTIONS = "Run 'uip login' to authenticate, or verify the tenant passed with --tenant.";
+var LIST_CONNECTIONS_AUTH_INSTRUCTIONS = "Run 'uip login' to authenticate, then use 'uip login tenant set <tenant>' if you need to switch tenants.";
 var LIST_CONNECTIONS_API_INSTRUCTIONS = "Verify the connector key and folder key, then retry. Use 'uip is connections list --help' for accepted options.";
 var EXPORT_CONNECTIONS_API_INSTRUCTIONS = "Verify the tenant and retry. Use 'uip is connections export --help' for accepted options.";
-var CONNECTIONS_CONFIG_ERROR_INSTRUCTIONS = "Run 'uip auth login' and retry. If you passed --tenant, verify the tenant name; otherwise set UIPATH_TENANT_NAME or pass --tenant <tenant-name>.";
+var CONNECTIONS_CONFIG_ERROR_INSTRUCTIONS = "Run 'uip login' and retry. Use 'uip login tenant set <tenant>' to switch tenants, or set UIPATH_TENANT_NAME for environment authentication.";
 var CONNECTIONS_UPDATE_POLLING_INTERVAL_ERROR_INSTRUCTIONS = "Verify the connection ID with 'uip is connections list --refresh', confirm --polling-interval is supported for the connection, and retry.";
 function appendListConnectionsHint(details, hint) {
   const normalizedDetails = details?.trim();
@@ -37020,6 +37166,19 @@ var CONNECTIONS_UPDATE_POLLING_INTERVAL_EXAMPLES = [
     }
   }
 ];
+var CONNECTIONS_BASE_URL_EXAMPLES = [
+  {
+    Description: "Get the API base URL for a connection",
+    Command: "uip is connections base-url a1b2c3d4-0000-0000-0000-000000000001",
+    Output: {
+      Code: "ConnectionBaseUrl",
+      Data: {
+        ConnectionId: "a1b2c3d4-0000-0000-0000-000000000001",
+        BaseUrl: "https://api.example.com/v2"
+      }
+    }
+  }
+];
 var CONNECTIONS_RENAME_EXAMPLES = [
   {
     Description: "Rename an existing connection",
@@ -37036,29 +37195,42 @@ var CONNECTIONS_RENAME_EXAMPLES = [
 function resolveFolderKey(options) {
   const folder = options.folder?.trim();
   const folderKey = options.folderKey?.trim();
-  if (folder !== undefined && folderKey !== undefined && folder !== folderKey) {
+  if (folder !== undefined && folderKey !== undefined) {
     OutputFormatter.error({
       Result: RESULTS.Failure,
-      Message: "Conflicting folder flags: --folder and --folder-key must match when both are provided.",
-      Instructions: "Use either --folder <key> or --folder-key <key>, or provide the same folder key for both."
+      Message: "--folder and --folder-key are aliases. Use only --folder-key.",
+      Instructions: "Replace --folder with --folder-key."
     });
     processContext.exit(1);
     return { hasError: true };
   }
+  if (folder !== undefined) {
+    getOutputSink().writeErr(`[WARN] --folder is deprecated. Use --folder-key instead.
+`);
+  }
   return { folderKey: folderKey ?? folder, hasError: false };
 }
 var registerConnectionsCommand = (program2) => {
   const connections = program2.command("connections").description("Manage UiPath Integration Service connections");
-  connections.command("list").description("List connections").argument("[connector-key]", "Connector key to filter by").option("--folder <key>", "Folder key to filter by (alias for --folder-key)").option("--folder-key <key>", "Folder key to filter by").option("--connection-id <id>", "Filter to a specific connection ID").option("--byoa", "Filter to BYOA (Bring Your Own Account) connections only").option("-t, --tenant <tenant-name>", "Tenant").option("--refresh", "Force re-fetch from API, ignoring cache").examples(CONNECTIONS_LIST_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
+  connections.command("list").description("List connections").argument("[connector-key]", "Connector key to filter by").option("--folder-key <key>", "Folder key to filter by").addOption(new Option("--folder <key>").hideHelp()).option("--connection-id <id>", "Filter to a specific connection ID").option("--byoa", "Filter to BYOA (Bring Your Own Account) connections only").option("--all-folders", "Return connections across all folders (cannot be combined with --folder/--folder-key)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--refresh", "Force re-fetch from API, ignoring cache").examples(CONNECTIONS_LIST_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
     const { folderKey, hasError } = resolveFolderKey(options);
     if (hasError) {
       return;
     }
+    if (options.allFolders && folderKey !== undefined) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Conflicting folder flags: --all-folders cannot be combined with --folder or --folder-key.",
+        Instructions: "Use --all-folders to list across all folders, or pass --folder/--folder-key to scope to a single folder."
+      });
+      processContext.exit(1);
+      return;
+    }
     if (folderKey !== undefined && !UUID_RE.test(folderKey)) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
         Message: `Invalid folder key: '${folderKey}'`,
-        Instructions: "Folder key must be a UUID (e.g. 717ede25-7494-44d5-9d65-5dab660653f6). Provide it with --folder or --folder-key."
+        Instructions: "Folder key must be a UUID (e.g. 717ede25-7494-44d5-9d65-5dab660653f6). Provide it with --folder-key."
       });
       processContext.exit(1);
       return;
@@ -37077,13 +37249,16 @@ var registerConnectionsCommand = (program2) => {
     let data = null;
     if (connectorKey) {
       if (!options.refresh) {
-        data = await readConnections(connectorKey, folderKey, options.tenant);
+        data = await readConnections(connectorKey, folderKey, options.tenant, options.allFolders);
         if (data)
           logger.info(`Loaded ${data.length} connections from cache`);
       }
       if (!data) {
         const api = new ConnectorsApi(config);
-        const [fetchError, fetched] = await catchError(api.apiV1ConnectorsKeyOrIdConnectionsGet({ keyOrId: connectorKey }, folderOverride(folderKey)));
+        const [fetchError, fetched] = await catchError(api.apiV1ConnectorsKeyOrIdConnectionsGet({
+          keyOrId: connectorKey,
+          ...options.allFolders ? { allFolders: true } : {}
+        }, folderOverride(folderKey)));
         if (fetchError) {
           const { message, details, context } = await extractErrorDetails(fetchError);
           if (context?.httpStatus === 404) {
@@ -37100,13 +37275,13 @@ var registerConnectionsCommand = (program2) => {
         } else {
           data = fetched;
           if (data && data.length > 0) {
-            await writeConnections(connectorKey, data, folderKey, options.tenant);
+            await writeConnections(connectorKey, data, folderKey, options.tenant, options.allFolders);
           }
         }
       }
     } else {
       const api = new ConnectionsApi(config);
-      const [fetchError, fetched] = await catchError(api.apiV1ConnectionsGet({}, folderOverride(folderKey)));
+      const [fetchError, fetched] = await catchError(api.apiV1ConnectionsGet(options.allFolders ? { allFolders: true } : {}, folderOverride(folderKey)));
       if (fetchError) {
         const { message, details, context } = await extractErrorDetails(fetchError);
         if (context?.httpStatus === 404) {
@@ -37151,7 +37326,7 @@ var registerConnectionsCommand = (program2) => {
       });
     }
   });
-  connections.command("export").description("Export connections for audit").option("-t, --tenant <tenant-name>", "Tenant").examples(CONNECTIONS_EXPORT_EXAMPLES).trackedAction(processContext, async (options) => {
+  connections.command("export").description("Export connections for audit").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(CONNECTIONS_EXPORT_EXAMPLES).trackedAction(processContext, async (options) => {
     logger.info("Exporting connections");
     const [configError, config] = await catchError(createConnectionsConfig({ tenant: options.tenant }));
     if (configError) {
@@ -37183,7 +37358,7 @@ var registerConnectionsCommand = (program2) => {
       Data: result
     });
   });
-  connections.command("create").description("Create a new connection (OAuth flow)").argument("<connector-key>", "Connector key").option("-t, --tenant <tenant-name>", "Tenant").option("--no-browser", "Don't auto-open browser").option("--no-wait", "Return pending authorization details without polling").examples(CONNECTIONS_CREATE_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
+  connections.command("create").description("Create a new connection (OAuth flow)").argument("<connector-key>", "Connector key").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--no-browser", "Don't auto-open browser").option("--no-wait", "Return pending authorization details without polling").examples(CONNECTIONS_CREATE_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
     logger.info(`Creating connection for: ${connectorKey}`);
     const [configError, config] = await catchError(createConnectionsConfig({ tenant: options.tenant }));
     if (configError) {
@@ -37283,7 +37458,7 @@ var registerConnectionsCommand = (program2) => {
     }
     handleAuthPollFailure(pollResult.outcome, pollResult.error, "Authentication", `uip is connections create ${connectorKey}`);
   });
-  connections.command("ping").description("Check if a connection is active").argument("<connection-id>", "Connection ID").option("-t, --tenant <tenant-name>", "Tenant").option("--force-refresh", "Force a live connection status refresh").examples(CONNECTIONS_PING_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
+  connections.command("ping").description("Check if a connection is active").argument("<connection-id>", "Connection ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--force-refresh", "Force a live connection status refresh").examples(CONNECTIONS_PING_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
     logger.info(`Pinging: ${connectionId}`);
     const [configError, config] = await catchError(createConnectionsConfig({ tenant: options.tenant }));
     if (configError) {
@@ -37340,7 +37515,7 @@ var registerConnectionsCommand = (program2) => {
       processContext.exit(1);
     }
   });
-  connections.command("delete").description("Delete a connection").argument("<connection-id>", "Connection ID").option("-t, --tenant <tenant-name>", "Tenant").examples(CONNECTIONS_DELETE_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
+  connections.command("delete").description("Delete a connection").argument("<connection-id>", "Connection ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(CONNECTIONS_DELETE_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
     logger.info(`Deleting connection: ${connectionId}`);
     const [configError, config] = await catchError(createConnectionsConfig({ tenant: options.tenant }));
     if (configError) {
@@ -37373,7 +37548,7 @@ var registerConnectionsCommand = (program2) => {
       }
     });
   });
-  connections.command("update-polling-interval").description("Update a connection polling interval").argument("<connection-id>", "Connection ID").requiredOption("--polling-interval <minutes>", "Polling interval in minutes").option("-t, --tenant <tenant-name>", "Tenant").examples(CONNECTIONS_UPDATE_POLLING_INTERVAL_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
+  connections.command("update-polling-interval").description("Update a connection polling interval").argument("<connection-id>", "Connection ID").requiredOption("--polling-interval <minutes>", "Polling interval in minutes").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(CONNECTIONS_UPDATE_POLLING_INTERVAL_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
     const normalizedPollingInterval = options.pollingInterval.trim();
     const pollingIntervalInMinutes = parsePositiveInteger(normalizedPollingInterval);
     if (pollingIntervalInMinutes === undefined) {
@@ -37422,7 +37597,7 @@ var registerConnectionsCommand = (program2) => {
       }
     });
   });
-  connections.command("rename").description("Rename a connection").argument("<connection-id>", "Connection ID").requiredOption("--name <name>", "New connection name").option("-t, --tenant <tenant-name>", "Tenant").examples(CONNECTIONS_RENAME_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
+  connections.command("rename").description("Rename a connection").argument("<connection-id>", "Connection ID").requiredOption("--name <name>", "New connection name").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(CONNECTIONS_RENAME_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
     const connectionName = options.name.trim();
     if (connectionName.length === 0) {
       OutputFormatter.error({
@@ -37468,7 +37643,7 @@ var registerConnectionsCommand = (program2) => {
       }
     });
   });
-  connections.command("set-default").description("Set a connection as the default connection").argument("<connection-id>", "Connection ID").option("-t, --tenant <tenant-name>", "Tenant").examples(CONNECTIONS_SET_DEFAULT_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
+  connections.command("set-default").description("Set a connection as the default connection").argument("<connection-id>", "Connection ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(CONNECTIONS_SET_DEFAULT_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
     logger.info(`Setting default connection: ${connectionId}`);
     const [configError, config] = await catchError(createConnectionsConfig({ tenant: options.tenant }));
     if (configError) {
@@ -37503,7 +37678,7 @@ var registerConnectionsCommand = (program2) => {
       }
     });
   });
-  connections.command("edit").description("Re-authenticate a connection (OAuth flow)").argument("<connection-id>", "Connection ID").option("-t, --tenant <tenant-name>", "Tenant").option("--no-browser", "Don't auto-open browser").option("--no-wait", "Return pending authorization details without polling").examples(CONNECTIONS_EDIT_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
+  connections.command("edit").description("Re-authenticate a connection (OAuth flow)").argument("<connection-id>", "Connection ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--no-browser", "Don't auto-open browser").option("--no-wait", "Return pending authorization details without polling").examples(CONNECTIONS_EDIT_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
     logger.info(`Re-authenticating: ${connectionId}`);
     const [configError, config] = await catchError(createConnectionsConfig({ tenant: options.tenant }));
     if (configError) {
@@ -37579,6 +37754,28 @@ var registerConnectionsCommand = (program2) => {
     }
     handleAuthPollFailure(pollResult.outcome, pollResult.error, "Re-authentication", `uip is connections edit ${connectionId}`);
   });
+  connections.command("base-url").description("Get the API base URL for a connection").argument("<connection-id>", "Connection ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(CONNECTIONS_BASE_URL_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
+    logger.info(`Fetching base URL for: ${connectionId}`);
+    const [error, result] = await catchError(getHttpRequestPreview({ tenant: options.tenant }, connectionId));
+    if (error) {
+      const msg = await extractErrorMessage(error);
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: msg,
+        Instructions: "Verify the connection ID with 'uip is connections list', confirm the connection is Enabled, and retry."
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ConnectionBaseUrl",
+      Data: {
+        ConnectionId: connectionId,
+        BaseUrl: result.url
+      }
+    });
+  });
 };
 async function openBrowser(url) {
   await getFileSystem().utils.open(url);
@@ -37769,7 +37966,7 @@ var ELEMENT_EVENT_OPERATIONS_EXAMPLES = [
 var ELEMENT_AUDIT_LOGS_EXAMPLES = [
   {
     Description: "List audit logs for a connector element version",
-    Command: "uip is connectors audit-logs uipath-zoho-desk --version 1.0.0 --page-size 50",
+    Command: "uip is connectors audit-logs uipath-zoho-desk --version 1.0.0 --limit 50",
     Output: {
       Code: "ElementAuditLogList",
       Data: [
@@ -37805,12 +38002,12 @@ function normalizeList(value) {
     return [];
   return [value];
 }
-function parsePageSize(pageSize) {
+function parsePageSize(pageSize, flagName = "--limit") {
   if (pageSize === undefined)
     return {};
   const value = parsePositiveInteger(pageSize);
   if (value === undefined) {
-    return { error: "--page-size must be a positive integer." };
+    return { error: `${flagName} must be a positive integer.` };
   }
   return { value };
 }
@@ -37820,7 +38017,7 @@ async function readBlobBytes(blob) {
 }
 var registerConnectorsCommand = (program2) => {
   const connectors = program2.command("connectors").description("Manage UiPath Integration Service connectors");
-  connectors.command("list").description("List all connectors").option("-t, --tenant <tenant-name>", "Tenant").option("-f, --filter <filter>", "Filter connectors by name or key").option("--refresh", "Force re-fetch from API, ignoring cache").examples(CONNECTORS_LIST_EXAMPLES).trackedAction(processContext, async (options) => {
+  connectors.command("list").description("List all connectors").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-f, --filter <filter>", "Filter connectors by name or key").option("--refresh", "Force re-fetch from API, ignoring cache").examples(CONNECTORS_LIST_EXAMPLES).trackedAction(processContext, async (options) => {
     logger.info(`Listing connectors${options.filter ? ` (filter: ${options.filter})` : ""}${options.refresh ? " [refresh]" : ""}`);
     const [apiError, api] = await catchError(createApiClient(ConnectorsApi, { tenant: options.tenant }));
     if (apiError) {
@@ -37863,7 +38060,7 @@ var registerConnectorsCommand = (program2) => {
       Data: data.length > 0 ? formatConnectorList(data) : []
     });
   });
-  connectors.command("get").description("Get connector by key").argument("<connector-key>", "Connector key (e.g., uipath-zoho-desk)").option("-t, --tenant <tenant-name>", "Tenant").examples(CONNECTORS_GET_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
+  connectors.command("get").description("Get connector by key").argument("<connector-key>", "Connector key (e.g., uipath-zoho-desk)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(CONNECTORS_GET_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
     logger.info(`Getting connector: ${connectorKey}`);
     const [apiError, api] = await catchError(createApiClient(ConnectorsApi, { tenant: options.tenant }));
     if (apiError) {
@@ -37895,7 +38092,7 @@ var registerConnectorsCommand = (program2) => {
   registerConnectorApiCommands(connectors);
 };
 var registerConnectorApiCommands = (connectors) => {
-  connectors.command("swagger").description("Get the OpenAPI document for a connector element").argument("<connector-key>", "Connector key").option("-t, --tenant <tenant-name>", "Tenant").option("--version <version>", "Element version").examples(ELEMENT_SWAGGER_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
+  connectors.command("swagger").description("Get the OpenAPI document for a connector element").argument("<connector-key>", "Connector key").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--version <version>", "Element version").examples(ELEMENT_SWAGGER_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
     logger.info(`Getting element swagger: ${connectorKey}`);
     const [apiError, api] = await catchError(createApiClient(ElementsApi, { tenant: options.tenant }));
     if (apiError) {
@@ -37927,7 +38124,7 @@ var registerConnectorApiCommands = (connectors) => {
       Data: swagger
     });
   });
-  connectors.command("event-operations").description("List event operations for a connector element").argument("<connector-key>", "Connector key").option("-t, --tenant <tenant-name>", "Tenant").option("--version <version>", "Element version").examples(ELEMENT_EVENT_OPERATIONS_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
+  connectors.command("event-operations").description("List event operations for a connector element").argument("<connector-key>", "Connector key").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--version <version>", "Element version").examples(ELEMENT_EVENT_OPERATIONS_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
     logger.info(`Listing element event operations: ${connectorKey}`);
     const [apiError, api] = await catchError(createApiClient(ElementsApi, { tenant: options.tenant }));
     if (apiError) {
@@ -37963,9 +38160,27 @@ var registerConnectorApiCommands = (connectors) => {
       } : {}
     });
   });
-  connectors.command("audit-logs").description("List audit logs for a connector element version").argument("<connector-key>", "Connector key").requiredOption("--version <version>", "Element version").option("--page-size <n>", "Page size for pagination").option("--next-page <token>", "Next page cursor").option("-t, --tenant <tenant-name>", "Tenant").examples(ELEMENT_AUDIT_LOGS_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
+  connectors.command("audit-logs").description("List audit logs for a connector element version").argument("<connector-key>", "Connector key").requiredOption("--version <version>", "Element version").option("--limit <n>", "Page size for pagination").addOption(new Option("--page-size <n>").hideHelp()).option("--next-page <token>", "Next page cursor").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(ELEMENT_AUDIT_LOGS_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
     logger.info(`Listing element audit logs: ${connectorKey}`);
-    const parsedPageSize = parsePageSize(options.pageSize);
+    const pageSize = resolveDeprecatedOptionAlias({
+      preferredValue: options.limit,
+      deprecatedValue: options.pageSize,
+      preferredFlag: "--limit",
+      deprecatedFlag: "--page-size"
+    });
+    if (pageSize.error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: pageSize.error.message,
+        Instructions: pageSize.error.instructions
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (pageSize.usedDeprecated) {
+      warnDeprecatedOptionAlias("--page-size", "--limit");
+    }
+    const parsedPageSize = parsePageSize(pageSize.value, pageSize.usedDeprecated ? "--page-size" : "--limit");
     if (parsedPageSize.error) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
@@ -38011,7 +38226,7 @@ var registerConnectorApiCommands = (connectors) => {
       } : {}
     });
   });
-  connectors.command("export").description("Export a connector element to a file").argument("<connector-key>", "Connector key").requiredOption("--output-file <path>", "Output file path").option("--version <version>", "Element version").option("-t, --tenant <tenant-name>", "Tenant").examples(ELEMENT_EXPORT_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
+  connectors.command("export").description("Export a connector element to a file").argument("<connector-key>", "Connector key").requiredOption("--output-file <path>", "Output file path").option("--version <version>", "Element version").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(ELEMENT_EXPORT_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
     logger.info(`Exporting element: ${connectorKey}`);
     const [apiError, api] = await catchError(createApiClient(ElementsApi, { tenant: options.tenant }));
     if (apiError) {
@@ -38244,7 +38459,7 @@ function buildResourceCompactSummary(metadata, operation) {
     };
   }
   const rawParams = methodInfo.parameters || [];
-  const parameters = rawParams.filter((p) => p.type === "path" || p.type === "query").map((p) => {
+  const parameters = rawParams.filter((p) => p.type === "path" || p.type === "query" || p.type === "multipart").map((p) => {
     const param = {
       name: p.name,
       type: p.type,
@@ -38858,7 +39073,7 @@ function parseBody(options) {
   return parsed;
 }
 function addExecuteOptions(cmd) {
-  return cmd.option("--connection-id <id>", "Connection/Instance ID (required)").option("-t, --tenant <tenant-name>", "Tenant").option("--query <params>", "Query parameters (key=value&key=value or JSON)");
+  return cmd.option("--connection-id <id>", "Connection/Instance ID (required)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--query <params>", "Query parameters (key=value&key=value or JSON)");
 }
 function validateConnectionId2(options) {
   if (!options.connectionId) {
@@ -38934,7 +39149,7 @@ async function handleExecuteAction(connectorKey, objectName, httpMethod, normali
 }
 var registerResourcesCommand = (program2) => {
   const resources = program2.command("resources").description("Manage UiPath Integration Service resources");
-  resources.command("list").description("List available objects for a connector").argument("<connector-key>", "Connector key").option("--operation <operation>", `Filter by operation (${VALID_OPERATIONS})`).option("--connection-id <id>", "Connection/Instance ID").option("-t, --tenant <tenant-name>", "Tenant").option("--refresh", "Force re-fetch from API, ignoring cache").examples(RESOURCES_LIST_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
+  resources.command("list").description("List available objects for a connector").argument("<connector-key>", "Connector key").option("--operation <operation>", `Filter by operation (${VALID_OPERATIONS})`).option("--connection-id <id>", "Connection/Instance ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--refresh", "Force re-fetch from API, ignoring cache").examples(RESOURCES_LIST_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
     logger.info(`Listing resources for: ${connectorKey}`);
     const connectionId = resolveCacheKey(options.connectionId);
     let data = null;
@@ -38995,7 +39210,7 @@ var registerResourcesCommand = (program2) => {
     })();
     OutputFormatter.emitList("ResourceList", formatResourceList(filtered), { emptyInstructions, warning });
   });
-  resources.command("describe").description("Describe object fields and operations").argument("<connector-key>", "Connector key").argument("<object-name>", "Object name").option("--connection-id <id>", "Connection/Instance ID").option("-t, --tenant <tenant-name>", "Tenant").option("--operation <operation>", `Filter to a single operation (${VALID_OPERATIONS})`).option("--refresh", "Force re-fetch from API, ignoring cache").option("-f, --field <name=value>", "Parent-field value (repeatable) — runs the api-type ObjectAction (e.g. Jira GenerateSchema, Salesforce GenerateQuerySchema) and merges its custom-field response into requestFields. Requires --connection-id and --operation.", (value, prev = []) => [...prev, value], []).option("--action <name>", "Explicit api-type ObjectAction name (e.g. GenerateSchema). Optional — inferred from --field rules when omitted.").examples(RESOURCES_DESCRIBE_EXAMPLES).trackedAction(processContext, async (connectorKey, objectName, options) => {
+  resources.command("describe").description("Describe object fields and operations").argument("<connector-key>", "Connector key").argument("<object-name>", "Object name").option("--connection-id <id>", "Connection/Instance ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--operation <operation>", `Filter to a single operation (${VALID_OPERATIONS})`).option("--refresh", "Force re-fetch from API, ignoring cache").option("-f, --field <name=value>", "Parent-field value (repeatable) — runs the api-type ObjectAction (e.g. Jira GenerateSchema, Salesforce GenerateQuerySchema) and merges its custom-field response into requestFields. Requires --connection-id and --operation.", (value, prev = []) => [...prev, value], []).option("--action <name>", "Explicit api-type ObjectAction name (e.g. GenerateSchema). Optional — inferred from --field rules when omitted.").examples(RESOURCES_DESCRIBE_EXAMPLES).trackedAction(processContext, async (connectorKey, objectName, options) => {
     const operation = resolveOperationOption(options.operation);
     logger.info(`Describing: ${connectorKey}/${objectName}${operation ? ` (operation: ${operation.name})` : ""}`);
     if (!validateOperationOption(options.operation))
@@ -39273,7 +39488,7 @@ var TRIGGERS_DESCRIBE_EXAMPLES = [
 ];
 var registerTriggersCommand = (program2) => {
   const triggers = program2.command("triggers").description("Manage UiPath Integration Service trigger metadata");
-  triggers.command("objects").description("List objects for a trigger operation").argument("<connector-key>", "Connector key").argument("<operation>", "Trigger operation (CREATED, UPDATED, DELETED)").option("--connection-id <id>", "Connection/Instance ID").option("-t, --tenant <tenant-name>", "Tenant").option("--refresh", "Force re-fetch from API, ignoring cache").examples(TRIGGERS_OBJECTS_EXAMPLES).trackedAction(processContext, async (connectorKey, operation, options) => {
+  triggers.command("objects").description("List objects for a trigger operation").argument("<connector-key>", "Connector key").argument("<operation>", "Trigger operation (CREATED, UPDATED, DELETED)").option("--connection-id <id>", "Connection/Instance ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--refresh", "Force re-fetch from API, ignoring cache").examples(TRIGGERS_OBJECTS_EXAMPLES).trackedAction(processContext, async (connectorKey, operation, options) => {
     const normalizedOp = operation.toUpperCase();
     logger.info(`Listing trigger objects: ${connectorKey}/${normalizedOp}`);
     if (!options.refresh && options.connectionId) {
@@ -39315,7 +39530,7 @@ var registerTriggersCommand = (program2) => {
       warning: !options.connectionId ? "Results may not include custom objects. Use --connection-id for connection-specific data." : undefined
     });
   });
-  triggers.command("describe").description("Get metadata for a trigger object").argument("<connector-key>", "Connector key").argument("<operation>", "Trigger operation").argument("<object-name>", "Object name").option("--connection-id <id>", "Connection/Instance ID").option("-t, --tenant <tenant-name>", "Tenant").option("--refresh", "Force re-fetch from API, ignoring cache").examples(TRIGGERS_DESCRIBE_EXAMPLES).trackedAction(processContext, async (connectorKey, operation, objectName, options) => {
+  triggers.command("describe").description("Get metadata for a trigger object").argument("<connector-key>", "Connector key").argument("<operation>", "Trigger operation").argument("<object-name>", "Object name").option("--connection-id <id>", "Connection/Instance ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--refresh", "Force re-fetch from API, ignoring cache").examples(TRIGGERS_DESCRIBE_EXAMPLES).trackedAction(processContext, async (connectorKey, operation, objectName, options) => {
     const normalizedOp = operation.toUpperCase();
     logger.info(`Describing trigger: ${connectorKey}/${normalizedOp}/${objectName}`);
     if (!options.refresh && options.connectionId) {
@@ -39391,7 +39606,7 @@ var WEBHOOKS_CONFIG_EXAMPLES = [
 ];
 var registerWebhooksCommand = (program2) => {
   const webhooks = program2.command("webhooks").description("Manage Integration Service webhook configuration for triggers");
-  webhooks.command("config").description("Get the webhook URL for a connector trigger using webhooks event mode").argument("<connector-key>", "Connector key (e.g. uipath-salesforce-slack)").requiredOption("--connection-id <id>", "Connection ID (UUID) from 'is connections list'").requiredOption("--element-instance-id <id>", "Element instance ID (numeric) from 'is connections list'").option("-t, --tenant <tenant-name>", "Tenant").examples(WEBHOOKS_CONFIG_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
+  webhooks.command("config").description("Get the webhook URL for a connector trigger using webhooks event mode").argument("<connector-key>", "Connector key (e.g. uipath-salesforce-slack)").requiredOption("--connection-id <id>", "Connection ID (UUID) from 'is connections list'").requiredOption("--element-instance-id <id>", "Element instance ID (numeric) from 'is connections list'").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(WEBHOOKS_CONFIG_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
     const elementInstanceId = Number(options.elementInstanceId);
     if (!Number.isFinite(elementInstanceId)) {
       OutputFormatter.error({