@uipath/common 0.2.0 → 0.9.1

package/dist/index.js

@@ -2126,20 +2126,17 @@ var require_commander = __commonJS((exports) => {
 });
 
 // src/catch-error.ts
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
 function catchError(fnOrPromise) {
-  if (fnOrPromise instanceof Promise) {
-    return fnOrPromise.then((data) => [undefined, data]).catch((error) => [
-      error instanceof Error ? error : new Error(String(error)),
-      undefined
-    ]);
+  if (isPromiseLike(fnOrPromise)) {
+    return settlePromiseLike(fnOrPromise);
   }
   try {
     const result = fnOrPromise();
-    if (result instanceof Promise) {
-      return result.then((data) => [undefined, data]).catch((error) => [
-        error instanceof Error ? error : new Error(String(error)),
-        undefined
-      ]);
+    if (isPromiseLike(result)) {
+      return settlePromiseLike(result);
     }
     return [undefined, result];
   } catch (error) {
@@ -2149,6 +2146,12 @@ function catchError(fnOrPromise) {
     ];
   }
 }
+function settlePromiseLike(thenable) {
+  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [
+    error instanceof Error ? error : new Error(String(error)),
+    undefined
+  ]);
+}
 // ../../node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -2165,6 +2168,15 @@ var {
   Help
 } = import__.default;
 
+// src/command-examples.ts
+var examplesByCommand = new WeakMap;
+function getCommandExamples(cmd) {
+  return examplesByCommand.get(cmd) ?? [];
+}
+Command.prototype.examples = function(examples) {
+  examplesByCommand.set(this, examples);
+  return this;
+};
 // src/command-walker.ts
 function collectCommands(command, parentName, result) {
   const subcommands = command.commands;
@@ -4136,6 +4148,10 @@ var TreeInterpreter = class _TreeInterpreter {
 };
 var TreeInterpreterInstance = new TreeInterpreter;
 var TreeInterpreter_default = TreeInterpreterInstance;
+function compile(expression, options) {
+  const nodeTree = Parser_default.parse(expression, options);
+  return nodeTree;
+}
 function search(data, expression, options) {
   const nodeTree = Parser_default.parse(expression, options);
   return TreeInterpreter_default.search(nodeTree, data);
@@ -6788,9 +6804,744 @@ var safeLoad = renamed("safeLoad", "load");
 var safeLoadAll = renamed("safeLoadAll", "loadAll");
 var safeDump = renamed("safeDump", "dump");
 
-// src/logger.ts
-import { appendFileSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+// ../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";
+
+// ../../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";
+
+// ../../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";
+
+// ../../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";
+
+// ../../node_modules/is-inside-container/index.js
+import fs2 from "node:fs";
+
+// ../../node_modules/is-inside-container/node_modules/is-docker/index.js
+import fs from "node:fs";
+var isDockerCached;
+function hasDockerEnv() {
+  try {
+    fs.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === undefined) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+
+// ../../node_modules/is-inside-container/index.js
+var cachedResult;
+var hasContainerEnv = () => {
+  try {
+    fs2.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+function isInsideContainer() {
+  if (cachedResult === undefined) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+
+// ../../node_modules/wsl-utils/node_modules/is-wsl/index.js
+var isWsl = () => {
+  if (process2.platform !== "linux") {
+    return false;
+  }
+  if (os.release().toLowerCase().includes("microsoft")) {
+    if (isInsideContainer()) {
+      return false;
+    }
+    return true;
+  }
+  try {
+    if (fs3.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+      return !isInsideContainer();
+    }
+  } catch {}
+  if (fs3.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs3.existsSync("/run/WSL")) {
+    return !isInsideContainer();
+  }
+  return false;
+};
+var is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+
+// ../../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 = promisify(childProcess.execFile);
+var powerShellPath = () => `${process3.env.SYSTEMROOT || process3.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+var executePowerShell = async (command, options = {}) => {
+  const {
+    powerShellPath: psPath,
+    ...execFileOptions
+  } = options;
+  const encodedCommand = executePowerShell.encodeCommand(command);
+  return execFile(psPath ?? powerShellPath(), [
+    ...executePowerShell.argumentsPrefix,
+    encodedCommand
+  ], {
+    encoding: "utf8",
+    ...execFileOptions
+  });
+};
+executePowerShell.argumentsPrefix = [
+  "-NoProfile",
+  "-NonInteractive",
+  "-ExecutionPolicy",
+  "Bypass",
+  "-EncodedCommand"
+];
+executePowerShell.encodeCommand = (command) => Buffer2.from(command, "utf16le").toString("base64");
+executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
+
+// ../../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
+var execFile2 = promisify2(childProcess2.execFile);
+var wslDrivesMountPoint = (() => {
+  const defaultMountPoint = "/mnt/";
+  let mountPoint;
+  return async function() {
+    if (mountPoint) {
+      return mountPoint;
+    }
+    const configFilePath = "/etc/wsl.conf";
+    let isConfigFileExists = false;
+    try {
+      await fs4.access(configFilePath, fsConstants.F_OK);
+      isConfigFileExists = true;
+    } catch {}
+    if (!isConfigFileExists) {
+      return defaultMountPoint;
+    }
+    const configContent = await fs4.readFile(configFilePath, { encoding: "utf8" });
+    const parsedMountPoint = parseMountPointFromConfig(configContent);
+    if (parsedMountPoint === undefined) {
+      return defaultMountPoint;
+    }
+    mountPoint = parsedMountPoint;
+    mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+    return mountPoint;
+  };
+})();
+var powerShellPathFromWsl = async () => {
+  const mountPoint = await wslDrivesMountPoint();
+  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+var powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
+var canAccessPowerShellPromise;
+var canAccessPowerShell = async () => {
+  canAccessPowerShellPromise ??= (async () => {
+    try {
+      const psPath = await powerShellPath2();
+      await fs4.access(psPath, fsConstants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  return canAccessPowerShellPromise;
+};
+var wslDefaultBrowser = async () => {
+  const psPath = await powerShellPath2();
+  const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+  const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
+  return stdout.trim();
+};
+var convertWslPathToWindows = async (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;
+  }
+};
+
+// ../../node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define(result);
+      return result;
+    },
+    set(value) {
+      define(value);
+    }
+  });
+  return object;
+}
+
+// ../../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";
+
+// ../../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";
+var execFileAsync = promisify3(execFile3);
+async function defaultBrowserId() {
+  if (process4.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  const browserId = match?.groups.id ?? "com.apple.Safari";
+  if (browserId === "com.apple.safari") {
+    return "com.apple.Safari";
+  }
+  return browserId;
+}
+
+// ../../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";
+var execFileAsync2 = promisify4(execFile4);
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+  if (process5.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const execOptions = {};
+  if (signal) {
+    execOptions.signal = signal;
+  }
+  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
+  return stdout.trim();
+}
+
+// ../../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")`);
+}
+
+// ../../node_modules/default-browser/windows.js
+import { promisify as promisify5 } from "node:util";
+import { execFile as execFile5 } from "node:child_process";
+var execFileAsync3 = promisify5(execFile5);
+var windowsBrowserProgIds = {
+  MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+  MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
+  MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
+  AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
+  ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+  ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
+  ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
+  ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
+  BraveHTML: { name: "Brave", id: "com.brave.Browser" },
+  BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
+  BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
+  BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
+  FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+  OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
+  VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
+  "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
+};
+var _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+
+class UnknownBrowserError extends Error {
+}
+async function defaultBrowser(_execFileAsync = execFileAsync3) {
+  const { stdout } = await _execFileAsync("reg", [
+    "QUERY",
+    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+    "/v",
+    "ProgId"
+  ]);
+  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match) {
+    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+  }
+  const { id } = match.groups;
+  const dotIndex = id.lastIndexOf(".");
+  const hyphenIndex = id.lastIndexOf("-");
+  const baseIdByDot = dotIndex === -1 ? undefined : id.slice(0, dotIndex);
+  const baseIdByHyphen = hyphenIndex === -1 ? undefined : id.slice(0, hyphenIndex);
+  return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? { name: id, id };
+}
+
+// ../../node_modules/default-browser/index.js
+var execFileAsync4 = promisify6(execFile6);
+var titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+async function defaultBrowser2() {
+  if (process6.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (process6.platform === "linux") {
+    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (process6.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+
+// ../../node_modules/is-in-ssh/index.js
+import process7 from "node:process";
+var isInSsh = Boolean(process7.env.SSH_CONNECTION || process7.env.SSH_CLIENT || process7.env.SSH_TTY);
+var is_in_ssh_default = isInSsh;
+
+// ../../node_modules/open/index.js
+var fallbackAttemptSymbol = Symbol("fallbackAttempt");
+var __dirname2 = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : "";
+var localXdgOpenPath = path.join(__dirname2, "xdg-open");
+var { platform, arch } = process8;
+var tryEachApp = async (apps, opener) => {
+  if (apps.length === 0) {
+    return;
+  }
+  const errors = [];
+  for (const app of apps) {
+    try {
+      return await opener(app);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  throw new AggregateError(errors, "Failed to open in all supported apps");
+};
+var baseOpen = async (options) => {
+  options = {
+    wait: false,
+    background: false,
+    newInstance: false,
+    allowNonzeroExitCode: false,
+    ...options
+  };
+  const isFallbackAttempt = options[fallbackAttemptSymbol] === true;
+  delete options[fallbackAttemptSymbol];
+  if (Array.isArray(options.app)) {
+    return tryEachApp(options.app, (singleApp) => baseOpen({
+      ...options,
+      app: singleApp,
+      [fallbackAttemptSymbol]: true
+    }));
+  }
+  let { name: app, arguments: appArguments = [] } = options.app ?? {};
+  appArguments = [...appArguments];
+  if (Array.isArray(app)) {
+    return tryEachApp(app, (appName) => baseOpen({
+      ...options,
+      app: {
+        name: appName,
+        arguments: appArguments
+      },
+      [fallbackAttemptSymbol]: true
+    }));
+  }
+  if (app === "browser" || app === "browserPrivate") {
+    const ids = {
+      "com.google.chrome": "chrome",
+      "google-chrome.desktop": "chrome",
+      "com.brave.browser": "brave",
+      "org.mozilla.firefox": "firefox",
+      "firefox.desktop": "firefox",
+      "com.microsoft.msedge": "edge",
+      "com.microsoft.edge": "edge",
+      "com.microsoft.edgemac": "edge",
+      "microsoft-edge.desktop": "edge",
+      "com.apple.safari": "safari"
+    };
+    const flags = {
+      chrome: "--incognito",
+      brave: "--incognito",
+      firefox: "--private-window",
+      edge: "--inPrivate"
+    };
+    let browser;
+    if (is_wsl_default) {
+      const progId = await wslDefaultBrowser();
+      const browserInfo = _windowsBrowserProgIdMap.get(progId);
+      browser = browserInfo ?? {};
+    } else {
+      browser = await defaultBrowser2();
+    }
+    if (browser.id in ids) {
+      const browserName = ids[browser.id.toLowerCase()];
+      if (app === "browserPrivate") {
+        if (browserName === "safari") {
+          throw new Error("Safari doesn't support opening in private mode via command line");
+        }
+        appArguments.push(flags[browserName]);
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name: apps[browserName],
+          arguments: appArguments
+        }
+      });
+    }
+    throw new Error(`${browser.name} is not supported as a default browser`);
+  }
+  let command;
+  const cliArguments = [];
+  const childProcessOptions = {};
+  let shouldUseWindowsInWsl = false;
+  if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
+    shouldUseWindowsInWsl = await canAccessPowerShell();
+  }
+  if (platform === "darwin") {
+    command = "open";
+    if (options.wait) {
+      cliArguments.push("--wait-apps");
+    }
+    if (options.background) {
+      cliArguments.push("--background");
+    }
+    if (options.newInstance) {
+      cliArguments.push("--new");
+    }
+    if (app) {
+      cliArguments.push("-a", app);
+    }
+  } else if (platform === "win32" || shouldUseWindowsInWsl) {
+    command = await powerShellPath2();
+    cliArguments.push(...executePowerShell.argumentsPrefix);
+    if (!is_wsl_default) {
+      childProcessOptions.windowsVerbatimArguments = true;
+    }
+    if (is_wsl_default && options.target) {
+      options.target = await convertWslPathToWindows(options.target);
+    }
+    const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
+    if (options.wait) {
+      encodedArguments.push("-Wait");
+    }
+    if (app) {
+      encodedArguments.push(executePowerShell.escapeArgument(app));
+      if (options.target) {
+        appArguments.push(options.target);
+      }
+    } else if (options.target) {
+      encodedArguments.push(executePowerShell.escapeArgument(options.target));
+    }
+    if (appArguments.length > 0) {
+      appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
+      encodedArguments.push("-ArgumentList", appArguments.join(","));
+    }
+    options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+    }
+  } else {
+    if (app) {
+      command = app;
+    } else {
+      const isBundled = !__dirname2 || __dirname2 === "/";
+      let exeLocalXdgOpen = false;
+      try {
+        await fs5.access(localXdgOpenPath, fsConstants2.X_OK);
+        exeLocalXdgOpen = true;
+      } catch {}
+      const useSystemXdgOpen = process8.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+      command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+    }
+    if (appArguments.length > 0) {
+      cliArguments.push(...appArguments);
+    }
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+      childProcessOptions.detached = true;
+    }
+  }
+  if (platform === "darwin" && appArguments.length > 0) {
+    cliArguments.push("--args", ...appArguments);
+  }
+  if (options.target) {
+    cliArguments.push(options.target);
+  }
+  const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
+  if (options.wait) {
+    return new Promise((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);
+        });
+      });
+    });
+  }
+  subprocess.unref();
+  return new Promise((resolve, reject) => {
+    subprocess.once("error", reject);
+    subprocess.once("spawn", () => {
+      subprocess.off("error", reject);
+      resolve(subprocess);
+    });
+  });
+};
+var open = (target, options) => {
+  if (typeof target !== "string") {
+    throw new TypeError("Expected a `target`");
+  }
+  return baseOpen({
+    ...options,
+    target
+  });
+};
+function detectArchBinary(binary2) {
+  if (typeof binary2 === "string" || Array.isArray(binary2)) {
+    return binary2;
+  }
+  const { [arch]: archBinary } = binary2;
+  if (!archBinary) {
+    throw new Error(`${arch} is not supported`);
+  }
+  return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl } = {}) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var apps = {
+  browser: "browser",
+  browserPrivate: "browserPrivate"
+};
+defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+  darwin: "google chrome",
+  win32: "chrome",
+  linux: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]
+}, {
+  wsl: {
+    ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+    x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+  }
+}));
+defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+  darwin: "brave browser",
+  win32: "brave",
+  linux: ["brave-browser", "brave"]
+}, {
+  wsl: {
+    ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+    x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+  }
+}));
+defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+  darwin: "firefox",
+  win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+  linux: "firefox"
+}, {
+  wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+}));
+defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+  darwin: "microsoft edge",
+  win32: "msedge",
+  linux: ["microsoft-edge", "microsoft-edge-dev"]
+}, {
+  wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+}));
+defineLazyProperty(apps, "safari", () => detectPlatformBinary({
+  darwin: "Safari"
+}));
+var open_default = open;
+
+// ../filesystem/src/node.ts
+class NodeFileSystem {
+  path = {
+    join: path2.join,
+    resolve: path2.resolve,
+    relative: path2.relative,
+    dirname: path2.dirname,
+    isAbsolute: path2.isAbsolute,
+    basename: path2.basename
+  };
+  env = {
+    cwd: process.cwd,
+    homedir: os2.homedir,
+    tmpdir: os2.tmpdir,
+    getenv: (key) => process.env[key]
+  };
+  utils = {
+    open: async (url) => {
+      await open_default(url);
+    }
+  };
+  async readFile(path3, options) {
+    try {
+      if (options) {
+        return await fs6.readFile(path3, "utf-8");
+      }
+      return await fs6.readFile(path3);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+  }
+  async writeFile(filePath, data) {
+    const dir = path2.dirname(filePath);
+    if (dir) {
+      await fs6.mkdir(dir, { recursive: true });
+    }
+    await fs6.writeFile(filePath, data);
+  }
+  async appendFile(filePath, data) {
+    const dir = path2.dirname(filePath);
+    if (dir) {
+      await fs6.mkdir(dir, { recursive: true });
+    }
+    await fs6.appendFile(filePath, data);
+  }
+  async readdir(dirPath) {
+    try {
+      return await fs6.readdir(dirPath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return [];
+      throw error;
+    }
+  }
+  async stat(filePath) {
+    try {
+      const stats = await fs6.stat(filePath);
+      return {
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        size: stats.size,
+        mtimeMs: stats.mtimeMs
+      };
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+  }
+  async exists(filePath) {
+    return existsSync(filePath);
+  }
+  async mkdir(dirPath) {
+    await fs6.mkdir(dirPath, { recursive: true });
+  }
+  async rm(filePath) {
+    await fs6.rm(filePath, { recursive: true, force: true });
+  }
+  async rename(oldPath, newPath) {
+    await fs6.rename(oldPath, newPath);
+  }
+  async getTempDir() {
+    return await fs6.mkdtemp(path2.join(os2.tmpdir(), "uipath-fs-"));
+  }
+  async copyDirectory(sourcePath, destPath) {
+    const sourceStats = await this.stat(sourcePath);
+    if (!sourceStats) {
+      throw new Error(`Source directory does not exist: ${sourcePath}`);
+    }
+    if (!sourceStats.isDirectory()) {
+      throw new Error(`Source path is not a directory: ${sourcePath}`);
+    }
+    await this.mkdir(destPath);
+    const entries = await this.readdir(sourcePath);
+    for (const entry of entries) {
+      const srcEntry = path2.join(sourcePath, entry);
+      const destEntry = path2.join(destPath, entry);
+      const entryStats = await this.stat(srcEntry);
+      if (!entryStats)
+        continue;
+      if (entryStats.isDirectory()) {
+        await this.copyDirectory(srcEntry, destEntry);
+      } else if (entryStats.isFile()) {
+        const content = await this.readFile(srcEntry);
+        if (content !== null) {
+          await this.writeFile(destEntry, content);
+        }
+      }
+    }
+  }
+  isEnoent(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+  }
+}
+
+// ../filesystem/src/index.ts
+var fsInstance = new NodeFileSystem;
+var getFileSystem = () => {
+  return fsInstance;
+};
 
 // src/singleton.ts
 var PREFIX = "@uipath/common/";
@@ -6825,7 +7576,7 @@ function singleton(ctorOrName) {
 // src/output-context.ts
 function createStorage() {
   const [error, mod2] = catchError(() => __require("node:async_hooks"));
-  if (error) {
+  if (error || typeof mod2?.AsyncLocalStorage !== "function") {
     return {
       getStore: () => {
         return;
@@ -6860,8 +7611,8 @@ function setGlobalSink(sink) {
 
 // src/logger.ts
 var logFilePathSlot = singleton("logFilePath");
-function setGlobalLogFilePath(path) {
-  logFilePathSlot.set(path);
+function setGlobalLogFilePath(path3) {
+  logFilePathSlot.set(path3);
 }
 function getGlobalLogFilePath() {
   return logFilePathSlot.get("");
@@ -6880,6 +7631,8 @@ class SimpleLogger {
   level;
   logFilePath;
   fileLoggingEnabled;
+  pendingWrites = Promise.resolve();
+  pendingInit = Promise.resolve();
   constructor() {
     this.level = SimpleLogger.resolveLevel();
     this.logFilePath = "";
@@ -6894,7 +7647,7 @@ class SimpleLogger {
   static isNode = typeof process !== "undefined" && !!process.versions?.node;
   static resolveLevel() {
     if (SimpleLogger.isNode) {
-      const explicitLevel = SimpleLogger.parseLevel(process.env?.UIPCLI_LOG_LEVEL ?? "");
+      const explicitLevel = SimpleLogger.parseLevel(process.env?.UIP_LOG_LEVEL ?? "");
       if (explicitLevel !== undefined)
         return explicitLevel;
       const debugVal = process.env?.DEBUG;
@@ -6934,11 +7687,14 @@ class SimpleLogger {
     return this.fileLoggingEnabled || !!getGlobalLogFilePath();
   }
   writeToFile(formatted) {
-    const path = this.logFilePath || getGlobalLogFilePath();
-    if (!path)
+    const path3 = this.logFilePath || getGlobalLogFilePath();
+    if (!path3)
       return;
     const timestamp2 = new Date().toISOString();
-    catchError(() => appendFileSync(path, `${timestamp2} ${formatted}`));
+    this.pendingWrites = Promise.all([
+      this.pendingWrites,
+      this.pendingInit
+    ]).then(() => getFileSystem().appendFile(path3, `${timestamp2} ${formatted}`).catch(() => {}));
   }
   debug(message, ...args) {
     if (this.level > 0 /* DEBUG */)
@@ -6993,16 +7749,25 @@ class SimpleLogger {
       setGlobalLogFilePath("");
     }
   }
-  setLogFile(path) {
-    this.logFilePath = path;
-    setGlobalLogFilePath(path);
-    if (!path)
+  setLogFile(path3) {
+    this.logFilePath = path3;
+    setGlobalLogFilePath(path3);
+    if (!path3)
       return;
-    const [error] = catchError(() => {
-      mkdirSync(dirname(path), { recursive: true });
-      writeFileSync(path, "");
-    });
-    this.fileLoggingEnabled = !error;
+    this.fileLoggingEnabled = true;
+    const fs7 = getFileSystem();
+    this.pendingInit = (async () => {
+      const [error] = await catchError((async () => {
+        await fs7.mkdir(fs7.path.dirname(path3));
+        await fs7.writeFile(path3, "");
+      })());
+      if (error)
+        this.fileLoggingEnabled = false;
+    })();
+  }
+  async flushFile() {
+    await this.pendingInit;
+    await this.pendingWrites;
   }
   getLogFilePath() {
     return this.logFilePath || getGlobalLogFilePath();
@@ -7063,7 +7828,7 @@ function setOutputFormat(format) {
   formatSlot.set(format);
 }
 function getOutputFormat() {
-  return formatSlot.get("table");
+  return formatSlot.get("json");
 }
 function setOutputFilter(filter) {
   filterSlot.set(filter);
@@ -7071,7 +7836,122 @@ function setOutputFilter(filter) {
 function getOutputFilter() {
   return filterSlot.get();
 }
-// ../telemetry/src/contextstorage/adapters/node-context-storage.ts
+
+// src/telemetry/telemetry-events.ts
+var CommonTelemetryEvents = {
+  Error: "uip.error"
+};
+
+// src/registry.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+function readRegistryValue(keyPath, valueName) {
+  if (process.platform !== "win32") {
+    return "";
+  }
+  const [error, output] = catchError(() => execFileSync2("reg", ["query", keyPath, "/v", valueName], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }));
+  if (error) {
+    return "";
+  }
+  const match = output.match(new RegExp(`${valueName}\\s+REG_SZ\\s+(.+)`));
+  return match?.[1]?.trim() ?? "";
+}
+
+// src/telemetry/logger-telemetry-provider.ts
+class LoggerTelemetryProvider {
+  analyticsUniqueId;
+  constructor() {
+    this.analyticsUniqueId = readRegistryValue("HKCU\\Software\\UiPath", "AnalyticsUniqueId");
+  }
+  enrich(properties) {
+    return {
+      ...properties,
+      ...this.analyticsUniqueId ? { analyticsUniqueId: this.analyticsUniqueId } : {}
+    };
+  }
+  async trackEvent(eventName, properties) {
+    logger.debug(formatMessage("Event", eventName, this.enrich(properties)));
+  }
+  async trackException(error, properties) {
+    logger.error(formatMessage("Exception", error.message, this.enrich({
+      ...properties,
+      stack: error.stack
+    })));
+  }
+  async trackRequest(name, duration, success, properties) {
+    logger.debug(formatMessage("Request", name, this.enrich({
+      ...properties,
+      duration: `${duration}ms`,
+      success
+    })));
+  }
+  async trackDependency(name, type2, duration, success, properties) {
+    logger.debug(formatMessage("Dependency", name, this.enrich({
+      ...properties,
+      type: type2,
+      duration: `${duration}ms`,
+      success
+    })));
+  }
+}
+function formatMessage(category, name, properties) {
+  let message = `[Telemetry] [${category}] ${name}`;
+  if (properties && Object.keys(properties).length > 0) {
+    const propsStr = Object.entries(properties).filter(([_, value]) => value !== undefined).map(([key, value]) => `${key}=${value}`).join(", ");
+    if (propsStr) {
+      message += ` | ${propsStr}`;
+    }
+  }
+  return message;
+}
+
+// src/telemetry/debug-telemetry-provider.ts
+class DebugTelemetryProvider {
+  async trackEvent(eventName, _properties) {
+    logger.debug(`[Telemetry] Event: ${eventName}`);
+  }
+  async trackException(error, _properties) {
+    logger.error(`[Telemetry] Exception: ${error.message}`);
+  }
+  async trackRequest(name, duration, success, _properties) {
+    logger.debug(`[Telemetry] Request: ${name} (${duration}ms, ${success ? "ok" : "fail"})`);
+  }
+  async trackDependency(name, type2, duration, success, _properties) {
+    logger.debug(`[Telemetry] Dependency: ${name} [${type2}] (${duration}ms, ${success ? "ok" : "fail"})`);
+  }
+}
+// src/telemetry/detect-agent.ts
+var KNOWN_AGENTS = [
+  { envVar: "CLAUDECODE", value: "1", id: "claude-code" },
+  { envVar: "CURSOR_AGENT", value: "1", id: "cursor" },
+  { envVar: "GEMINI_CLI", value: "1", id: "gemini-cli" },
+  { envVar: "CODEX_SANDBOX", id: "codex" },
+  { envVar: "AUGMENT_AGENT", value: "1", id: "augment" },
+  { envVar: "CLINE_ACTIVE", value: "true", id: "cline" }
+];
+function detectAgent() {
+  for (const agent of KNOWN_AGENTS) {
+    const envValue = process.env[agent.envVar];
+    if (agent.value !== undefined) {
+      if (envValue === agent.value)
+        return agent.id;
+    } else {
+      if (envValue)
+        return agent.id;
+    }
+  }
+  const agentEnv = process.env.AGENT;
+  if (agentEnv) {
+    if (agentEnv === "1" || agentEnv === "true")
+      return "unknown";
+    if (agentEnv.length <= 32)
+      return agentEnv.toLowerCase();
+  }
+  return;
+}
+// src/telemetry/node-context-storage.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 
 class NodeContextStorage {
@@ -7083,7 +7963,7 @@ class NodeContextStorage {
     return this.storage.getStore();
   }
 }
-// ../telemetry/src/telemetry-service.ts
+// src/telemetry/telemetry-service.ts
 class TelemetryService {
   telemetryProvider;
   contextStorage;
@@ -7171,72 +8051,7 @@ class TelemetryService {
     return crypto.randomUUID().replaceAll("-", "");
   }
 }
-// src/registry.ts
-import { execFileSync } from "node:child_process";
-function readRegistryValue(keyPath, valueName) {
-  if (process.platform !== "win32") {
-    return "";
-  }
-  const [error, output] = catchError(() => execFileSync("reg", ["query", keyPath, "/v", valueName], {
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  }));
-  if (error) {
-    return "";
-  }
-  const match = output.match(new RegExp(`${valueName}\\s+REG_SZ\\s+(.+)`));
-  return match?.[1]?.trim() ?? "";
-}
-
-// src/logger-telemetry-provider.ts
-class LoggerTelemetryProvider {
-  analyticsUniqueId;
-  constructor() {
-    this.analyticsUniqueId = readRegistryValue("HKCU\\Software\\UiPath", "AnalyticsUniqueId");
-  }
-  enrich(properties) {
-    return {
-      ...properties,
-      ...this.analyticsUniqueId ? { analyticsUniqueId: this.analyticsUniqueId } : {}
-    };
-  }
-  async trackEvent(eventName, properties) {
-    logger.debug(formatMessage("Event", eventName, this.enrich(properties)));
-  }
-  async trackException(error, properties) {
-    logger.error(formatMessage("Exception", error.message, this.enrich({
-      ...properties,
-      stack: error.stack
-    })));
-  }
-  async trackRequest(name, duration, success, properties) {
-    logger.debug(formatMessage("Request", name, this.enrich({
-      ...properties,
-      duration: `${duration}ms`,
-      success
-    })));
-  }
-  async trackDependency(name, type2, duration, success, properties) {
-    logger.debug(formatMessage("Dependency", name, this.enrich({
-      ...properties,
-      type: type2,
-      duration: `${duration}ms`,
-      success
-    })));
-  }
-}
-function formatMessage(category, name, properties) {
-  let message = `[Telemetry] [${category}] ${name}`;
-  if (properties && Object.keys(properties).length > 0) {
-    const propsStr = Object.entries(properties).filter(([_, value]) => value !== undefined).map(([key, value]) => `${key}=${value}`).join(", ");
-    if (propsStr) {
-      message += ` | ${propsStr}`;
-    }
-  }
-  return message;
-}
-
-// src/node-appinsights-telemetry-provider.ts
+// src/telemetry/node-appinsights-telemetry-provider.ts
 var telemetryPropsSlot = singleton("TelemetryDefaultProps");
 var providerSlot = singleton("TelemetryProvider");
 function setGlobalTelemetryProperties(properties) {
@@ -7246,9 +8061,18 @@ function setGlobalTelemetryProperties(properties) {
 function getGlobalTelemetryProperties() {
   return telemetryPropsSlot.get();
 }
+function toOperationUrn(name) {
+  if (URL.canParse(name))
+    return name;
+  const sanitized = encodeURIComponent(name).replace(/%2F/g, "/");
+  return `urn:uip:${sanitized}`;
+}
 async function loadApplicationInsights() {
   const savedDebug = process.env.DEBUG;
   delete process.env.DEBUG;
+  if (process.env.APPLICATION_INSIGHTS_DISABLE_WARNING_LOGS === undefined) {
+    process.env.APPLICATION_INSIGHTS_DISABLE_WARNING_LOGS = "1";
+  }
   const [error, mod2] = await catchError(import("applicationinsights"));
   if (savedDebug !== undefined) {
     process.env.DEBUG = savedDebug;
@@ -7287,6 +8111,11 @@ class NodeAppInsightsTelemetryProvider {
   getSessionId() {
     return this._sessionId;
   }
+  setApplicationVersion(version) {
+    if (!this.client)
+      return;
+    this.client.context.tags[this.client.context.keys.applicationVersion] = version;
+  }
   mergeProperties(properties) {
     const globalProps = getGlobalTelemetryProperties();
     if (!globalProps && !properties)
@@ -7327,14 +8156,17 @@ class NodeAppInsightsTelemetryProvider {
     if (!client)
       return;
     const merged = this.mergeProperties(properties);
-    client.trackRequest({
+    const [trackError] = catchError(() => client.trackRequest({
       name,
-      url: name,
+      url: toOperationUrn(name),
       duration,
       resultCode: success ? "200" : "500",
       success,
       properties: merged
-    });
+    }));
+    if (trackError) {
+      logger.debug(`[AppInsights] trackRequest failed for: ${name}`);
+    }
   }
   async trackDependency(name, type2, duration, success, properties) {
     const client = this.client;
@@ -7356,18 +8188,18 @@ class NodeAppInsightsTelemetryProvider {
       logger.warn(`[AppInsights] flush error (non-fatal): nil client`);
       return;
     }
-    const [error] = await catchError(new Promise((resolve, reject) => {
+    const [error] = await catchError(new Promise((resolve2, reject) => {
       client.flush({
         callback: (response) => {
           if (!response) {
-            resolve();
+            resolve2();
             return;
           }
           const [parseError, parsed] = catchError(() => JSON.parse(response));
           if (parseError || parsed?.errors && parsed.errors.length > 0) {
             reject(new Error(response));
           } else {
-            resolve();
+            resolve2();
           }
         }
       });
@@ -7413,9 +8245,9 @@ async function getOrCreateProvider(connectionString) {
   return initPromise;
 }
 
-// src/telemetry.ts
+// src/telemetry/telemetry-init.ts
 var telemetryInstanceSlot = singleton("TelemetryService");
-var DEFAULT_AI_CONNECTION_STRING = Buffer.from("SW5zdHJ1bWVudGF0aW9uS2V5PTliZDM3NDgyLTgxMGUtNDQyYS1hYWE2LWQzOGVmNjVjNjY3NDtJbmdlc3Rpb25FbmRwb2ludD1odHRwczovL3dlc3RldXJvcGUtNS5pbi5hcHBsaWNhdGlvbmluc2lnaHRzLmF6dXJlLmNvbS87TGl2ZUVuZHBvaW50PWh0dHBzOi8vd2VzdGV1cm9wZS5saXZlZGlhZ25vc3RpY3MubW9uaXRvci5henVyZS5jb20vO0FwcGxpY2F0aW9uSWQ9MzU2OTdlZjEtOGJkMC00ZjE5LWEyN2MtZDg3Y2NhYzY2ZDJj", "base64").toString("utf-8");
+var DEFAULT_AI_CONNECTION_STRING = atob("SW5zdHJ1bWVudGF0aW9uS2V5PTliZDM3NDgyLTgxMGUtNDQyYS1hYWE2LWQzOGVmNjVjNjY3NDtJbmdlc3Rpb25FbmRwb2ludD1odHRwczovL3dlc3RldXJvcGUtNS5pbi5hcHBsaWNhdGlvbmluc2lnaHRzLmF6dXJlLmNvbS87TGl2ZUVuZHBvaW50PWh0dHBzOi8vd2VzdGV1cm9wZS5saXZlZGlhZ25vc3RpY3MubW9uaXRvci5henVyZS5jb20vO0FwcGxpY2F0aW9uSWQ9MzU2OTdlZjEtOGJkMC00ZjE5LWEyN2MtZDg3Y2NhYzY2ZDJj");
 function getConnectionString() {
   return process.env.UIPATH_AI_CONNECTION_STRING || DEFAULT_AI_CONNECTION_STRING;
 }
@@ -7472,16 +8304,19 @@ var telemetry = new Proxy({}, {
     return typeof value === "function" ? value.bind(instance) : value;
   }
 });
-async function telemetryInit(defaultProperties) {
+async function telemetryInit(options) {
   const { provider, name: providerName } = await createTelemetryProvider();
   const instance = new TelemetryService(provider, new NodeContextStorage);
   setGlobalTelemetryInstance(instance);
   _localTelemetryInstance = instance;
-  if (defaultProperties) {
-    setGlobalTelemetryProperties(defaultProperties);
-    telemetry.setDefaultProperties(defaultProperties);
-  }
   const isAppInsights = providerName === "NodeAppInsightsTelemetryProvider";
+  if (options?.version && isAppInsights) {
+    provider.setApplicationVersion(options.version);
+  }
+  if (options?.defaultProperties) {
+    setGlobalTelemetryProperties(options.defaultProperties);
+    telemetry.setDefaultProperties(options.defaultProperties);
+  }
   if (!isAppInsights) {
     logger.debug(`[Telemetry] initialized with fallback provider (${providerName}). applicationinsights package not available.`);
   }
@@ -7491,8 +8326,8 @@ async function telemetryFlushAndShutdown() {
   if (telemetryProviderInstance && "shutdown" in telemetryProviderInstance) {
     const provider = telemetryProviderInstance;
     let timer;
-    const timeout = new Promise((resolve) => {
-      timer = setTimeout(() => resolve("timeout"), FLUSH_SHUTDOWN_TIMEOUT_MS);
+    const timeout = new Promise((resolve2) => {
+      timer = setTimeout(() => resolve2("timeout"), FLUSH_SHUTDOWN_TIMEOUT_MS);
     });
     const result = await Promise.race([
       provider.flush().then(() => provider.shutdown()).then(() => "done"),
@@ -7506,14 +8341,26 @@ async function telemetryFlushAndShutdown() {
   }
 }
 
-// src/telemetry-events.ts
-var CommonTelemetryEvents = {
-  Error: "uip.error"
+// src/formatter.ts
+var RESULTS = {
+  Success: "Success",
+  Failure: "Failure",
+  ConfigError: "ConfigError",
+  AuthenticationError: "AuthenticationError",
+  ValidationError: "ValidationError",
+  TimeoutError: "TimeoutError"
+};
+var EXIT_CODES = {
+  Success: 0,
+  Failure: 1,
+  ConfigError: 1,
+  AuthenticationError: 2,
+  ValidationError: 3,
+  TimeoutError: 4
 };
 
-// src/formatter.ts
 class SuccessOutput {
-  Result = "Success";
+  Result = RESULTS.Success;
   Code;
   Data;
   Instructions;
@@ -7532,18 +8379,22 @@ class FailureOutput {
   Result;
   Message;
   Instructions;
+  Context;
   Log;
-  constructor(result, message, instructions) {
+  constructor(result, message, instructions, context) {
     this.Result = result;
     this.Message = message;
     this.Instructions = instructions;
+    if (context) {
+      this.Context = context;
+    }
     const logPath = getLogFilePath();
     if (logPath) {
       this.Log = logPath;
     }
   }
 }
-function printOutput(data, format = "table", logFn) {
+function printOutput(data, format = "json", logFn) {
   if (!data) {
     logFn("Empty response object. No data to display.");
     return;
@@ -7583,7 +8434,7 @@ function printOutput(data, format = "table", logFn) {
     }
   }
 }
-function logOutput(data, format = "table") {
+function logOutput(data, format = "json") {
   const sink = getOutputSink();
   printOutput(data, format, (msg) => sink.writeOut(`${msg}
 `));
@@ -7710,6 +8561,14 @@ function printResizableTable(data, logFn = console.log, externalLogValue) {
 function toYaml(data) {
   return dump(data);
 }
+function validateOutputFilter(filter) {
+  try {
+    compile(filter);
+    return null;
+  } catch (err) {
+    return err instanceof Error ? err : new Error(String(err));
+  }
+}
 function applyFilter(data, filter) {
   const result = search(data, filter);
   if (result == null)
@@ -7739,6 +8598,7 @@ var OutputFormatter;
   OutputFormatter.success = success;
   function error(data) {
     data.Log ??= getLogFilePath() || undefined;
+    process.exitCode = EXIT_CODES[data.Result] ?? 1;
     telemetry.trackEvent(CommonTelemetryEvents.Error, {
       result: data.Result,
       message: data.Message
@@ -7746,6 +8606,21 @@ var OutputFormatter;
     logOutput(data, getOutputFormat());
   }
   OutputFormatter.error = error;
+  function emitList(code, items, opts) {
+    const data = {
+      Result: RESULTS.Success,
+      Code: code,
+      Data: items
+    };
+    if (items.length === 0 && opts?.emptyInstructions) {
+      data.Instructions = opts.emptyInstructions;
+    }
+    if (opts?.warning) {
+      data.Warning = opts.warning;
+    }
+    success(data);
+  }
+  OutputFormatter.emitList = emitList;
   function log(data) {
     const format = getOutputFormat();
     const sink = getOutputSink();
@@ -7780,34 +8655,39 @@ function extractCommandHelp(cmd, helper) {
   const usage = helper.commandUsage(cmd);
   const description = helper.commandDescription(cmd);
   const args = helper.visibleArguments(cmd).map((arg) => {
-    const result = {
+    const result2 = {
       Name: arg.name(),
       Description: arg.description || "",
       Required: arg.required
     };
     if (arg.defaultValue !== undefined) {
-      result.Default = String(arg.defaultValue);
+      result2.Default = String(arg.defaultValue);
     }
-    return result;
+    return result2;
   });
   const options = helper.visibleOptions(cmd).map((opt) => {
-    const result = {
+    const result2 = {
       Flags: opt.flags,
       Description: opt.description || ""
     };
     const defaultDesc = opt.defaultValueDescription ?? (opt.defaultValue !== undefined ? String(opt.defaultValue) : undefined);
     if (defaultDesc !== undefined) {
-      result.Default = defaultDesc;
+      result2.Default = defaultDesc;
     }
-    return result;
+    return result2;
   });
-  return {
+  const examples = getCommandExamples(cmd);
+  const result = {
     Command: cmd.name(),
     Description: description,
     Usage: usage,
     Arguments: args,
     Options: options
   };
+  if (examples.length > 0) {
+    result.Examples = examples;
+  }
+  return result;
 }
 function formatHelpAll(command, baseName = "") {
   const entries = [];
@@ -7824,7 +8704,7 @@ function formatHelpAll(command, baseName = "") {
     return { ...help, Command: e.fullName };
   });
   const output = {
-    Result: "Success",
+    Result: RESULTS.Success,
     Code: "HelpAll",
     Data: data
   };
@@ -7856,6 +8736,21 @@ function registerHelpAll(command) {
     throw new CommanderError(0, "commander.helpDisplayed", "(outputHelp)");
   });
 }
+// src/completer.ts
+var COMPLETER_SYMBOL = Symbol.for("@uipath/common/completer");
+function withCompleter(target, spec) {
+  target[COMPLETER_SYMBOL] = spec;
+  return target;
+}
+function getCompleter(target) {
+  if (!target)
+    return;
+  const raw = target[COMPLETER_SYMBOL];
+  if (raw && typeof raw === "object" && "command" in raw && "valueSelector" in raw) {
+    return raw;
+  }
+  return;
+}
 // src/console-guard.ts
 function format(first, ...rest) {
   if (typeof first !== "string") {
@@ -8013,12 +8908,20 @@ async function extractErrorDetails(error, options) {
   }
   const rawMessage = typeof err.message === "string" ? err.message : "Unknown error";
   let message;
+  let result = "Failure";
   if (status === 401) {
     message = DEFAULT_401;
+    result = "AuthenticationError";
   } else if (status === 403) {
     message = options?.forbiddenMessage ?? DEFAULT_403;
+    result = "AuthenticationError";
   } else if (status === 405) {
     message = DEFAULT_405;
+  } else if (status === 400 || status === 422) {
+    message = extractedMessage ? `HTTP ${status}: ${extractedMessage}` : `HTTP ${status}: ${rawMessage}`;
+    result = "ValidationError";
+  } else if (status === 429) {
+    message = extractedMessage ? `HTTP ${status}: ${extractedMessage}` : `HTTP ${status}: ${rawMessage}`;
   } else if (extractedMessage) {
     message = status ? `HTTP ${status}: ${extractedMessage}` : extractedMessage;
   } else if (status) {
@@ -8053,7 +8956,36 @@ async function extractErrorDetails(error, options) {
   } else {
     details = String(error);
   }
-  return { message, details };
+  const context = {};
+  if (status) {
+    context.httpStatus = status;
+  }
+  if (parsedBody?.errorCode && typeof parsedBody.errorCode === "string") {
+    context.errorCode = parsedBody.errorCode;
+  }
+  if (parsedBody?.requestId && typeof parsedBody.requestId === "string") {
+    context.requestId = parsedBody.requestId;
+  }
+  if (status === 429) {
+    const resp = response;
+    const headersObj = resp?.headers;
+    let retryAfterValue;
+    if (headersObj && typeof headersObj === "object" && typeof headersObj.get === "function") {
+      retryAfterValue = headersObj.get("retry-after") ?? undefined;
+    }
+    if (!retryAfterValue && headersObj && typeof headersObj === "object") {
+      const headers = headersObj;
+      retryAfterValue = headers["retry-after"] ?? headers["Retry-After"];
+    }
+    if (retryAfterValue) {
+      const seconds = Number(retryAfterValue);
+      if (!Number.isNaN(seconds)) {
+        context.retryAfter = seconds;
+      }
+    }
+  }
+  const hasContext = Object.keys(context).length > 0;
+  return { result, message, details, ...hasContext ? { context } : {} };
 }
 async function extractErrorMessage(error, options) {
   const { message } = await extractErrorDetails(error, options);
@@ -8073,6 +9005,49 @@ function extractErrorMessageSync(error) {
   }
   return String(error);
 }
+// src/error-instructions.ts
+function extractHttpStatus(err) {
+  if (!err || typeof err !== "object")
+    return;
+  const e = err;
+  return e.response?.status ?? e.status ?? e.statusCode;
+}
+var GENERIC = "Check authentication and parameters";
+function instructionsFor(ctx, err) {
+  switch (ctx) {
+    case "auth":
+      return "Re-authenticate with 'uip login' or verify your session hasn't expired";
+    case "identity":
+      return "Pass --tenant (and ensure your login includes an organization) or re-authenticate";
+    case "input-parse":
+      return "Ensure --inputs is valid JSON or pipe JSON via stdin";
+    case "input-validate":
+      return "Fix the flagged input fields to match the process's input schema";
+    case "flag-format":
+      return "Check the flag value format — see --help for the expected shape";
+    case "permissions":
+      return "Confirm your user has the required permissions in this folder/tenant, or re-authenticate with 'uip login' if your session has lapsed";
+    case "backend": {
+      const status = extractHttpStatus(err);
+      if (status === 401) {
+        return "Re-authenticate with 'uip login' — your session is invalid or expired";
+      }
+      if (status === 403) {
+        return "Confirm your user has access to the folder and the required permissions";
+      }
+      if (status === 404) {
+        return "Verify the resource exists in the current folder/tenant";
+      }
+      if (status === 400) {
+        return "Request was rejected — check flag values and inputs";
+      }
+      if (status !== undefined && status >= 500 && status < 600) {
+        return "Orchestrator returned a server error — retry; if it persists, check service status";
+      }
+      return GENERIC;
+    }
+  }
+}
 // ../../node_modules/jsonpath-plus/dist/index-node-esm.js
 import vm from "vm";
 
@@ -9158,8 +10133,8 @@ JSONPath.prototype._getPreferredOutput = function(ea) {
   const resultType = this.currResultType;
   switch (resultType) {
     case "all": {
-      const path = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);
-      ea.pointer = JSONPath.toPointer(path);
+      const path3 = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);
+      ea.pointer = JSONPath.toPointer(path3);
       ea.path = typeof ea.path === "string" ? ea.path : JSONPath.toPathString(ea.path);
       return ea;
     }
@@ -9182,11 +10157,11 @@ JSONPath.prototype._handleCallback = function(fullRetObj, callback, type2) {
     callback(preferredOutput, type2, fullRetObj);
   }
 };
-JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, callback, hasArrExpr, literalPriority) {
+JSONPath.prototype._trace = function(expr, val, path3, parent, parentPropName, callback, hasArrExpr, literalPriority) {
   let retObj;
   if (!expr.length) {
     retObj = {
-      path,
+      path: path3,
       value: val,
       parent,
       parentProperty: parentPropName,
@@ -9207,28 +10182,28 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
     }
   }
   if ((typeof loc !== "string" || literalPriority) && val && Object.hasOwn(val, loc)) {
-    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr));
+    addRet(this._trace(x, val[loc], push(path3, loc), val, loc, callback, hasArrExpr));
   } else if (loc === "*") {
     this._walk(val, (m) => {
-      addRet(this._trace(x, val[m], push(path, m), val, m, callback, true, true));
+      addRet(this._trace(x, val[m], push(path3, m), val, m, callback, true, true));
     });
   } else if (loc === "..") {
-    addRet(this._trace(x, val, path, parent, parentPropName, callback, hasArrExpr));
+    addRet(this._trace(x, val, path3, parent, parentPropName, callback, hasArrExpr));
     this._walk(val, (m) => {
       if (typeof val[m] === "object") {
-        addRet(this._trace(expr.slice(), val[m], push(path, m), val, m, callback, true));
+        addRet(this._trace(expr.slice(), val[m], push(path3, m), val, m, callback, true));
       }
     });
   } else if (loc === "^") {
     this._hasParentSelector = true;
     return {
-      path: path.slice(0, -1),
+      path: path3.slice(0, -1),
       expr: x,
       isParentSelector: true
     };
   } else if (loc === "~") {
     retObj = {
-      path: push(path, loc),
+      path: push(path3, loc),
       value: parentPropName,
       parent,
       parentProperty: null
@@ -9236,9 +10211,9 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
     this._handleCallback(retObj, callback, "property");
     return retObj;
   } else if (loc === "$") {
-    addRet(this._trace(x, val, path, null, null, callback, hasArrExpr));
+    addRet(this._trace(x, val, path3, null, null, callback, hasArrExpr));
   } else if (/^(-?\d*):(-?\d*):?(\d*)$/u.test(loc)) {
-    addRet(this._slice(loc, x, val, path, parent, parentPropName, callback));
+    addRet(this._slice(loc, x, val, path3, parent, parentPropName, callback));
   } else if (loc.indexOf("?(") === 0) {
     if (this.currEval === false) {
       throw new Error("Eval [?(expr)] prevented in JSONPath expression.");
@@ -9249,15 +10224,15 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
       this._walk(val, (m) => {
         const npath = [nested[2]];
         const nvalue = nested[1] ? val[m][nested[1]] : val[m];
-        const filterResults = this._trace(npath, nvalue, path, parent, parentPropName, callback, true);
+        const filterResults = this._trace(npath, nvalue, path3, parent, parentPropName, callback, true);
         if (filterResults.length > 0) {
-          addRet(this._trace(x, val[m], push(path, m), val, m, callback, true));
+          addRet(this._trace(x, val[m], push(path3, m), val, m, callback, true));
         }
       });
     } else {
       this._walk(val, (m) => {
-        if (this._eval(safeLoc, val[m], m, path, parent, parentPropName)) {
-          addRet(this._trace(x, val[m], push(path, m), val, m, callback, true));
+        if (this._eval(safeLoc, val[m], m, path3, parent, parentPropName)) {
+          addRet(this._trace(x, val[m], push(path3, m), val, m, callback, true));
         }
       });
     }
@@ -9265,7 +10240,7 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
     if (this.currEval === false) {
       throw new Error("Eval [(expr)] prevented in JSONPath expression.");
     }
-    addRet(this._trace(unshift(this._eval(loc, val, path.at(-1), path.slice(0, -1), parent, parentPropName), x), val, path, parent, parentPropName, callback, hasArrExpr));
+    addRet(this._trace(unshift(this._eval(loc, val, path3.at(-1), path3.slice(0, -1), parent, parentPropName), x), val, path3, parent, parentPropName, callback, hasArrExpr));
   } else if (loc[0] === "@") {
     let addType = false;
     const valueType = loc.slice(1, -2);
@@ -9309,7 +10284,7 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
         }
         break;
       case "other":
-        addType = this.currOtherTypeCallback(val, path, parent, parentPropName);
+        addType = this.currOtherTypeCallback(val, path3, parent, parentPropName);
         break;
       case "null":
         if (val === null) {
@@ -9321,7 +10296,7 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
     }
     if (addType) {
       retObj = {
-        path,
+        path: path3,
         value: val,
         parent,
         parentProperty: parentPropName
@@ -9331,14 +10306,14 @@ JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, ca
     }
   } else if (loc[0] === "`" && val && Object.hasOwn(val, loc.slice(1))) {
     const locProp = loc.slice(1);
-    addRet(this._trace(x, val[locProp], push(path, locProp), val, locProp, callback, hasArrExpr, true));
+    addRet(this._trace(x, val[locProp], push(path3, locProp), val, locProp, callback, hasArrExpr, true));
   } else if (loc.includes(",")) {
     const parts = loc.split(",");
     for (const part of parts) {
-      addRet(this._trace(unshift(part, x), val, path, parent, parentPropName, callback, true));
+      addRet(this._trace(unshift(part, x), val, path3, parent, parentPropName, callback, true));
     }
   } else if (!literalPriority && val && Object.hasOwn(val, loc)) {
-    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr, true));
+    addRet(this._trace(x, val[loc], push(path3, loc), val, loc, callback, hasArrExpr, true));
   }
   if (this._hasParentSelector) {
     for (let t = 0;t < ret.length; t++) {
@@ -9372,7 +10347,7 @@ JSONPath.prototype._walk = function(val, f) {
     });
   }
 };
-JSONPath.prototype._slice = function(loc, expr, val, path, parent, parentPropName, callback) {
+JSONPath.prototype._slice = function(loc, expr, val, path3, parent, parentPropName, callback) {
   if (!Array.isArray(val)) {
     return;
   }
@@ -9382,14 +10357,14 @@ JSONPath.prototype._slice = function(loc, expr, val, path, parent, parentPropNam
   end = end < 0 ? Math.max(0, end + len) : Math.min(len, end);
   const ret = [];
   for (let i2 = start;i2 < end; i2 += step) {
-    const tmp = this._trace(unshift(i2, expr), val, path, parent, parentPropName, callback, true);
+    const tmp = this._trace(unshift(i2, expr), val, path3, parent, parentPropName, callback, true);
     tmp.forEach((t) => {
       ret.push(t);
     });
   }
   return ret;
 };
-JSONPath.prototype._eval = function(code, _v, _vname, path, parent, parentPropName) {
+JSONPath.prototype._eval = function(code, _v, _vname, path3, parent, parentPropName) {
   this.currSandbox._$_parentProperty = parentPropName;
   this.currSandbox._$_parent = parent;
   this.currSandbox._$_property = _vname;
@@ -9397,7 +10372,7 @@ JSONPath.prototype._eval = function(code, _v, _vname, path, parent, parentPropNa
   this.currSandbox._$_v = _v;
   const containsPath = code.includes("@path");
   if (containsPath) {
-    this.currSandbox._$_path = JSONPath.toPathString(path.concat([_vname]));
+    this.currSandbox._$_path = JSONPath.toPathString(path3.concat([_vname]));
   }
   const scriptCacheKey = this.currEval + "Script:" + code;
   if (!JSONPath.cache[scriptCacheKey]) {
@@ -9496,6 +10471,26 @@ class JsonPathError extends Error {
     this.name = "JsonPathError";
   }
 }
+// src/option-validators.ts
+function parseLimit(raw, _previous) {
+  return parseBoundedInt(raw, "--limit", { min: 1, max: 1e4 });
+}
+function parseOffset(raw, _previous) {
+  return parseBoundedInt(raw, "--offset", { min: 0, max: 1e6 });
+}
+function parseBoundedInt(raw, optionName, bounds) {
+  if (raw.trim() === "") {
+    throw new InvalidArgumentError(`${optionName} requires a value (got empty).`);
+  }
+  if (!/^-?\d+$/.test(raw.trim())) {
+    throw new InvalidArgumentError(`${optionName} must be an integer, got '${raw}'.`);
+  }
+  const n = parseInt(raw, 10);
+  if (n < bounds.min || n > bounds.max) {
+    throw new InvalidArgumentError(`${optionName} must be between ${bounds.min} and ${bounds.max}, got ${n}.`);
+  }
+  return n;
+}
 // src/polling/abort-controller.ts
 var created = false;
 function createPollAbortController() {
@@ -9614,7 +10609,7 @@ function abortError(signal) {
   return err;
 }
 function interruptibleSleep(ms, signal) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     if (signal?.aborted) {
       reject(abortError(signal));
       return;
@@ -9627,7 +10622,7 @@ function interruptibleSleep(ms, signal) {
     };
     const timer = setTimeout(() => {
       cleanup();
-      resolve();
+      resolve2();
     }, ms);
     if (signal) {
       onAbort = () => {
@@ -9989,6 +10984,130 @@ async function ensurePackagerFactory(verb) {
   }
   await provider(verb);
 }
+// src/telemetry/pii-redactor.ts
+var REDACTED = "[REDACTED]";
+var MAX_VALUE_LENGTH = 200;
+var SENSITIVE_NAME_TOKENS = new Set([
+  "token",
+  "tokens",
+  "secret",
+  "secrets",
+  "password",
+  "passwords",
+  "pwd",
+  "credential",
+  "credentials",
+  "auth",
+  "authentication",
+  "authorization",
+  "authority",
+  "cert",
+  "certificate",
+  "certificates"
+]);
+var SENSITIVE_KEY_PREFIXES = new Set([
+  "api",
+  "access",
+  "client",
+  "private",
+  "public",
+  "signing",
+  "encryption",
+  "session",
+  "master",
+  "shared",
+  "root",
+  "ssh",
+  "rsa",
+  "aes",
+  "hmac",
+  "oauth"
+]);
+var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+var EMAIL_PATTERN = /\b[^\s@]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
+var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
+var USER_HOME_PATTERN = /([/\\])(Users|home)([/\\])([^/\\]+)/gi;
+var URL_PATTERN = /\bhttps?:\/\/[^\s,;]+/gi;
+var URL_TRAILING_PUNCT = /[.,;:!?)\]}>'"]+$/;
+function shortHash(input) {
+  let hash = 2166136261;
+  for (let i2 = 0;i2 < input.length; i2++) {
+    hash ^= input.charCodeAt(i2);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function redactUrl(raw) {
+  try {
+    const url = new URL(raw);
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return `url#${shortHash(raw)}`;
+  }
+}
+function redactValueDetectors(value) {
+  let out = value;
+  out = out.replace(JWT_PATTERN, () => REDACTED);
+  out = out.replace(URL_PATTERN, (match) => {
+    const trailing = match.match(URL_TRAILING_PUNCT)?.[0] ?? "";
+    const core2 = trailing ? match.slice(0, -trailing.length) : match;
+    return `${redactUrl(core2)}${trailing}`;
+  });
+  out = out.replace(USER_HOME_PATTERN, (_match, sep1, folder, sep2) => `${sep1}${folder}${sep2}<user>`);
+  out = out.replace(EMAIL_PATTERN, (match) => `email#${shortHash(match)}`);
+  out = out.replace(UUID_PATTERN, (match) => `uuid#${shortHash(match)}`);
+  out = out.replace(LONG_TOKEN_PATTERN, () => REDACTED);
+  if (out.length > MAX_VALUE_LENGTH) {
+    out = `${out.slice(0, MAX_VALUE_LENGTH)}…`;
+  }
+  return out;
+}
+function nameTokens(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).map((t) => t.toLowerCase()).filter(Boolean);
+}
+function isSensitiveName(name) {
+  const tokens = nameTokens(name);
+  for (let i2 = 0;i2 < tokens.length; i2++) {
+    const token = tokens[i2];
+    if (SENSITIVE_NAME_TOKENS.has(token)) {
+      return true;
+    }
+    if (token === "key" || token === "keys") {
+      const prev = tokens[i2 - 1];
+      if (prev && SENSITIVE_KEY_PREFIXES.has(prev)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function redactProperty(name, value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (isSensitiveName(name)) {
+    return REDACTED;
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return "[OBJECT]";
+  }
+  return redactValueDetectors(value);
+}
+function redactProperties(properties) {
+  const out = {};
+  for (const [name, value] of Object.entries(properties)) {
+    const redacted = redactProperty(name, value);
+    if (redacted !== undefined) {
+      out[name] = redacted;
+    }
+  }
+  return out;
+}
+
 // src/trackedAction.ts
 var pollSignalSlot = singleton("PollSignal");
 var processContext = {
@@ -10002,6 +11121,27 @@ var processContext = {
 function setProcessContextPollSignal(signal) {
   pollSignalSlot.set(signal);
 }
+function extractCommandParams(cmd) {
+  const params = {};
+  const registered = cmd.registeredArguments ?? [];
+  const processed = cmd.processedArgs ?? [];
+  for (let i2 = 0;i2 < registered.length; i2++) {
+    const value = processed[i2];
+    if (value === undefined) {
+      continue;
+    }
+    const name = registered[i2].name();
+    if (name) {
+      params[name] = value;
+    }
+  }
+  for (const [key, value] of Object.entries(cmd.opts())) {
+    if (value !== undefined) {
+      params[key] = value;
+    }
+  }
+  return params;
+}
 function deriveCommandPath(cmd) {
   const parts = [];
   let current = cmd;
@@ -10029,7 +11169,7 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       errorMessage = error instanceof Error ? error.message : String(error);
       logger.error(`[trackedAction] ${telemetryName} failed: ${errorMessage}`);
       OutputFormatter.error({
-        Result: "Failure",
+        Result: RESULTS.Failure,
         Message: errorMessage,
         Instructions: "An unexpected error occurred. Run with --log-level debug for details."
       });
@@ -10037,15 +11177,18 @@ Command.prototype.trackedAction = function(context, fn, properties) {
     }
     const durationMs = performance.now() - startTime;
     const success = !error && (process.exitCode === undefined || process.exitCode === 0);
-    telemetry.trackEvent(telemetryName, {
+    telemetry.trackEvent(telemetryName, redactProperties({
+      ...extractCommandParams(command),
       ...props,
       duration: String(durationMs),
       success: String(success),
       ...errorMessage ? { errorMessage } : {}
-    });
+    }));
   });
 };
 export {
+  withCompleter,
+  validateOutputFilter,
   telemetryInit,
   telemetryFlushAndShutdown,
   telemetry,
@@ -10064,18 +11207,24 @@ export {
   readRegistryValue,
   processContext,
   pollUntil,
+  parseOffset,
+  parseLimit,
+  parseBoundedInt,
   msToDuration,
   logger,
   isTerminalStatus,
   isTelemetryDisabled,
   isSuccessStatus,
   isFailureStatus,
+  instructionsFor,
   installConsoleGuard,
   getOutputSink,
   getOutputFormat,
   getOutputFilter,
   getLogFilePath,
   getGlobalLogFilePath,
+  getCompleter,
+  getCommandExamples,
   formatHelpAll,
   extractFormatFromArgs,
   extractErrorMessageSync,
@@ -10084,6 +11233,7 @@ export {
   extractCommandHelp,
   evaluateJsonPath,
   ensurePackagerFactory,
+  detectAgent,
   deriveCommandPath,
   createTelemetryProvider,
   createPollAbortController,
@@ -10092,17 +11242,22 @@ export {
   collectCommands,
   catchError,
   UIPATH_HOME_DIR,
+  TelemetryService,
   SuccessOutput,
   ScreenLogger,
+  RESULTS,
   PollOutcome,
   POLL_DEFAULTS,
   OutputFormatter,
+  NodeContextStorage,
   MIN_INTERVAL_MS,
   LogLevel,
   LOCAL_CONFIG_FILENAME,
   JsonPathError,
   FailureOutput,
   ErrorDecision,
+  EXIT_CODES,
+  DebugTelemetryProvider,
   DEFAULT_REDIRECT_URI,
   DEFAULT_PAGE_SIZE,
   DEFAULT_LOG_LEVEL,