@uipath/cli 1.195.1 → 1.196.1

package/dist/index.js

@@ -946,6 +946,32 @@ function settlePromiseLike(thenable) {
 }
 
 // ../common/src/error-handler.ts
+function describeConnectivityError(error) {
+  let current = error;
+  for (let depth = 0;depth < 5 && current !== null && typeof current === "object"; depth++) {
+    const cur = current;
+    const code = typeof cur.code === "string" ? cur.code : undefined;
+    const message = typeof cur.message === "string" ? cur.message : undefined;
+    if (code && TLS_ERROR_CODES.has(code)) {
+      return {
+        code,
+        kind: "tls",
+        message: message ?? code,
+        instructions: TLS_INSTRUCTIONS
+      };
+    }
+    if (code && NETWORK_ERROR_CODES.has(code)) {
+      return {
+        code,
+        kind: "network",
+        message: message ?? code,
+        instructions: NETWORK_INSTRUCTIONS
+      };
+    }
+    current = cur.cause;
+  }
+  return;
+}
 function extractErrorMessageSync(error) {
   if (error instanceof Error) {
     return error.message;
@@ -960,8 +986,32 @@ function extractErrorMessageSync(error) {
   }
   return String(error);
 }
-var DEFAULT_401 = "Unauthorized (401). Run `uip login` to authenticate.";
-var init_error_handler = () => {};
+var DEFAULT_401 = "Unauthorized (401). Run `uip login` to authenticate.", NETWORK_ERROR_CODES, TLS_ERROR_CODES, TLS_INSTRUCTIONS, NETWORK_INSTRUCTIONS;
+var init_error_handler = __esm(() => {
+  NETWORK_ERROR_CODES = new Set([
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "ETIMEDOUT",
+    "EPIPE",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "EAI_FAIL"
+  ]);
+  TLS_ERROR_CODES = new Set([
+    "SELF_SIGNED_CERT_IN_CHAIN",
+    "DEPTH_ZERO_SELF_SIGNED_CERT",
+    "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+    "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+    "UNABLE_TO_GET_ISSUER_CERT",
+    "CERT_HAS_EXPIRED",
+    "CERT_UNTRUSTED",
+    "ERR_TLS_CERT_ALTNAME_INVALID"
+  ]);
+  TLS_INSTRUCTIONS = "The server's TLS certificate could not be verified. Most often a " + "corporate proxy/firewall re-signs HTTPS with a root CA that Node does " + "not trust — set NODE_EXTRA_CA_CERTS to that CA's PEM file (and HTTPS_PROXY " + "if you connect through a proxy). If the certificate is instead expired or " + "its hostname does not match, fix the endpoint URL or the system clock. " + "Then retry.";
+  NETWORK_INSTRUCTIONS = "Could not reach the UiPath service. Check your network connection and " + "VPN, confirm any HTTP_PROXY/HTTPS_PROXY/NO_PROXY settings are correct, " + "then retry.";
+});
 
 // ../common/src/attachment-binding.ts
 var init_attachment_binding = __esm(() => {
@@ -3242,111 +3292,6 @@ var init_completer = __esm(() => {
   COMPLETER_SYMBOL = Symbol.for("@uipath/common/completer");
 });
 
-// ../common/src/console-guard.ts
-function format(first, ...rest) {
-  if (typeof first !== "string") {
-    if (first === undefined && rest.length === 0)
-      return "";
-    return [first, ...rest].map(String).join(" ");
-  }
-  let i = 0;
-  const result = first.replace(/%[sdifjoO%]/g, (spec) => {
-    if (spec === "%%")
-      return "%";
-    if (i >= rest.length)
-      return spec;
-    const arg = rest[i++];
-    switch (spec) {
-      case "%s":
-        return String(arg);
-      case "%d":
-      case "%i":
-        return String(parseInt(String(arg), 10));
-      case "%f":
-        return String(parseFloat(String(arg)));
-      case "%j":
-      case "%o":
-      case "%O":
-        try {
-          return JSON.stringify(arg);
-        } catch {
-          return String(arg);
-        }
-      default:
-        return spec;
-    }
-  });
-  const extra = rest.slice(i);
-  if (extra.length > 0) {
-    return result + " " + extra.map(String).join(" ");
-  }
-  return result;
-}
-function formatArgs(args) {
-  return `${format(args[0], ...args.slice(1))}
-`;
-}
-function installConsoleGuard() {
-  if (guardInstalledSlot.get(false))
-    return;
-  const originals = {
-    log: console.log,
-    info: console.info,
-    warn: console.warn,
-    error: console.error,
-    debug: console.debug
-  };
-  savedOriginalsSlot.set(originals);
-  let reentrant = false;
-  function guardedWriter(original) {
-    return (...args) => {
-      if (reentrant) {
-        original.apply(console, args);
-        return;
-      }
-      reentrant = true;
-      try {
-        getOutputSink().writeErr(formatArgs(args));
-      } finally {
-        reentrant = false;
-      }
-    };
-  }
-  console.log = guardedWriter(originals.log);
-  console.info = guardedWriter(originals.info);
-  console.warn = guardedWriter(originals.warn);
-  console.error = guardedWriter(originals.error);
-  console.debug = guardedWriter(originals.debug);
-  guardInstalledSlot.set(true);
-}
-var guardInstalledSlot, savedOriginalsSlot;
-var init_console_guard = __esm(() => {
-  init_output_context();
-  init_singleton();
-  guardInstalledSlot = singleton("ConsoleGuardInstalled");
-  savedOriginalsSlot = singleton("ConsoleGuardOriginals");
-});
-
-// ../common/src/constants.ts
-var UIPATH_HOME_DIR = ".uipath", CONFIG_FILENAME = "config.json", DEFAULT_AUTH_TIMEOUT_MS, DEFAULT_FETCH_TIMEOUT_MS = 30000;
-var init_constants = __esm(() => {
-  DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
-});
-
-// ../common/src/env-reference.ts
-function resolveEnvReference(value) {
-  if (value == null)
-    return value;
-  if (value.startsWith("env.")) {
-    const name = value.slice(4);
-    const resolved = process.env[name];
-    if (!resolved) {
-      throw new Error(`Environment variable "${name}" is not set`);
-    }
-    return resolved;
-  }
-  return value;
-}
 // ../../node_modules/@jmespath-community/jmespath/dist/index.mjs
 function compile(expression, options) {
   const nodeTree = Parser_default.parse(expression, options);
@@ -8244,8 +8189,8 @@ var init_logger = __esm(() => {
 });
 
 // ../common/src/output-format-context.ts
-function setOutputFormat(format2) {
-  formatSlot.set(format2);
+function setOutputFormat(format) {
+  formatSlot.set(format);
 }
 function getOutputFormat() {
   return formatSlot.get("json");
@@ -8400,6 +8345,20 @@ class NodeContextStorage {
 }
 var init_node_context_storage = () => {};
 
+// ../common/src/telemetry/global-telemetry-properties.ts
+function setGlobalTelemetryProperties(properties) {
+  const existing = getGlobalTelemetryProperties();
+  telemetryPropsSlot.set({ ...existing, ...properties });
+}
+function getGlobalTelemetryProperties() {
+  return telemetryPropsSlot.get();
+}
+var telemetryPropsSlot;
+var init_global_telemetry_properties = __esm(() => {
+  init_singleton();
+  telemetryPropsSlot = singleton("TelemetryDefaultProps");
+});
+
 // ../common/src/telemetry/telemetry-service.ts
 class TelemetryService {
   telemetryProvider;
@@ -8417,7 +8376,7 @@ class TelemetryService {
     this.telemetryProvider = provider;
   }
   setDefaultProperties(properties) {
-    this.defaultProperties = properties;
+    this.defaultProperties = properties === undefined ? undefined : { ...this.defaultProperties, ...properties };
   }
   trackEvent(name, properties) {
     const context = this.getCurrentContext();
@@ -8479,6 +8438,7 @@ class TelemetryService {
   }
   enrichPropertiesWithContext(properties, context) {
     return {
+      ...getGlobalTelemetryProperties(),
       ...this.defaultProperties,
       ...properties,
       ...context
@@ -8488,12 +8448,16 @@ class TelemetryService {
     return crypto.randomUUID().replaceAll("-", "");
   }
 }
+var init_telemetry_service = __esm(() => {
+  init_global_telemetry_properties();
+});
 
 // ../common/src/telemetry/node.ts
 var init_node2 = __esm(() => {
   init_debug_telemetry_provider();
   init_detect_agent();
   init_node_context_storage();
+  init_telemetry_service();
 });
 
 // ../../node_modules/applicationinsights/out/Library/FileSystemHelper.js
@@ -21735,12 +21699,12 @@ var require_common2 = __commonJS((exports, module) => {
           args.unshift("%O");
         }
         let index = 0;
-        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format2) => {
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
           if (match === "%%") {
             return "%";
           }
           index++;
-          const formatter = createDebug.formatters[format2];
+          const formatter = createDebug.formatters[format];
           if (typeof formatter === "function") {
             const val = args[index];
             match = formatter.call(self2, val);
@@ -21865,7 +21829,7 @@ var require_common2 = __commonJS((exports, module) => {
 
 // ../../node_modules/debug/src/browser.js
 var require_browser = __commonJS((exports, module) => {
-  exports.formatArgs = formatArgs2;
+  exports.formatArgs = formatArgs;
   exports.save = save;
   exports.load = load2;
   exports.useColors = useColors;
@@ -21967,7 +21931,7 @@ var require_browser = __commonJS((exports, module) => {
     let m;
     return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
   }
-  function formatArgs2(args) {
+  function formatArgs(args) {
     args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
     if (!this.useColors) {
       return;
@@ -22138,7 +22102,7 @@ var require_node5 = __commonJS((exports, module) => {
   var util = __require("util");
   exports.init = init;
   exports.log = log;
-  exports.formatArgs = formatArgs2;
+  exports.formatArgs = formatArgs;
   exports.save = save;
   exports.load = load2;
   exports.useColors = useColors;
@@ -22249,7 +22213,7 @@ var require_node5 = __commonJS((exports, module) => {
   function useColors() {
     return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
   }
-  function formatArgs2(args) {
+  function formatArgs(args) {
     const { namespace: name, useColors: useColors2 } = this;
     if (useColors2) {
       const c = this.color;
@@ -29024,9 +28988,9 @@ var require_stack_chain = __commonJS((exports, module) => {
       };
     }
     SHORTCIRCUIT_FORMATER = true;
-    var format2 = chain.format._formater(error, frames);
+    var format = chain.format._formater(error, frames);
     SHORTCIRCUIT_FORMATER = false;
-    return format2;
+    return format;
   }
   Object.defineProperty(Error, "prepareStackTrace", {
     get: function() {
@@ -37129,11 +37093,11 @@ var require_bytesEncoding = __commonJS((exports, module) => {
     uint8ArrayToString: () => uint8ArrayToString2
   });
   module.exports = __toCommonJS(bytesEncoding_exports);
-  function uint8ArrayToString2(bytes, format2) {
-    return Buffer.from(bytes).toString(format2);
+  function uint8ArrayToString2(bytes, format) {
+    return Buffer.from(bytes).toString(format);
   }
-  function stringToUint8Array2(value, format2) {
-    return Buffer.from(value, format2);
+  function stringToUint8Array2(value, format) {
+    return Buffer.from(value, format);
   }
 });
 
@@ -37570,11 +37534,11 @@ var require_commonjs4 = __commonJS((exports) => {
   exports.isNodeRuntime = tspRuntime.isNodeRuntime;
   exports.isReactNative = tspRuntime.isReactNative;
   exports.isWebWorker = tspRuntime.isWebWorker;
-  function uint8ArrayToString2(bytes, format2) {
-    return tspRuntime.uint8ArrayToString(bytes, format2);
+  function uint8ArrayToString2(bytes, format) {
+    return tspRuntime.uint8ArrayToString(bytes, format);
   }
-  function stringToUint8Array2(value, format2) {
-    return tspRuntime.stringToUint8Array(value, format2);
+  function stringToUint8Array2(value, format) {
+    return tspRuntime.stringToUint8Array(value, format);
   }
 });
 
@@ -43453,13 +43417,6 @@ var require_applicationinsights2 = __commonJS((exports) => {
 });
 
 // ../common/src/telemetry/node-appinsights-telemetry-provider.ts
-function setGlobalTelemetryProperties(properties) {
-  const existing = getGlobalTelemetryProperties();
-  telemetryPropsSlot.set({ ...existing, ...properties });
-}
-function getGlobalTelemetryProperties() {
-  return telemetryPropsSlot.get();
-}
 function toOperationUrn(name) {
   if (URL.canParse(name))
     return name;
@@ -43722,11 +43679,12 @@ async function getOrCreateProvider(connectionString) {
   providerSlot.set(initPromise);
   return initPromise;
 }
-var telemetryPropsSlot, providerSlot, APPINSIGHTS_BATCH_INTERVAL_MS = 1000;
+var providerSlot, APPINSIGHTS_BATCH_INTERVAL_MS = 1000;
 var init_node_appinsights_telemetry_provider = __esm(() => {
   init_logger();
   init_singleton();
-  telemetryPropsSlot = singleton("TelemetryDefaultProps");
+  init_global_telemetry_properties();
+  init_global_telemetry_properties();
   providerSlot = singleton("TelemetryProvider");
 });
 
@@ -43935,12 +43893,12 @@ function normalizeOutputKeys(data) {
   }
   return result;
 }
-function printOutput(data, format2 = "json", logFn, asciiSafe = false) {
+function printOutput(data, format = "json", logFn, asciiSafe = false) {
   if (!data) {
     logFn("Empty response object. No data to display.");
     return;
   }
-  switch (format2) {
+  switch (format) {
     case "json": {
       const json = JSON.stringify(data, null, 2);
       logFn(asciiSafe ? escapeNonAscii(json) : json);
@@ -43977,9 +43935,9 @@ function printOutput(data, format2 = "json", logFn, asciiSafe = false) {
     }
   }
 }
-function logOutput(data, format2 = "json") {
+function logOutput(data, format = "json") {
   const sink = getOutputSink();
-  printOutput(data, format2, (msg) => sink.writeOut(`${msg}
+  printOutput(data, format, (msg) => sink.writeOut(`${msg}
 `), needsAsciiSafeJson(sink));
 }
 function cellToString(val) {
@@ -44133,7 +44091,32 @@ function applyFilter(data, filter) {
     return result;
   return { Value: result };
 }
-var RESULTS, EXIT_CODES, FilterEvaluationError, OutputFormatter;
+function defaultErrorCodeForResult(result) {
+  switch (result) {
+    case RESULTS.AuthenticationError:
+      return "authentication_required";
+    case RESULTS.ConfigError:
+      return "configuration_error";
+    case RESULTS.ValidationError:
+      return "invalid_argument";
+    case RESULTS.TimeoutError:
+      return "timeout";
+    default:
+      return "unknown_error";
+  }
+}
+function defaultRetryForErrorCode(errorCode) {
+  switch (errorCode) {
+    case "network_error":
+    case "rate_limited":
+    case "server_error":
+    case "timeout":
+      return "RetryLater";
+    default:
+      return "RetryWillNotFix";
+  }
+}
+var CLI_ERROR_CODES, RETRY_HINTS, RESULTS, EXIT_CODES, FilterEvaluationError, OutputFormatter;
 var init_formatter = __esm(() => {
   init_dist();
   init_js_yaml();
@@ -44142,6 +44125,27 @@ var init_formatter = __esm(() => {
   init_output_format_context();
   init_telemetry_events();
   init_telemetry_init();
+  CLI_ERROR_CODES = [
+    "invalid_argument",
+    "authentication_required",
+    "permission_denied",
+    "not_found",
+    "rate_limited",
+    "network_error",
+    "timeout",
+    "server_error",
+    "method_not_allowed",
+    "configuration_error",
+    "unknown_error"
+  ];
+  RETRY_HINTS = [
+    "RetryWillNotFix",
+    "RetryLater",
+    "RetryAfter1Second",
+    "RetryAfter10Seconds",
+    "RetryAfter30Seconds",
+    "RetryAfter60Seconds"
+  ];
   RESULTS = {
     Success: "Success",
     Failure: "Failure",
@@ -44161,7 +44165,9 @@ var init_formatter = __esm(() => {
   FilterEvaluationError = class FilterEvaluationError extends Error {
     __brand = "FilterEvaluationError";
     filter;
+    errorCode = "invalid_argument";
     instructions;
+    retry = "RetryWillNotFix";
     result = RESULTS.ValidationError;
     constructor(filter, cause) {
       const underlying = cause instanceof Error ? cause.message : String(cause);
@@ -44188,9 +44194,13 @@ var init_formatter = __esm(() => {
     OutputFormatter.success = success;
     function error(data) {
       data.Log ??= getLogFilePath() || undefined;
+      data.ErrorCode ??= defaultErrorCodeForResult(data.Result);
+      data.Retry ??= defaultRetryForErrorCode(data.ErrorCode);
       process.exitCode = EXIT_CODES[data.Result] ?? 1;
       telemetry.trackEvent(CommonTelemetryEvents.Error, {
         result: data.Result,
+        errorCode: data.ErrorCode,
+        retry: data.Retry,
         message: data.Message
       });
       logOutput(normalizeOutputKeys(data), getOutputFormat());
@@ -44212,10 +44222,10 @@ var init_formatter = __esm(() => {
     }
     OutputFormatter.emitList = emitList;
     function log(data) {
-      const format2 = getOutputFormat();
+      const format = getOutputFormat();
       const sink = getOutputSink();
       const normalized = toPascalCaseData(data);
-      if (format2 === "json") {
+      if (format === "json") {
         const json = JSON.stringify(normalized);
         const safe = needsAsciiSafeJson(sink) ? escapeNonAscii(json) : json;
         sink.writeErr(`${safe}
@@ -44249,9 +44259,391 @@ var init_formatter = __esm(() => {
   })(OutputFormatter ||= {});
 });
 
+// ../common/src/telemetry/pii-redactor.ts
+function shortHash(input) {
+  let hash = 2166136261;
+  for (let i = 0;i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    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 core = trailing ? match.slice(0, -trailing.length) : match;
+    return `${redactUrl(core)}${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 i = 0;i < tokens.length; i++) {
+    const token = tokens[i];
+    if (SENSITIVE_NAME_TOKENS.has(token)) {
+      return true;
+    }
+    if (token === "key" || token === "keys") {
+      const prev = tokens[i - 1];
+      if (prev && SENSITIVE_KEY_PREFIXES.has(prev)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function redactProperty(name, value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (isSensitiveName(name)) {
+    return REDACTED;
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return "[OBJECT]";
+  }
+  return redactValueDetectors(value);
+}
+function redactProperties(properties) {
+  const out = {};
+  for (const [name, value] of Object.entries(properties)) {
+    const redacted = redactProperty(name, value);
+    if (redacted !== undefined) {
+      out[name] = redacted;
+    }
+  }
+  return out;
+}
+var REDACTED = "[REDACTED]", MAX_VALUE_LENGTH = 200, SENSITIVE_NAME_TOKENS, SENSITIVE_KEY_PREFIXES, UUID_PATTERN, EMAIL_PATTERN, JWT_PATTERN, LONG_TOKEN_PATTERN, USER_HOME_PATTERN, URL_PATTERN, URL_TRAILING_PUNCT;
+var init_pii_redactor = __esm(() => {
+  SENSITIVE_NAME_TOKENS = new Set([
+    "token",
+    "tokens",
+    "secret",
+    "secrets",
+    "password",
+    "passwords",
+    "pwd",
+    "credential",
+    "credentials",
+    "auth",
+    "authentication",
+    "authorization",
+    "authority",
+    "cert",
+    "certificate",
+    "certificates"
+  ]);
+  SENSITIVE_KEY_PREFIXES = new Set([
+    "api",
+    "access",
+    "client",
+    "private",
+    "public",
+    "signing",
+    "encryption",
+    "session",
+    "master",
+    "shared",
+    "root",
+    "ssh",
+    "rsa",
+    "aes",
+    "hmac",
+    "oauth"
+  ]);
+  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;
+  EMAIL_PATTERN = /\b[^\s@]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
+  JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+  LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
+  USER_HOME_PATTERN = /([/\\])(Users|home)([/\\])([^/\\]+)/gi;
+  URL_PATTERN = /\bhttps?:\/\/[^\s,;]+/gi;
+  URL_TRAILING_PUNCT = /[.,;:!?)\]}>'"]+$/;
+});
+
+// ../common/src/trackedAction.ts
+function setProcessContextPollSignal(signal) {
+  pollSignalSlot.set(signal);
+}
+function extractCommandParams(cmd) {
+  const params = {};
+  const registered = cmd.registeredArguments ?? [];
+  const processed = cmd.processedArgs ?? [];
+  for (let i = 0;i < registered.length; i++) {
+    const value = processed[i];
+    if (value === undefined) {
+      continue;
+    }
+    const name = registered[i].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;
+  while (current) {
+    const name = current.name();
+    if (name) {
+      parts.unshift(name);
+    }
+    current = current.parent;
+  }
+  if (parts.length > 1) {
+    parts.shift();
+  }
+  return ["uip", ...parts.filter((p) => p !== "uip")].join(".");
+}
+function isCliErrorCode(value) {
+  return typeof value === "string" && cliErrorCodeValues.has(value);
+}
+function isRetryHint(value) {
+  return typeof value === "string" && retryHintValues.has(value);
+}
+function isErrorContext(value) {
+  return value !== null && typeof value === "object";
+}
+function commandHelpHint(commandPath) {
+  const command = commandPath.replace(/\./g, " ");
+  return `An unexpected error occurred. Run '${command} --help' to verify command syntax, or run with --log-level debug for details.`;
+}
+var pollSignalSlot, cliErrorCodeValues, retryHintValues, processContext;
+var init_trackedAction = __esm(() => {
+  init_esm();
+  init_formatter();
+  init_logger();
+  init_singleton();
+  init_pii_redactor();
+  init_telemetry_init();
+  pollSignalSlot = singleton("PollSignal");
+  cliErrorCodeValues = new Set(CLI_ERROR_CODES);
+  retryHintValues = new Set(RETRY_HINTS);
+  processContext = {
+    exit: (code) => {
+      process.exitCode = code;
+    },
+    get pollSignal() {
+      return pollSignalSlot.get();
+    }
+  };
+  Command.prototype.trackedAction = function(context, fn, properties) {
+    const command = this;
+    return this.action(async (...args) => {
+      const telemetryName = deriveCommandPath(command);
+      const props = typeof properties === "function" ? properties(...args) : properties;
+      const startTime = performance.now();
+      let errorMessage;
+      const [error] = await catchError(fn(...args));
+      if (error) {
+        errorMessage = error instanceof Error ? error.message : String(error);
+        logger.debug(`[trackedAction] ${telemetryName} failed: ${errorMessage}`);
+        const typed = error;
+        const customInstructions = typeof typed.instructions === "string" ? typed.instructions : undefined;
+        const customResult = typeof typed.result === "string" && typed.result !== RESULTS.Success && Object.values(RESULTS).includes(typed.result) ? typed.result : undefined;
+        const finalResult = customResult ?? RESULTS.Failure;
+        const typedErrorCode = typed.errorCode ?? typed.ErrorCode;
+        const customErrorCode = isCliErrorCode(typedErrorCode) ? typedErrorCode : undefined;
+        const typedRetry = typed.retry ?? typed.Retry;
+        const customRetry = isRetryHint(typedRetry) ? typedRetry : undefined;
+        const typedContext = typed.context ?? typed.Context;
+        const customContext = isErrorContext(typedContext) ? typedContext : undefined;
+        OutputFormatter.error({
+          Result: finalResult,
+          ...customErrorCode ? { ErrorCode: customErrorCode } : {},
+          Message: errorMessage,
+          Instructions: customInstructions ?? commandHelpHint(telemetryName),
+          ...customRetry ? { Retry: customRetry } : {},
+          ...customContext ? { Context: customContext } : {}
+        });
+        context.exit(EXIT_CODES[finalResult]);
+      }
+      const durationMs = performance.now() - startTime;
+      const success = !error && (process.exitCode === undefined || process.exitCode === 0);
+      telemetry.trackEvent(telemetryName, redactProperties({
+        ...extractCommandParams(command),
+        ...props,
+        command: "true",
+        duration: String(durationMs),
+        success: String(success),
+        ...errorMessage ? { errorMessage } : {}
+      }));
+    });
+  };
+});
+
+// ../common/src/confirmation.ts
+var init_confirmation = __esm(() => {
+  init_formatter();
+  init_trackedAction();
+});
+
+// ../common/src/console-guard.ts
+function format(first, ...rest) {
+  if (typeof first !== "string") {
+    if (first === undefined && rest.length === 0)
+      return "";
+    return [first, ...rest].map(String).join(" ");
+  }
+  let i = 0;
+  const result = first.replace(/%[sdifjoO%]/g, (spec) => {
+    if (spec === "%%")
+      return "%";
+    if (i >= rest.length)
+      return spec;
+    const arg = rest[i++];
+    switch (spec) {
+      case "%s":
+        return String(arg);
+      case "%d":
+      case "%i":
+        return String(parseInt(String(arg), 10));
+      case "%f":
+        return String(parseFloat(String(arg)));
+      case "%j":
+      case "%o":
+      case "%O":
+        try {
+          return JSON.stringify(arg);
+        } catch {
+          return String(arg);
+        }
+      default:
+        return spec;
+    }
+  });
+  const extra = rest.slice(i);
+  if (extra.length > 0) {
+    return result + " " + extra.map(String).join(" ");
+  }
+  return result;
+}
+function formatArgs(args) {
+  return `${format(args[0], ...args.slice(1))}
+`;
+}
+function installConsoleGuard() {
+  if (guardInstalledSlot.get(false))
+    return;
+  const originals = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error,
+    debug: console.debug
+  };
+  savedOriginalsSlot.set(originals);
+  let reentrant = false;
+  function guardedWriter(original) {
+    return (...args) => {
+      if (reentrant) {
+        original.apply(console, args);
+        return;
+      }
+      reentrant = true;
+      try {
+        getOutputSink().writeErr(formatArgs(args));
+      } finally {
+        reentrant = false;
+      }
+    };
+  }
+  console.log = guardedWriter(originals.log);
+  console.info = guardedWriter(originals.info);
+  console.warn = guardedWriter(originals.warn);
+  console.error = guardedWriter(originals.error);
+  console.debug = guardedWriter(originals.debug);
+  guardInstalledSlot.set(true);
+}
+var guardInstalledSlot, savedOriginalsSlot;
+var init_console_guard = __esm(() => {
+  init_output_context();
+  init_singleton();
+  guardInstalledSlot = singleton("ConsoleGuardInstalled");
+  savedOriginalsSlot = singleton("ConsoleGuardOriginals");
+});
+
+// ../common/src/constants.ts
+var UIPATH_HOME_DIR = ".uipath", CONFIG_FILENAME = "config.json", DEFAULT_AUTH_TIMEOUT_MS, DEFAULT_FETCH_TIMEOUT_MS = 30000;
+var init_constants = __esm(() => {
+  DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
+});
+// ../common/src/env-reference.ts
+function resolveEnvReference(value) {
+  if (value == null)
+    return value;
+  if (value.startsWith("env.")) {
+    const name = value.slice(4);
+    const resolved = process.env[name];
+    if (!resolved) {
+      throw new Error(`Environment variable "${name}" is not set`);
+    }
+    return resolved;
+  }
+  return value;
+}
+
+// ../common/src/error-instructions.ts
+var init_error_instructions = __esm(() => {
+  init_error_handler();
+});
+
 // ../common/src/guid.ts
 var init_guid = () => {};
 
+// ../common/src/interactivity-context.ts
+function setInteractivityMode(mode) {
+  modeSlot.set(mode);
+}
+function getInteractivityMode() {
+  return modeSlot.get("never") ?? "never";
+}
+function canPrompt() {
+  const mode = getInteractivityMode();
+  if (mode === "always") {
+    return true;
+  }
+  if (mode === "never") {
+    return false;
+  }
+  return getOutputSink().capabilities.isInteractive;
+}
+var modeSlot;
+var init_interactivity_context = __esm(() => {
+  init_output_context();
+  init_singleton();
+  modeSlot = singleton("InteractivityMode");
+});
+
 // ../../node_modules/jsonpath-plus/dist/index-node-esm.js
 import vm from "vm";
 
@@ -45799,7 +46191,6 @@ var init_sdk_user_agent = __esm(() => {
   init_singleton();
   sdkUserAgentHostToken = singleton("SdkUserAgentHostToken");
 });
-
 // ../common/src/tool-provider.ts
 function setPackagerFactoryProvider(provider) {
   factorySlot.set(provider);
@@ -45810,223 +46201,6 @@ var init_tool_provider = __esm(() => {
   factorySlot = singleton("PackagerFactoryProvider");
 });
 
-// ../common/src/telemetry/pii-redactor.ts
-function shortHash(input) {
-  let hash = 2166136261;
-  for (let i = 0;i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    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 core = trailing ? match.slice(0, -trailing.length) : match;
-    return `${redactUrl(core)}${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 i = 0;i < tokens.length; i++) {
-    const token = tokens[i];
-    if (SENSITIVE_NAME_TOKENS.has(token)) {
-      return true;
-    }
-    if (token === "key" || token === "keys") {
-      const prev = tokens[i - 1];
-      if (prev && SENSITIVE_KEY_PREFIXES.has(prev)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function redactProperty(name, value) {
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (isSensitiveName(name)) {
-    return REDACTED;
-  }
-  if (typeof value === "boolean" || typeof value === "number") {
-    return value;
-  }
-  if (typeof value !== "string") {
-    return "[OBJECT]";
-  }
-  return redactValueDetectors(value);
-}
-function redactProperties(properties) {
-  const out = {};
-  for (const [name, value] of Object.entries(properties)) {
-    const redacted = redactProperty(name, value);
-    if (redacted !== undefined) {
-      out[name] = redacted;
-    }
-  }
-  return out;
-}
-var REDACTED = "[REDACTED]", MAX_VALUE_LENGTH = 200, SENSITIVE_NAME_TOKENS, SENSITIVE_KEY_PREFIXES, UUID_PATTERN, EMAIL_PATTERN, JWT_PATTERN, LONG_TOKEN_PATTERN, USER_HOME_PATTERN, URL_PATTERN, URL_TRAILING_PUNCT;
-var init_pii_redactor = __esm(() => {
-  SENSITIVE_NAME_TOKENS = new Set([
-    "token",
-    "tokens",
-    "secret",
-    "secrets",
-    "password",
-    "passwords",
-    "pwd",
-    "credential",
-    "credentials",
-    "auth",
-    "authentication",
-    "authorization",
-    "authority",
-    "cert",
-    "certificate",
-    "certificates"
-  ]);
-  SENSITIVE_KEY_PREFIXES = new Set([
-    "api",
-    "access",
-    "client",
-    "private",
-    "public",
-    "signing",
-    "encryption",
-    "session",
-    "master",
-    "shared",
-    "root",
-    "ssh",
-    "rsa",
-    "aes",
-    "hmac",
-    "oauth"
-  ]);
-  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;
-  EMAIL_PATTERN = /\b[^\s@]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
-  JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
-  LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
-  USER_HOME_PATTERN = /([/\\])(Users|home)([/\\])([^/\\]+)/gi;
-  URL_PATTERN = /\bhttps?:\/\/[^\s,;]+/gi;
-  URL_TRAILING_PUNCT = /[.,;:!?)\]}>'"]+$/;
-});
-
-// ../common/src/trackedAction.ts
-function setProcessContextPollSignal(signal) {
-  pollSignalSlot.set(signal);
-}
-function extractCommandParams(cmd) {
-  const params = {};
-  const registered = cmd.registeredArguments ?? [];
-  const processed = cmd.processedArgs ?? [];
-  for (let i = 0;i < registered.length; i++) {
-    const value = processed[i];
-    if (value === undefined) {
-      continue;
-    }
-    const name = registered[i].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;
-  while (current) {
-    const name = current.name();
-    if (name) {
-      parts.unshift(name);
-    }
-    current = current.parent;
-  }
-  if (parts.length > 1) {
-    parts.shift();
-  }
-  return ["uip", ...parts.filter((p) => p !== "uip")].join(".");
-}
-var pollSignalSlot, processContext;
-var init_trackedAction = __esm(() => {
-  init_esm();
-  init_formatter();
-  init_logger();
-  init_singleton();
-  init_pii_redactor();
-  init_telemetry_init();
-  pollSignalSlot = singleton("PollSignal");
-  processContext = {
-    exit: (code) => {
-      process.exitCode = code;
-    },
-    get pollSignal() {
-      return pollSignalSlot.get();
-    }
-  };
-  Command.prototype.trackedAction = function(context, fn, properties) {
-    const command = this;
-    return this.action(async (...args) => {
-      const telemetryName = deriveCommandPath(command);
-      const props = typeof properties === "function" ? properties(...args) : properties;
-      const startTime = performance.now();
-      let errorMessage;
-      const [error] = await catchError(fn(...args));
-      if (error) {
-        errorMessage = error instanceof Error ? error.message : String(error);
-        logger.debug(`[trackedAction] ${telemetryName} failed: ${errorMessage}`);
-        const typed = error;
-        const customInstructions = typeof typed.instructions === "string" ? typed.instructions : undefined;
-        const customResult = typeof typed.result === "string" && typed.result !== RESULTS.Success && Object.values(RESULTS).includes(typed.result) ? typed.result : undefined;
-        const finalResult = customResult ?? RESULTS.Failure;
-        OutputFormatter.error({
-          Result: finalResult,
-          Message: errorMessage,
-          Instructions: customInstructions ?? "An unexpected error occurred. Run with --log-level debug for details."
-        });
-        context.exit(EXIT_CODES[finalResult]);
-      }
-      const durationMs = performance.now() - startTime;
-      const success = !error && (process.exitCode === undefined || process.exitCode === 0);
-      telemetry.trackEvent(telemetryName, redactProperties({
-        ...extractCommandParams(command),
-        ...props,
-        duration: String(durationMs),
-        success: String(success),
-        ...errorMessage ? { errorMessage } : {}
-      }));
-    });
-  };
-});
-
 // ../common/src/index.ts
 var init_src2 = __esm(() => {
   init_console_guard();
@@ -46035,10 +46209,13 @@ var init_src2 = __esm(() => {
   init_command_examples();
   init_command_help();
   init_completer();
+  init_confirmation();
   init_constants();
   init_error_handler();
+  init_error_instructions();
   init_formatter();
   init_guid();
+  init_interactivity_context();
   init_jsonpath();
   init_logger();
   init_option_aliases();
@@ -46063,7 +46240,7 @@ var init_package = __esm(() => {
   package_default = {
     name: "@uipath/cli",
     license: "MIT",
-    version: "1.195.1",
+    version: "1.196.1",
     description: "Cross platform CLI for UiPath",
     repository: {
       type: "git",
@@ -46112,7 +46289,7 @@ var init_package = __esm(() => {
       "@uipath/filesystem": "workspace:*",
       applicationinsights: "^2.9.8",
       commander: "^14.0.3",
-      esbuild: "^0.27.3",
+      esbuild: "^0.28.1",
       "js-yaml": "^4.1.0",
       ora: "^9.3.0",
       "path-browserify": "^1.0.1",
@@ -46177,115 +46354,156 @@ var init_storage = __esm(() => {
 });
 
 // src/utils/globalOptions.ts
-function stripGlobalOptions(args) {
-  const cleaned = [];
-  let format2;
-  let formatWasExplicit = false;
-  let sawJsonAlias = false;
-  let sawOutputOption = false;
-  let outputConflict = false;
-  let filter;
-  let logLevel;
-  let logFile;
-  for (let i = 0;i < args.length; i++) {
-    if (args[i] === "--output-filter" && i + 1 < args.length) {
-      filter = args[i + 1];
-      i++;
-      continue;
-    }
-    if (args[i]?.startsWith("--output-filter=")) {
-      filter = args[i].substring("--output-filter=".length);
-      continue;
-    }
-    if (args[i] === "--json") {
-      sawJsonAlias = true;
-      format2 = "json";
-      formatWasExplicit = true;
-      if (sawOutputOption) {
-        outputConflict = true;
-      }
-      continue;
+function tryParseOutputFilter(state, args, i) {
+  if (args[i] === "--output-filter" && i + 1 < args.length) {
+    state.filter = args[i + 1];
+    return { consumed: true, advance: 1 };
+  }
+  if (args[i]?.startsWith("--output-filter=")) {
+    state.filter = args[i].substring("--output-filter=".length);
+    return { consumed: true, advance: 0 };
+  }
+  return NOT_CONSUMED;
+}
+function tryParseJson(state, args, i) {
+  if (args[i] !== "--json") {
+    return NOT_CONSUMED;
+  }
+  state.sawJsonAlias = true;
+  state.format = "json";
+  state.formatWasExplicit = true;
+  if (state.sawOutputOption) {
+    state.outputConflict = true;
+  }
+  return { consumed: true, advance: 0 };
+}
+function applyOutputValue(state, value) {
+  if (!state.sawJsonAlias) {
+    state.format = value;
+  }
+  state.formatWasExplicit = true;
+}
+function tryParseOutputSpace(state, args, i) {
+  if (args[i] !== "--output") {
+    return NOT_CONSUMED;
+  }
+  state.sawOutputOption = true;
+  if (state.sawJsonAlias) {
+    state.outputConflict = true;
+  }
+  if (i + 1 < args.length) {
+    const v = args[i + 1];
+    if (VALID_FORMATS.includes(v)) {
+      applyOutputValue(state, v);
+      return { consumed: true, advance: 1 };
     }
-    if (args[i] === "--output") {
-      sawOutputOption = true;
-      if (sawJsonAlias) {
-        outputConflict = true;
-      }
-      if (i + 1 < args.length) {
-        const v = args[i + 1];
-        if (VALID_FORMATS.includes(v)) {
-          if (!sawJsonAlias) {
-            format2 = v;
-          }
-          formatWasExplicit = true;
-          i++;
-          continue;
-        }
-        if (sawJsonAlias) {
-          i++;
-          continue;
-        }
-      }
-      if (sawJsonAlias) {
-        continue;
-      }
+    if (state.sawJsonAlias) {
+      return { consumed: true, advance: 1 };
     }
-    if (args[i]?.startsWith("--output=")) {
-      sawOutputOption = true;
-      if (sawJsonAlias) {
-        outputConflict = true;
-      }
-      const v = args[i].substring("--output=".length);
-      if (VALID_FORMATS.includes(v)) {
-        if (!sawJsonAlias) {
-          format2 = v;
-        }
-        formatWasExplicit = true;
-        continue;
-      }
-      if (sawJsonAlias) {
-        continue;
-      }
+  }
+  if (state.sawJsonAlias) {
+    return { consumed: true, advance: 0 };
+  }
+  return NOT_CONSUMED;
+}
+function tryParseOutputEquals(state, args, i) {
+  if (!args[i]?.startsWith("--output=")) {
+    return NOT_CONSUMED;
+  }
+  state.sawOutputOption = true;
+  if (state.sawJsonAlias) {
+    state.outputConflict = true;
+  }
+  const v = args[i].substring("--output=".length);
+  if (VALID_FORMATS.includes(v)) {
+    applyOutputValue(state, v);
+    return { consumed: true, advance: 0 };
+  }
+  if (state.sawJsonAlias) {
+    return { consumed: true, advance: 0 };
+  }
+  return NOT_CONSUMED;
+}
+function tryParseLogLevel(state, args, i) {
+  if (args[i] === "--log-level" && i + 1 < args.length) {
+    const parsed = VALID_LOG_LEVELS[args[i + 1].toLowerCase()];
+    if (parsed !== undefined) {
+      state.logLevel = parsed;
     }
-    if (args[i] === "--log-level" && i + 1 < args.length) {
-      const parsed = VALID_LOG_LEVELS[args[i + 1].toLowerCase()];
-      if (parsed !== undefined) {
-        logLevel = parsed;
-      }
-      i++;
-      continue;
+    return { consumed: true, advance: 1 };
+  }
+  if (args[i]?.startsWith("--log-level=")) {
+    const parsed = VALID_LOG_LEVELS[args[i].substring("--log-level=".length).toLowerCase()];
+    if (parsed !== undefined) {
+      state.logLevel = parsed;
     }
-    if (args[i]?.startsWith("--log-level=")) {
-      const parsed = VALID_LOG_LEVELS[args[i].substring("--log-level=".length).toLowerCase()];
-      if (parsed !== undefined) {
-        logLevel = parsed;
+    return { consumed: true, advance: 0 };
+  }
+  return NOT_CONSUMED;
+}
+function tryParseLogFile(state, args, i) {
+  if (args[i] === "--log-file" && i + 1 < args.length) {
+    state.logFile = args[i + 1];
+    return { consumed: true, advance: 1 };
+  }
+  if (args[i]?.startsWith("--log-file=")) {
+    state.logFile = args[i].substring("--log-file=".length);
+    return { consumed: true, advance: 0 };
+  }
+  return NOT_CONSUMED;
+}
+function tryParseInteractive(state, args, i) {
+  if (args[i] === "--interactive") {
+    state.interactive = "always";
+    return { consumed: true, advance: 0 };
+  }
+  if (args[i] === "--no-interactive") {
+    state.interactive = "never";
+    return { consumed: true, advance: 0 };
+  }
+  return NOT_CONSUMED;
+}
+function stripGlobalOptions(args) {
+  const state = {
+    cleaned: [],
+    format: undefined,
+    formatWasExplicit: false,
+    sawJsonAlias: false,
+    sawOutputOption: false,
+    outputConflict: false,
+    filter: undefined,
+    logLevel: undefined,
+    logFile: undefined,
+    interactive: undefined
+  };
+  for (let i = 0;i < args.length; i++) {
+    let matched = false;
+    for (const matcher of MATCHERS) {
+      const result = matcher(state, args, i);
+      if (result.consumed) {
+        i += result.advance;
+        matched = true;
+        break;
       }
-      continue;
     }
-    if (args[i] === "--log-file" && i + 1 < args.length) {
-      logFile = args[i + 1];
-      i++;
-      continue;
-    }
-    if (args[i]?.startsWith("--log-file=")) {
-      logFile = args[i].substring("--log-file=".length);
-      continue;
+    if (!matched) {
+      state.cleaned.push(args[i]);
     }
-    cleaned.push(args[i]);
   }
   const envDefault = process.env?.UIP_DEFAULT_OUTPUT;
-  const resolvedFormat = format2 ?? (envDefault && VALID_FORMATS.includes(envDefault) ? envDefault : "json");
+  const resolvedFormat = state.format ?? (envDefault && VALID_FORMATS.includes(envDefault) ? envDefault : "json");
   return {
-    args: cleaned,
+    args: state.cleaned,
     format: resolvedFormat,
-    formatWasExplicit,
-    outputConflict,
-    filter,
-    logLevel,
-    logFile
+    formatWasExplicit: state.formatWasExplicit,
+    outputConflict: state.outputConflict,
+    filter: state.filter,
+    logLevel: state.logLevel,
+    logFile: state.logFile,
+    interactive: state.interactive
   };
 }
-var VALID_FORMATS, VALID_LOG_LEVELS;
+var VALID_FORMATS, VALID_LOG_LEVELS, NOT_CONSUMED, MATCHERS;
 var init_globalOptions = __esm(() => {
   VALID_FORMATS = ["table", "json", "yaml", "plain"];
   VALID_LOG_LEVELS = {
@@ -46294,6 +46512,16 @@ var init_globalOptions = __esm(() => {
     warn: 2,
     error: 3
   };
+  NOT_CONSUMED = { consumed: false, advance: 0 };
+  MATCHERS = [
+    tryParseOutputFilter,
+    tryParseJson,
+    tryParseOutputSpace,
+    tryParseOutputEquals,
+    tryParseLogLevel,
+    tryParseLogFile,
+    tryParseInteractive
+  ];
 });
 
 // src/utils/helpFormatter.ts
@@ -46620,6 +46848,12 @@ function buildTableHelpSections(cmd, helper) {
       Lines: buildExampleLines(baseHelp.Examples, contentWidth)
     });
   }
+  if (isRootCommand(cmd)) {
+    sections.push({
+      Title: "Getting started",
+      Lines: renderRows(GETTING_STARTED_ROWS, contentWidth)
+    });
+  }
   return sections;
 }
 function renderTableHelp(cmd, helper) {
@@ -46647,15 +46881,25 @@ function createHelpConfiguration(isBrowser2) {
         return renderTableHelp(cmd, helper);
       }
       const baseHelp = extractCommandHelp(cmd, helper);
-      const subcommands = helper.visibleCommands(cmd).map((sub2) => ({
-        Name: helper.subcommandTerm(sub2),
-        Description: helper.subcommandDescription(sub2)
-      }));
+      const subcommands = helper.visibleCommands(cmd).map((sub2) => {
+        const entry = {
+          Name: sub2.name(),
+          Description: helper.subcommandDescription(sub2)
+        };
+        const aliases = sub2.aliases();
+        if (aliases.length > 0) {
+          entry.Aliases = aliases;
+        }
+        return entry;
+      });
       const helpData = {
         ...baseHelp,
         Subcommands: subcommands,
         GlobalOptions: GLOBAL_OPTIONS
       };
+      if (isRootCommand(cmd)) {
+        helpData.GettingStarted = GETTING_STARTED_ROWS;
+      }
       const output = {
         Result: RESULTS.Success,
         Code: "Help",
@@ -46677,7 +46921,7 @@ function createHelpConfiguration(isBrowser2) {
   }
   return config;
 }
-var GLOBAL_OPTIONS, BUILT_IN_ROOT_COMMANDS;
+var GLOBAL_OPTIONS, BUILT_IN_ROOT_COMMANDS, GETTING_STARTED_ROWS;
 var init_helpFormatter = __esm(() => {
   init_src2();
   GLOBAL_OPTIONS = [
@@ -46708,16 +46952,49 @@ var init_helpFormatter = __esm(() => {
     "feedback",
     "help"
   ];
+  GETTING_STARTED_ROWS = [
+    {
+      Label: "uip login",
+      Description: "Authenticate against the UiPath Platform"
+    },
+    {
+      Label: "uip <command> --help",
+      Description: "Show help for any command"
+    },
+    {
+      Label: "uip skills install",
+      Description: "Install AI-agent skills for this CLI"
+    }
+  ];
 });
 
 // src/utils/parseError.ts
+function helpInstructions(cleanedArgs) {
+  const commandParts = [];
+  const userArgs = cleanedArgs.slice(2);
+  for (let i = 0;i < userArgs.length; i++) {
+    const arg = userArgs[i];
+    if (arg === "--") {
+      break;
+    }
+    if (arg.startsWith("-")) {
+      if (!arg.includes("=") && i + 1 < userArgs.length && !userArgs[i + 1].startsWith("-")) {
+        i++;
+      }
+      continue;
+    }
+    commandParts.push(arg);
+  }
+  const command = ["uip", ...commandParts].join(" ");
+  return `Run '${command} --help' for usage information.`;
+}
 function instructionsForUnknownCommand(cleanedArgs) {
   const firstUserToken = cleanedArgs.slice(2).find((a) => !a.startsWith("-"));
   const flagHint = firstUserToken && FLAG_HINTS[firstUserToken];
   if (flagHint) {
     return `Did you mean \`${flagHint}\`? Use --help for usage information.`;
   }
-  return GENERIC_INSTRUCTIONS;
+  return "Run 'uip --help' to list available commands.";
 }
 async function handleParseError(error, cleanedArgs, context) {
   const isObj = error !== null && typeof error === "object";
@@ -46734,11 +47011,13 @@ async function handleParseError(error, cleanedArgs, context) {
       context.exit(exitCode ?? 0);
       return;
     }
-    const instructions = code === "commander.unknownCommand" ? instructionsForUnknownCommand(cleanedArgs) : GENERIC_INSTRUCTIONS;
+    const instructions = code === "commander.unknownCommand" ? instructionsForUnknownCommand(cleanedArgs) : helpInstructions(cleanedArgs);
     OutputFormatter.error({
       Result: RESULTS.ValidationError,
+      ErrorCode: "invalid_argument",
       Message: message,
-      Instructions: instructions
+      Instructions: instructions,
+      Retry: "RetryWillNotFix"
     });
     await telemetryFlushAndShutdown();
     context.exit(process.exitCode ? Number(process.exitCode) : 1);
@@ -46747,7 +47026,7 @@ async function handleParseError(error, cleanedArgs, context) {
   await telemetryFlushAndShutdown();
   context.exit(process.exitCode ? Number(process.exitCode) : 1);
 }
-var FLAG_HINTS, GENERIC_INSTRUCTIONS = "Check command arguments and options. Use --help for usage information.";
+var FLAG_HINTS;
 var init_parseError = __esm(() => {
   init_src2();
   FLAG_HINTS = {
@@ -46813,7 +47092,8 @@ async function initProgram(context, hooks2 = {}) {
     outputConflict,
     filter,
     logLevel,
-    logFile
+    logFile,
+    interactive
   } = globalOptions;
   context.args = cleanedArgs;
   const overrides = hooks2.beforeLoggerConfigure ? await hooks2.beforeLoggerConfigure({
@@ -46822,6 +47102,7 @@ async function initProgram(context, hooks2 = {}) {
   }) : {};
   const effectiveFormat = formatWasExplicit ? helpFormat : overrides.outputFormat ?? helpFormat;
   const effectiveLogLevel = logLevel !== undefined ? logLevel : overrides.level;
+  setInteractivityMode(interactive ?? overrides.interactivityMode ?? "never");
   setOutputFormat(!formatWasExplicit && cleanedArgs.some((arg) => HELP_FLAGS.has(arg)) ? "table" : effectiveFormat);
   setOutputFormatExplicit(formatWasExplicit);
   configureLogger({
@@ -50969,6 +51250,7 @@ var init_tools_whitelist = __esm(() => {
     ["@uipath/solution-tool", "solution"],
     ["@uipath/agent-tool", "agent"],
     ["@uipath/agenthub-tool", "agenthub"],
+    ["@uipath/conversational-tool", "conversational"],
     ["@uipath/codedagent-tool", "codedagent"],
     ["@uipath/context-grounding-tool", "context-grounding"],
     ["@uipath/functions-tool", "functions"],
@@ -50977,7 +51259,6 @@ var init_tools_whitelist = __esm(() => {
     ["@uipath/orchestrator-tool", "or"],
     ["@uipath/rpa-tool", "rpa"],
     ["@uipath/test-manager-tool", "tm"],
-    ["@uipath/resource-tool", "resource"],
     ["@uipath/api-workflow-tool", "api-workflow"],
     ["@uipath/maestro-tool", "maestro"],
     ["@uipath/docsai-tool", "docsai"],
@@ -50991,6 +51272,7 @@ var init_tools_whitelist = __esm(() => {
     ["@uipath/tasks-tool", "tasks"],
     ["@uipath/aops-tool", "aops"],
     ["@uipath/llmgw-tool", "llm-configuration"],
+    ["@uipath/model-hub-tool", "model-hub"],
     ["@uipath/platform-tool", "platform"]
   ]);
   COMMAND_ALIASES = new Map([
@@ -51020,167 +51302,6 @@ var init_tools_whitelist = __esm(() => {
   ]));
 });
 
-// src/utils/npmrc.ts
-var exports_npmrc = {};
-__export(exports_npmrc, {
-  findNpmrcConfig: () => findNpmrcConfig
-});
-function expandEnvVars(raw) {
-  let hasMissing = false;
-  const expanded = raw.replace(/\$\{([^}]+)\}/g, (_, v) => {
-    const val = process.env[v];
-    if (val === undefined) {
-      hasMissing = true;
-      logger.warn(`Warning: .npmrc references \${${v}} but it is not set.`);
-      return "";
-    }
-    return val;
-  });
-  return hasMissing ? undefined : expanded;
-}
-function parseNpmrc(content) {
-  const result = { tokensByHost: new Map };
-  for (const line of content.split(`
-`)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith(";") || trimmed.startsWith("#"))
-      continue;
-    const tokenMatch = trimmed.match(/^\/\/([^/]+)\/:_authToken=(.+)$/);
-    if (tokenMatch) {
-      const host = tokenMatch[1];
-      const raw = tokenMatch[2].trim();
-      const expanded = expandEnvVars(raw);
-      if (expanded) {
-        result.tokensByHost.set(host, expanded);
-      }
-    }
-    const prefixMatch = trimmed.match(/^prefix=(.+)$/);
-    if (prefixMatch)
-      result.prefix = prefixMatch[1].trim();
-    const scopedMatch = trimmed.match(/^@uipath:registry=(.+)$/);
-    if (scopedMatch)
-      result.scopedRegistry = scopedMatch[1].trim();
-  }
-  return result;
-}
-function registryHost(url) {
-  const [error, parsed] = catchError(() => new URL(url));
-  if (error)
-    return;
-  return parsed.host;
-}
-function getNpmGlobalPrefix() {
-  const fromEnv = process.env.PREFIX ?? process.env.npm_config_prefix ?? process.env.NPM_CONFIG_PREFIX;
-  if (fromEnv)
-    return fromEnv;
-  const fs7 = getFileSystem();
-  const execPath = process.execPath;
-  if (process.platform === "win32")
-    return fs7.path.dirname(execPath);
-  return fs7.path.dirname(fs7.path.dirname(execPath));
-}
-function getBuiltinNpmrcPath(prefix) {
-  const fs7 = getFileSystem();
-  if (process.platform === "win32") {
-    return fs7.path.join(prefix, "node_modules", "npm", "npmrc");
-  }
-  return fs7.path.join(prefix, "lib", "node_modules", "npm", "npmrc");
-}
-function readEnvSource() {
-  const result = { tokensByHost: new Map };
-  for (const [key, value] of Object.entries(process.env)) {
-    if (value === undefined)
-      continue;
-    const match = key.match(/^npm_config_(.+)$/i);
-    if (!match)
-      continue;
-    const configKey = match[1];
-    const lower2 = configKey.toLowerCase();
-    if (lower2 === "@uipath:registry") {
-      result.scopedRegistry = value;
-      continue;
-    }
-    if (lower2 === "prefix") {
-      result.prefix = value;
-      continue;
-    }
-    const tokenMatch = configKey.match(/^\/\/([^/]+)\/:_authToken$/);
-    if (tokenMatch) {
-      result.tokensByHost.set(tokenMatch[1], value);
-    }
-  }
-  return result;
-}
-async function readNpmrcFile(path6, seen) {
-  if (seen.has(path6))
-    return null;
-  seen.add(path6);
-  const fs7 = getFileSystem();
-  const [readError, content] = await catchError(fs7.readFile(path6, "utf-8"));
-  if (readError || !content)
-    return null;
-  logger.debug(`Found .npmrc at ${path6}`);
-  return parseNpmrc(content);
-}
-async function findNpmrcConfig() {
-  const fs7 = getFileSystem();
-  const sources = [];
-  const seen = new Set;
-  sources.push(readEnvSource());
-  let dir = fs7.env.cwd();
-  for (let i = 0;i < 20; i++) {
-    const parsed = await readNpmrcFile(fs7.path.join(dir, ".npmrc"), seen);
-    if (parsed)
-      sources.push(parsed);
-    const parent = fs7.path.dirname(dir);
-    if (parent === dir)
-      break;
-    dir = parent;
-  }
-  const userConfigPath = process.env.NPM_CONFIG_USERCONFIG ?? process.env.npm_config_userconfig ?? fs7.path.join(fs7.env.homedir(), ".npmrc");
-  const userParsed = await readNpmrcFile(userConfigPath, seen);
-  if (userParsed)
-    sources.push(userParsed);
-  const prefix = getNpmGlobalPrefix();
-  const globalConfigPath = process.env.NPM_CONFIG_GLOBALCONFIG ?? process.env.npm_config_globalconfig ?? fs7.path.join(prefix, "etc", "npmrc");
-  const globalParsed = await readNpmrcFile(globalConfigPath, seen);
-  if (globalParsed)
-    sources.push(globalParsed);
-  const builtinParsed = await readNpmrcFile(getBuiltinNpmrcPath(prefix), seen);
-  if (builtinParsed)
-    sources.push(builtinParsed);
-  logger.debug(`Resolved npm config from ${sources.length} source(s) (env + ${seen.size} npmrc path(s) probed)`);
-  let scopedRegistry;
-  let prefixValue;
-  const tokensByHost = new Map;
-  for (const src of sources) {
-    if (src.scopedRegistry && !scopedRegistry) {
-      scopedRegistry = src.scopedRegistry;
-      logger.debug(`@uipath:registry = ${scopedRegistry}`);
-    }
-    if (src.prefix && !prefixValue)
-      prefixValue = src.prefix;
-    for (const [host, token] of src.tokensByHost) {
-      if (!tokensByHost.has(host)) {
-        tokensByHost.set(host, token);
-        logger.debug(`Auth token found for host '${host}'`);
-      }
-    }
-  }
-  let authToken;
-  if (scopedRegistry) {
-    const host = registryHost(scopedRegistry);
-    if (host) {
-      authToken = tokensByHost.get(host);
-    }
-  }
-  return { scopedRegistry, authToken, prefix: prefixValue };
-}
-var init_npmrc = __esm(() => {
-  init_src2();
-  init_src();
-});
-
 // src/services/toolService.ts
 function isValidSemver(v) {
   return SEMVER_RE.test(v);
@@ -51233,6 +51354,26 @@ function compareSemver(a, b) {
   }
   return 0;
 }
+function loadChildProcess() {
+  childProcessModulePromise ??= import("node:child_process");
+  return childProcessModulePromise;
+}
+async function isBunOnPath() {
+  if (cachedBunOnPath !== undefined)
+    return cachedBunOnPath;
+  const [error, result] = await catchError((async () => {
+    const { spawn } = await loadChildProcess();
+    const isWindows = process.platform === "win32";
+    const cmd = isWindows ? "where" : "which";
+    return await new Promise((resolve2) => {
+      const proc = spawn(cmd, ["bun"], { stdio: "ignore" });
+      proc.on("error", () => resolve2(false));
+      proc.on("close", (code) => resolve2(code === 0));
+    });
+  })());
+  cachedBunOnPath = !error && result === true;
+  return cachedBunOnPath;
+}
 function validatePackageSpec(spec) {
   if (!SAFE_PACKAGE_SPEC.test(spec)) {
     throw new Error(`Invalid package specifier: '${spec}'. Only alphanumeric characters, dots, hyphens, underscores, slashes, and @ are allowed.`);
@@ -51256,11 +51397,9 @@ function parsePackageSpec(spec) {
     version: spec.slice(versionSeparator + 1) || undefined
   };
 }
-function parsePrefixCeiling(prefix) {
-  const match = prefix.match(/^(\d+)\.(\d+)\.$/);
-  if (!match)
-    return null;
-  return `${match[1]}.${match[2]}.0`;
+function scopeRegistryEnv(packageName, registry2) {
+  const scope = packageName.split("/")[0];
+  return { [`npm_config_${scope}:registry`]: registry2 };
 }
 function pickForChannel(versions, channel) {
   if (channel === "stable") {
@@ -51269,6 +51408,20 @@ function pickForChannel(versions, channel) {
   const tag = `-${channel}.`;
   return versions.find((v) => v.includes(tag)) ?? null;
 }
+function channelFallbacks(channel) {
+  if (channel === "beta") {
+    return ["beta", "alpha", "stable"];
+  }
+  return [channel];
+}
+function pickForChannelWithFallback(versions, channel) {
+  for (const candidate of channelFallbacks(channel)) {
+    const picked = pickForChannel(versions, candidate);
+    if (picked)
+      return picked;
+  }
+  return null;
+}
 async function isDevMode() {
   const [error, result] = await catchError((async () => {
     const fs7 = getFileSystem();
@@ -51308,7 +51461,7 @@ function isPermissionError(err) {
   const msg = err.message.toLowerCase();
   return PERMISSION_ERROR_MARKERS.some((m) => msg.includes(m.toLowerCase()));
 }
-async function spawnPackageManager(executable, args, cwd, label) {
+async function spawnPackageManager(executable, args, cwd, label, extraEnv) {
   if (!SHELL_SAFE_ARG.test(executable)) {
     throw new Error(`Unsafe executable: '${executable}'`);
   }
@@ -51317,8 +51470,9 @@ async function spawnPackageManager(executable, args, cwd, label) {
       throw new Error(`Unsafe argument: '${arg}'`);
     }
   }
-  const { spawn } = await import("node:child_process");
+  const { spawn } = await loadChildProcess();
   const isWindows = process.platform === "win32";
+  const envOpt = extraEnv ? { env: { ...process.env, ...extraEnv } } : {};
   return new Promise((resolve2, reject) => {
     let proc;
     if (isWindows) {
@@ -51329,12 +51483,14 @@ async function spawnPackageManager(executable, args, cwd, label) {
       proc = spawn(commandLine, [], {
         stdio: ["inherit", "pipe", "pipe"],
         shell: true,
-        cwd
+        cwd,
+        ...envOpt
       });
     } else {
       proc = spawn(executable, args, {
         stdio: ["inherit", "pipe", "pipe"],
-        cwd
+        cwd,
+        ...envOpt
       });
     }
     let stderr = "";
@@ -51361,7 +51517,7 @@ async function spawnPackageManager(executable, args, cwd, label) {
     });
   });
 }
-async function runPackageManager(args, cwd) {
+async function runPackageManager(args, cwd, extraEnv) {
   for (const arg of args) {
     if (arg !== "-g" && !arg.startsWith("--")) {
       validatePackageSpec(arg);
@@ -51371,67 +51527,169 @@ async function runPackageManager(args, cwd) {
   const pm = useBun ? "bun" : "npm";
   logger.debug(`Running package manager: ${pm} ${args.join(" ")}${cwd ? ` (cwd: ${cwd})` : ""}`);
   const pmArgs = useBun ? args.filter((a) => a !== "-g").map((a) => a === "uninstall" ? "remove" : a) : args;
-  await spawnPackageManager(pm, pmArgs, cwd, `${pm} ${pmArgs[0]}`);
-}
-async function resolveRegistry() {
-  logger.debug("Resolving npm registry for @uipath packages...");
-  const { findNpmrcConfig: findNpmrcConfig2 } = await Promise.resolve().then(() => (init_npmrc(), exports_npmrc));
-  const config = await findNpmrcConfig2();
-  const registryUrl = config.scopedRegistry || DEFAULT_REGISTRY;
-  logger.debug(`Registry URL: ${registryUrl}${config.scopedRegistry ? " (from .npmrc)" : " (default)"}`);
-  const [urlError] = catchError(() => new URL(registryUrl));
-  if (urlError) {
-    throw new Error(`Invalid @uipath:registry URL in .npmrc: "${registryUrl}"`);
+  await spawnPackageManager(pm, pmArgs, cwd, `${pm} ${pmArgs[0]}`, extraEnv);
+}
+async function runPackageManagerWithBun(args, cwd, extraEnv) {
+  for (const arg of args) {
+    if (arg !== "-g" && !arg.startsWith("--")) {
+      validatePackageSpec(arg);
+    }
   }
-  const envToken = globalThis.process?.env?.GH_NPM_REGISTRY_TOKEN;
-  const authToken = envToken || config.authToken || undefined;
-  logger.debug(`Auth token: ${authToken ? `found (source: ${envToken ? "GH_NPM_REGISTRY_TOKEN env" : ".npmrc"})` : "not found"}`);
-  if (authToken && !config.scopedRegistry) {
-    logger.warn("Auth token found but no @uipath:registry configured in .npmrc — " + "token will be sent to the default registry (npmjs.org)");
+  const pmArgs = args.filter((a) => a !== "-g").map((a) => a === "uninstall" ? "remove" : a);
+  logger.debug(`Running package manager: bun ${pmArgs.join(" ")}${cwd ? ` (cwd: ${cwd})` : ""}`);
+  await spawnPackageManager("bun", pmArgs, cwd, `bun ${pmArgs[0]}`, extraEnv);
+}
+function validateTarballUrl(tarballUrl, registryUrl) {
+  const [err, parsed] = catchError(() => {
+    const url = new URL(tarballUrl);
+    const registry2 = new URL(registryUrl);
+    if (url.hostname !== registry2.hostname || url.protocol !== registry2.protocol) {
+      throw new Error(`refusing tarball from '${url.protocol}//${url.hostname}'; expected '${registry2.protocol}//${registry2.hostname}'`);
+    }
+    return url;
+  });
+  if (err || !parsed) {
+    throw new Error(`Invalid tarball URL '${tarballUrl}': ${err ? err.message : "unparseable"}`);
+  }
+  return parsed;
+}
+function extractTarEntry(tar, entryName) {
+  const decoder = new TextDecoder;
+  let offset = 0;
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every((b) => b === 0))
+      break;
+    const name = decoder.decode(header.subarray(0, 100)).split("\x00", 1)[0];
+    const sizeField = decoder.decode(header.subarray(124, 136)).split("\x00", 1)[0].trim();
+    const size = Number.parseInt(sizeField, 8);
+    if (Number.isNaN(size) || size < 0) {
+      throw new Error(`Corrupt tar header at offset ${offset}`);
+    }
+    const typeflag = header[156];
+    if ((typeflag === 0 || typeflag === 48) && name === entryName) {
+      return decoder.decode(tar.subarray(offset + 512, offset + 512 + size));
+    }
+    offset += 512 + Math.ceil(size / 512) * 512;
   }
-  return { registryUrl, authToken };
+  return null;
 }
 
 class NodeToolService {
-  async fetchPackageInfo(registryUrl, packageName, headers, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
-    const encodedName = packageName.replaceAll("/", "%2f");
-    const url = `${registryUrl.replace(/\/+$/, "")}/${encodedName}`;
-    logger.debug(`Fetching package info: ${url}`);
-    const fetchHeaders = {
-      Accept: "application/json",
-      ...headers
-    };
-    const response = await fetch(url, {
-      headers: fetchHeaders,
-      signal: AbortSignal.timeout(timeoutMs)
+  async npmView(packageName, timeoutMs = NPM_VIEW_TIMEOUT_MS, registry2) {
+    validatePackageSpec(packageName);
+    const args = ["view", packageName, "--json"];
+    const { spawn } = await loadChildProcess();
+    const isWindows = process.platform === "win32";
+    const spawnOpts = registry2 ? {
+      env: {
+        ...process.env,
+        ...scopeRegistryEnv(packageName, registry2)
+      }
+    } : {};
+    const { stdout } = await new Promise((resolve2, reject) => {
+      let proc;
+      if (isWindows) {
+        if (!SHELL_SAFE_ARG.test("npm")) {
+          reject(new Error("Unsafe executable: 'npm'"));
+          return;
+        }
+        for (const arg of args) {
+          if (!SHELL_SAFE_ARG.test(arg)) {
+            reject(new Error(`Unsafe argument: '${arg}'`));
+            return;
+          }
+        }
+        const commandLine = ["npm", ...args].join(" ");
+        if (!SHELL_SAFE_COMMAND_LINE.test(commandLine)) {
+          reject(new Error(`Unsafe command line: '${commandLine}'`));
+          return;
+        }
+        proc = spawn(commandLine, [], {
+          shell: true,
+          ...spawnOpts
+        });
+      } else {
+        proc = spawn("npm", args, spawnOpts);
+      }
+      let out = "";
+      let err = "";
+      const MAX_STDERR = 65536;
+      proc.stdout?.on("data", (d) => {
+        out += d.toString();
+      });
+      proc.stderr?.on("data", (d) => {
+        if (err.length < MAX_STDERR) {
+          err += d.toString();
+        }
+      });
+      const timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`npm view ${packageName} timed out after ${timeoutMs / 1000}s`));
+      }, timeoutMs);
+      proc.on("error", (spawnErr) => {
+        clearTimeout(timer);
+        reject(this.mapNpmViewError(packageName, err, spawnErr));
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        if (code === 0) {
+          resolve2({ stdout: out });
+        } else {
+          reject(this.mapNpmViewError(packageName, err, code));
+        }
+      });
     });
-    if (response.status === 401 || response.status === 403) {
-      throw new Error(`Registry ${registryUrl} returned ${response.status} for ${packageName} (authentication required)`);
-    }
-    if (!response.ok) {
-      throw new Error(`Registry ${registryUrl} returned ${response.status} ${response.statusText} for ${packageName}`);
+    const [parseError, parsed] = catchError(() => JSON.parse(stdout));
+    if (parseError) {
+      throw new Error(`Unexpected npm view output for ${packageName}`);
+    }
+    const data = parsed;
+    const latestVersion = data["dist-tags"]?.latest ?? data.version;
+    const rawVersions = Array.isArray(data.versions) ? data.versions : data.versions ? [data.versions] : [];
+    const availableVersions = rawVersions.filter(isValidSemver).sort((a, b) => compareSemver(b, a));
+    let registryLabel;
+    if (data.dist?.tarball) {
+      const tarball = data.dist.tarball;
+      const [urlError, parsedUrl] = catchError(() => new URL(tarball));
+      registryLabel = urlError ? undefined : parsedUrl.host;
     }
-    const data = await response.json();
-    const latestVersion = data["dist-tags"]?.latest;
-    const [labelError, parsedUrl] = catchError(() => new URL(registryUrl));
-    const registryLabel = labelError ? registryUrl : parsedUrl.host;
-    const availableVersions = Object.keys(data.versions || {}).filter(isValidSemver).sort((a, b) => compareSemver(b, a));
     logger.debug(`Package '${packageName}': latest=${latestVersion ?? "unknown"}, ${availableVersions.length} versions available`);
     return {
-      name: data.name,
+      name: data.name ?? packageName,
       version: latestVersion || "latest",
       description: data.description || "",
       availableVersions,
       registry: registryLabel
     };
   }
+  mapNpmViewError(packageName, stderr, codeOrError) {
+    if (/E404/.test(stderr) || /404/.test(stderr)) {
+      return new Error(`Package ${packageName} not found in the registry`);
+    }
+    if (/E401|E403|ENEEDAUTH|need(s)? auth|authentication/i.test(stderr)) {
+      return new Error(`Authentication required for ${packageName} (configure a token in .npmrc)`);
+    }
+    const detail = stderr.trim() || (codeOrError instanceof Error ? codeOrError.message : `exit ${codeOrError}`);
+    return new Error(`npm view ${packageName} failed: ${detail}`);
+  }
+  async fetchPublicPackument(packageName, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+    validatePackageSpec(packageName);
+    const encodedName = packageName.replaceAll("/", "%2f");
+    const url = `${NPMJS_REGISTRY}/${encodedName}`;
+    logger.debug(`Fetching package info: ${url}`);
+    const response = await fetch(url, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!response.ok) {
+      throw new Error(`Registry ${NPMJS_REGISTRY} returned ${response.status} ${response.statusText} for ${packageName}`);
+    }
+    return await response.json();
+  }
   async search(query) {
-    const { registryUrl, authToken } = await resolveRegistry();
-    const headers = {};
-    if (authToken)
-      headers.Authorization = `Bearer ${authToken}`;
     const packages = [...TOOLS_WHITELIST.keys()];
-    const settled = await Promise.allSettled(packages.map((name) => this.fetchPackageInfo(registryUrl, name, headers)));
+    const settled = await Promise.allSettled(packages.map((name) => this.npmView(name)));
     const results = [];
     const errors4 = [];
     for (const r of settled) {
@@ -51442,7 +51700,7 @@ class NodeToolService {
       }
     }
     if (results.length === 0) {
-      throw new Error(`All ${packages.length} package lookups on ${registryUrl} failed:
+      throw new Error(`All ${packages.length} package lookups failed:
 ${errors4.map((e) => `  - ${e}`).join(`
 `)}`);
     }
@@ -51455,53 +51713,90 @@ ${errors4.map((e) => `  - ${e}`).join(`
   async searchLatestVersion(packageName, versionPrefix, options) {
     const channel = options?.channel ?? "stable";
     logger.debug(`Searching latest version of '${packageName}'${versionPrefix ? ` with prefix '${versionPrefix}'` : ""} (channel: ${channel})`);
-    const { registryUrl, authToken } = await resolveRegistry();
-    const headers = {};
-    if (authToken)
-      headers.Authorization = `Bearer ${authToken}`;
-    const info = await this.fetchPackageInfo(registryUrl, packageName, headers, options?.timeoutMs);
+    const info = await this.npmView(packageName, options?.timeoutMs);
     if (options?.exact !== undefined && info.availableVersions?.includes(options.exact)) {
       logger.debug(`Resolved version: ${options.exact} (exact pin match)`);
       return options.exact;
     }
     if (versionPrefix && info.availableVersions) {
       const matching = info.availableVersions.filter((v) => v.startsWith(versionPrefix));
-      const picked = pickForChannel(matching, channel);
+      const picked = pickForChannelWithFallback(matching, channel);
       if (picked) {
         logger.debug(`Resolved version: ${picked} (${channel}, prefix match)`);
         return picked;
       }
-      if (options?.allowLowerFallback) {
-        const ceiling = parsePrefixCeiling(versionPrefix);
-        if (ceiling) {
-          const lower2 = info.availableVersions.filter((v) => compareSemver(v, ceiling) < 0);
-          const pickedLower = pickForChannel(lower2, channel);
-          if (pickedLower) {
-            logger.debug(`Resolved version: ${pickedLower} (${channel}, lower fallback below ${ceiling})`);
-            return pickedLower;
-          }
-        }
-      }
       logger.debug(`No ${channel} version found matching prefix '${versionPrefix}'`);
       return null;
     }
     if (channel !== "stable" && info.availableVersions) {
-      const picked = pickForChannel(info.availableVersions, channel);
+      const picked = pickForChannelWithFallback(info.availableVersions, channel);
       logger.debug(`Resolved version: ${picked ?? "null"} (${channel}, no prefix)`);
       return picked;
     }
     logger.debug(`Resolved version: ${info.version ?? "null"} (latest)`);
     return info.version ?? null;
   }
+  async resolveInstallCandidate(packageName, versionPrefix) {
+    for (const registry2 of REGISTRY_PREFERENCE) {
+      const [err, info] = await catchError(this.npmView(packageName, undefined, registry2));
+      if (err) {
+        logger.debug(`Skipping ${registry2} for '${packageName}': ${extractErrorMessageSync(err)}`);
+        continue;
+      }
+      const onLine = (info.availableVersions ?? []).filter((v) => v.startsWith(versionPrefix));
+      for (const channel of CHANNEL_PREFERENCE) {
+        const version = pickForChannel(onLine, channel);
+        if (version) {
+          logger.debug(`Resolved '${packageName}@${version}' from ${registry2} (${channel})`);
+          return { version, registry: registry2 };
+        }
+      }
+    }
+    return null;
+  }
+  async downloadPackageFile(packageName, fileName, options) {
+    validatePackageSpec(packageName);
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+    const packument = await this.fetchPublicPackument(packageName, timeoutMs);
+    const latest = packument["dist-tags"]?.latest;
+    const tarballUrl = latest ? packument.versions?.[latest]?.dist?.tarball : undefined;
+    if (!tarballUrl) {
+      throw new Error(`No tarball URL for ${packageName}@${latest ?? "latest"} on ${NPMJS_REGISTRY}`);
+    }
+    const tarball = validateTarballUrl(tarballUrl, NPMJS_REGISTRY);
+    logger.debug(`Downloading tarball: ${tarball.href}`);
+    const response = await fetch(tarball, {
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!response.ok) {
+      throw new Error(`Tarball download for ${packageName} returned ${response.status} ${response.statusText}`);
+    }
+    const { gunzipSync } = await import("node:zlib");
+    const tar = gunzipSync(new Uint8Array(await response.arrayBuffer()));
+    const content = extractTarEntry(tar, `package/${fileName}`);
+    if (content === null) {
+      throw new Error(`File '${fileName}' not found in ${packageName}@${latest} tarball`);
+    }
+    return content;
+  }
   async install(packageName, destination, options) {
     validatePackageSpec(packageName);
     const baseArgs = options?.global ? ["install", "-g", packageName] : ["install", packageName];
+    const extraEnv = options?.registry ? scopeRegistryEnv(packageName, options.registry) : undefined;
     for (let attempt = 0;attempt <= NPM_MAX_RETRIES; attempt++) {
-      const [err] = await catchError(runPackageManager(baseArgs, destination));
+      const [err] = await catchError(runPackageManager(baseArgs, destination, extraEnv));
       if (!err) {
         return;
       }
       const msg = extractErrorMessageSync(err);
+      if (msg.includes(UNSUPPORTED_PROTOCOL_MARKER)) {
+        if (await isBunOnPath()) {
+          logger.warn(`npm install failed with ${UNSUPPORTED_PROTOCOL_MARKER} — ` + `the published package contains 'workspace:' deps that npm cannot resolve. Retrying with bun.`);
+          await runPackageManagerWithBun(baseArgs, destination, extraEnv);
+          return;
+        }
+        throw new Error(`Installation of '${packageName}' failed with ${UNSUPPORTED_PROTOCOL_MARKER}: the published package contains 'workspace:' deps that npm cannot resolve. Install bun (https://bun.sh) and rerun to enable automatic fallback, or use a pre-bundled CLI distribution. Original error: ${msg}`);
+      }
       const isTransient = TRANSIENT_NPM_ERRORS.some((code) => msg.includes(code));
       if (!isTransient || attempt === NPM_MAX_RETRIES) {
         throw err;
@@ -51573,7 +51868,7 @@ function truncateVersionsForDisplay(versions) {
   }
   return result;
 }
-var SEMVER_RE, SAFE_PACKAGE_SPEC, SAFE_VERSION, SHELL_SAFE_ARG, SHELL_SAFE_COMMAND_LINE, NPM_TIMEOUT_MS = 180000, NPM_MAX_RETRIES = 2, TRANSIENT_NPM_ERRORS, DEFAULT_REGISTRY = "https://registry.npmjs.org", PERMISSION_ERROR_MARKERS, toolService;
+var SEMVER_RE, SAFE_PACKAGE_SPEC, SAFE_VERSION, SHELL_SAFE_ARG, SHELL_SAFE_COMMAND_LINE, NPM_TIMEOUT_MS = 180000, NPM_VIEW_TIMEOUT_MS = 30000, NPM_MAX_RETRIES = 2, TRANSIENT_NPM_ERRORS, UNSUPPORTED_PROTOCOL_MARKER = "EUNSUPPORTEDPROTOCOL", cachedBunOnPath, childProcessModulePromise, NPMJS_REGISTRY = "https://registry.npmjs.org", GITHUB_REGISTRY = "https://npm.pkg.github.com", REGISTRY_PREFERENCE, CHANNEL_PREFERENCE, PERMISSION_ERROR_MARKERS, toolService;
 var init_toolService = __esm(() => {
   init_src2();
   init_src();
@@ -51586,6 +51881,11 @@ var init_toolService = __esm(() => {
   SHELL_SAFE_ARG = /^[a-zA-Z0-9@/._-]+$/;
   SHELL_SAFE_COMMAND_LINE = /^[a-zA-Z0-9@/._\- ]+$/;
   TRANSIENT_NPM_ERRORS = ["ENOTEMPTY", "EPERM", "EBUSY"];
+  REGISTRY_PREFERENCE = [
+    NPMJS_REGISTRY,
+    GITHUB_REGISTRY
+  ];
+  CHANNEL_PREFERENCE = ["stable", "alpha"];
   PERMISSION_ERROR_MARKERS = ["EACCES", "permission denied"];
   toolService = new NodeToolService;
 });
@@ -52634,7 +52934,7 @@ function registerCompletionCommand(program2, discovered, context) {
       handlePrint(target);
       return;
     }
-    if (shellArg || !context.output.isInteractive) {
+    if (shellArg || !canPrompt()) {
       context.output.writeOut(target.scriptContent ?? target.content);
       return;
     }
@@ -67249,7 +67549,26 @@ var init_zod = __esm(() => {
   init_external();
 });
 
+// src/services/channels.ts
+var CHANNELS, VALID_CHANNELS;
+var init_channels = __esm(() => {
+  CHANNELS = ["stable", "alpha", "beta", "preview"];
+  VALID_CHANNELS = new Set(CHANNELS);
+});
+
 // src/config/loadConfig.ts
+var exports_loadConfig = {};
+__export(exports_loadConfig, {
+  setCoreConfigValuesAsync: () => setCoreConfigValuesAsync,
+  resolveConfigFilePathAsync: () => resolveConfigFilePathAsync,
+  loadConfigAsync: () => loadConfigAsync,
+  invalidateConfigCache: () => invalidateConfigCache,
+  getCachedConfig: () => getCachedConfig,
+  VERSION_PIN_RE: () => VERSION_PIN_RE,
+  SECRET_FIELD_PATHS: () => SECRET_FIELD_PATHS,
+  ConfigValidationError: () => ConfigValidationError
+});
+import { randomUUID as randomUUID3 } from "node:crypto";
 var VERSION_PIN_RE, ConfigSchema, SECRET_FIELD_PATHS, formatZodError = (error51) => {
   const issues = error51.issues.map((issue2) => {
     const path6 = issue2.path.join(".") || "config";
@@ -67276,7 +67595,37 @@ Please check your config file and fix the errors above.`;
     throw new ConfigValidationError(formatZodError(result.error));
   }
   return result.data;
-}, cachedConfig = null, getCachedConfig = () => cachedConfig ?? {}, getFs = async () => {
+}, cachedConfig = null, getCachedConfig = () => cachedConfig ?? {}, invalidateConfigCache = () => {
+  cachedConfig = null;
+}, setCoreConfigValuesAsync = async (values) => {
+  const fs7 = await getFs();
+  const { absolutePath } = await resolveConfigFilePathAsync();
+  const targetPath = absolutePath ?? fs7.path.join(fs7.env.homedir(), UIPATH_HOME_DIR, CONFIG_FILENAME);
+  let raw = {};
+  const [, content] = await catchError(fs7.readFile(targetPath, "utf-8"));
+  if (content) {
+    const [, parsed] = catchError(() => JSON.parse(content));
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      raw = parsed;
+    }
+  }
+  const existingCore = raw.core;
+  const core2 = existingCore !== null && typeof existingCore === "object" && !Array.isArray(existingCore) ? existingCore : {};
+  for (const [key, value] of Object.entries(values)) {
+    core2[key] = value;
+  }
+  raw.core = core2;
+  await fs7.mkdir(fs7.path.dirname(targetPath));
+  const tempPath = `${targetPath}.${randomUUID3()}.tmp`;
+  await fs7.writeFile(tempPath, JSON.stringify(raw, null, 4));
+  const [renameErr] = await catchError(fs7.rename(tempPath, targetPath));
+  if (renameErr) {
+    await catchError(fs7.rm(tempPath));
+    throw renameErr;
+  }
+  invalidateConfigCache();
+  await loadConfigAsync();
+}, getFs = async () => {
   const { getFileSystemAsync: getFileSystemAsync2 } = await Promise.resolve().then(() => (init_src(), exports_src));
   return getFileSystemAsync2();
 }, LOCAL_CONFIG_REL, resolveConfigFilePathAsync = async (explicitPath) => {
@@ -67345,13 +67694,17 @@ Please ensure your config file contains valid JSON.`);
 var init_loadConfig = __esm(() => {
   init_src2();
   init_zod();
+  init_channels();
   VERSION_PIN_RE = /^(\d+)\.(\d+)(?:\.(\d+))?$/;
   ConfigSchema = exports_external.object({
     core: exports_external.object({
       output: exports_external.enum(["table", "json", "yaml", "plain", "text"]).transform((v) => v === "text" ? "plain" : v).optional(),
       logLevel: exports_external.enum(["error", "warn", "info", "debug"]).optional(),
-      updateChannel: exports_external.enum(["alpha", "beta", "stable"]).optional(),
-      version: exports_external.string().regex(VERSION_PIN_RE, "must be major.minor or major.minor.patch (e.g. 1.2 or 1.2.3)").optional()
+      interactive: exports_external.enum(["never", "auto", "always"]).optional(),
+      updateChannel: exports_external.enum(CHANNELS).optional(),
+      version: exports_external.string().regex(VERSION_PIN_RE, "must be major.minor or major.minor.patch (e.g. 1.2 or 1.2.3)").optional(),
+      autoVersionSync: exports_external.enum(["true", "false"]).optional(),
+      versionSource: exports_external.enum(["environment", "manual"]).optional()
     }).optional(),
     auth: exports_external.object({
       clientId: exports_external.string().min(1).optional(),
@@ -67394,6 +67747,13 @@ function parseVersionPin(raw) {
     pin.patch = Number(match[3]);
   return pin;
 }
+function majorMinorPinOf(version2) {
+  const [rawMajor, rawMinor] = version2.trim().split(/[.\-+]/);
+  if (rawMajor === undefined || rawMinor === undefined || !/^\d+$/.test(rawMajor) || !/^\d+$/.test(rawMinor)) {
+    return null;
+  }
+  return { major: Number(rawMajor), minor: Number(rawMinor) };
+}
 function resolvePinnedVersion() {
   return parseVersionPin(getCachedConfig().core?.version);
 }
@@ -67411,7 +67771,7 @@ var init_versionPin = __esm(() => {
 });
 
 // src/commands/config.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
 async function resolveForRead(explicit) {
   const r = await resolveConfigFilePathAsync(explicit);
@@ -67483,7 +67843,7 @@ async function writeConfigFileAt(path6, config2) {
   const fs7 = getFileSystem();
   const dir = fs7.path.dirname(path6);
   await fs7.mkdir(dir);
-  const tempPath = `${path6}.${randomUUID3()}.tmp`;
+  const tempPath = `${path6}.${randomUUID4()}.tmp`;
   await fs7.writeFile(tempPath, JSON.stringify(config2, null, 4));
   const [renameErr] = await catchError(fs7.rename(tempPath, path6));
   if (renameErr) {
@@ -67629,6 +67989,9 @@ function registerConfigCommand(program2, context) {
     const [opErr] = await catchError(withConfigLock(target.path, async () => {
       const rawConfig = await readConfigFileAt(target.path);
       setNestedValue(rawConfig, def.path, value);
+      if (key === "version") {
+        setNestedValue(rawConfig, ["core", "versionSource"], "manual");
+      }
       await writeConfigFileAt(target.path, rawConfig);
     }));
     if (opErr) {
@@ -67651,11 +68014,12 @@ function registerConfigCommand(program2, context) {
     });
   });
 }
-var CONFIG_KEYS, VALID_KEY_NAMES, CONFIG_GET_EXAMPLES, CONFIG_SET_EXAMPLES, LOCK_STALE_MS2 = 1000, LOCK_RETRY_MS = 50, LOCK_TIMEOUT_MS = 1e4, LOCK_VERIFY_DELAY_MS = 25, lockToken = () => `${process.pid ?? 0}.${randomUUID3()}`, SECRET_WORD_TOKENS, REDACTED_VALUE = "<redacted>", SECRET_PATH_SET;
+var CONFIG_KEYS, VALID_KEY_NAMES, CONFIG_GET_EXAMPLES, CONFIG_SET_EXAMPLES, LOCK_STALE_MS2 = 1000, LOCK_RETRY_MS = 50, LOCK_TIMEOUT_MS = 1e4, LOCK_VERIFY_DELAY_MS = 25, lockToken = () => `${process.pid ?? 0}.${randomUUID4()}`, SECRET_WORD_TOKENS, REDACTED_VALUE = "<redacted>", SECRET_PATH_SET;
 var init_config = __esm(() => {
   init_src2();
   init_src();
   init_loadConfig();
+  init_channels();
   init_versionPin();
   CONFIG_KEYS = {
     output: {
@@ -67668,9 +68032,14 @@ var init_config = __esm(() => {
       validValues: ["error", "warn", "info", "debug"],
       description: "Default log level"
     },
+    interactive: {
+      path: ["core", "interactive"],
+      validValues: ["never", "auto", "always"],
+      description: "When the CLI may show interactive prompts (default: never)"
+    },
     updateChannel: {
       path: ["core", "updateChannel"],
-      validValues: ["alpha", "beta", "stable"],
+      validValues: [...CHANNELS],
       description: "Release channel used to resolve tool updates"
     },
     version: {
@@ -67679,6 +68048,11 @@ var init_config = __esm(() => {
       validate: (v) => isValidVersionPin(v),
       valueHint: "Use major.minor or major.minor.patch (e.g. 1.2 or 1.2.3).",
       description: "Pinned platform version enforced by 'uip update' (CLI + tools)"
+    },
+    autoVersionSync: {
+      path: ["core", "autoVersionSync"],
+      validValues: ["true", "false"],
+      description: "Daily environment-pinned CLI/tools version sync (set 'false' to disable)"
     }
   };
   VALID_KEY_NAMES = Object.keys(CONFIG_KEYS);
@@ -86890,11 +87264,11 @@ var DEFAULT_TIMEOUT_MS = 1000, CLOSE_TIMEOUT_MS = 500, NOTICE_SENTINEL, printNot
   if (error51 || !parsed)
     return;
   const segments = parsed.pathname.split("/").filter(Boolean);
-  const organizationName = segments[0];
-  const tenantName = segments[1];
-  if (!organizationName || !tenantName)
-    return;
-  return { baseUrl: parsed.origin, organizationName, tenantName };
+  return {
+    baseUrl: parsed.origin,
+    organizationName: segments[0],
+    tenantName: segments[1]
+  };
 }, defaultLoadModule = async () => {
   const [error51, mod2] = await catchError2(() => Promise.resolve().then(() => __toESM(require_dist4(), 1)));
   if (error51 || !mod2) {
@@ -86943,6 +87317,7 @@ var DEFAULT_TIMEOUT_MS = 1000, CLOSE_TIMEOUT_MS = 500, NOTICE_SENTINEL, printNot
     }
     let organizationIdFromToken;
     let tenantIdFromToken;
+    let issuerFromToken;
     const [jwtError, claims] = catchError2(() => parseJWT(accessToken));
     if (!jwtError && claims) {
       const rawOrgId = claims.prtId ?? claims.organizationId ?? claims.prt_id;
@@ -86953,6 +87328,10 @@ var DEFAULT_TIMEOUT_MS = 1000, CLOSE_TIMEOUT_MS = 500, NOTICE_SENTINEL, printNot
       if (typeof tenantClaim === "string" && tenantClaim.length > 0) {
         tenantIdFromToken = tenantClaim;
       }
+      const issClaim = claims.iss;
+      if (typeof issClaim === "string" && issClaim.length > 0) {
+        issuerFromToken = issClaim;
+      }
     }
     printNoticeOnce();
     return {
@@ -86961,7 +87340,8 @@ var DEFAULT_TIMEOUT_MS = 1000, CLOSE_TIMEOUT_MS = 500, NOTICE_SENTINEL, printNot
       organizationName: parsedUrl.organizationName,
       organizationId: organizationIdFromToken ?? parsedUrl.organizationName,
       tenantName: parsedUrl.tenantName,
-      tenantId: tenantIdFromToken
+      tenantId: tenantIdFromToken,
+      issuer: issuerFromToken
     };
   } catch {
     return;
@@ -87057,7 +87437,7 @@ var DEFAULT_AUTH_FILENAME, DEFAULT_ENV_FILENAME, KNOWN_ERROR_CODES, errorCode =
       }
     };
   }
-}, resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME) => {
+}, resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
   const fs7 = getFileSystem();
   if (fs7.path.isAbsolute(envFilePath)) {
     const probe2 = await probeAsync(fs7, envFilePath);
@@ -87068,7 +87448,7 @@ var DEFAULT_AUTH_FILENAME, DEFAULT_ENV_FILENAME, KNOWN_ERROR_CODES, errorCode =
       ...probe2.unusable ? { unusable: probe2.unusable } : {}
     };
   }
-  const cwd = fs7.env.cwd();
+  const cwd = opts?.cwd ?? fs7.env.cwd();
   let searchDir = cwd;
   while (true) {
     const candidate = fs7.path.join(searchDir, envFilePath);
@@ -87097,8 +87477,8 @@ var DEFAULT_AUTH_FILENAME, DEFAULT_ENV_FILENAME, KNOWN_ERROR_CODES, errorCode =
     source: "default",
     ...probe.unusable ? { unusable: probe.unusable } : {}
   };
-}, resolveEnvFilePathAsync = async (envFilePath = DEFAULT_ENV_FILENAME) => {
-  const location = await resolveEnvFileLocationAsync(envFilePath);
+}, resolveEnvFilePathAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
+  const location = await resolveEnvFileLocationAsync(envFilePath, opts);
   if (location.exists) {
     return { absolutePath: location.absolutePath };
   }
@@ -87342,6 +87722,7 @@ var LoginStatusSource, getLoginStatusWithDeps = async (options = {}, deps = {})
       organizationId: robotCreds.organizationId,
       tenantName: robotCreds.tenantName,
       tenantId: robotCreds.tenantId,
+      issuer: robotCreds.issuer,
       expiration: expiration2,
       source: "robot" /* Robot */
     };
@@ -87363,6 +87744,7 @@ var LoginStatusSource, getLoginStatusWithDeps = async (options = {}, deps = {})
         organizationId: robotCreds.organizationId,
         tenantName: robotCreds.tenantName,
         tenantId: robotCreds.tenantId,
+        issuer: robotCreds.issuer,
         expiration: expiration2,
         source: "robot" /* Robot */
       };
@@ -87531,7 +87913,8 @@ var init_loginStatus = __esm(() => {
 // ../auth/src/authContext.ts
 var getAuthContext = async (options = {}) => {
   const status = await getLoginStatusAsync({
-    ensureTokenValidityMinutes: options.ensureTokenValidityMinutes
+    ensureTokenValidityMinutes: options.ensureTokenValidityMinutes,
+    envFilePath: options.envFilePath
   });
   if (status.loginStatus !== "Logged in" || !status.baseUrl || !status.accessToken) {
     throw new Error(status.hint ? `Not logged in. ${status.hint}` : "Not logged in. Run 'uip login' first.");
@@ -87557,6 +87940,33 @@ var getAuthContext = async (options = {}) => {
     tenantId: status.tenantId,
     tenantName
   };
+}, getAuthEnv = async (options = {}) => {
+  const authEnv = {};
+  let status;
+  try {
+    status = await getLoginStatusAsync(options);
+  } catch {
+    return { authEnv };
+  }
+  if (status.loginStatus === "Logged in" && status.accessToken) {
+    authEnv.UIPATH_ACCESS_TOKEN = status.accessToken;
+    if (status.baseUrl) {
+      const org = status.organizationName || status.organizationId;
+      const tenant = status.tenantName || status.tenantId;
+      if (org && tenant) {
+        authEnv.UIPATH_URL = `${status.baseUrl.replace(/\/+$/, "")}/${org}/${tenant}`;
+      }
+    }
+    if (status.organizationId)
+      authEnv.UIPATH_ORGANIZATION_ID = status.organizationId;
+    if (status.organizationName)
+      authEnv.UIPATH_ORGANIZATION_NAME = status.organizationName;
+    if (status.tenantId)
+      authEnv.UIPATH_TENANT_ID = status.tenantId;
+    if (status.tenantName)
+      authEnv.UIPATH_TENANT_NAME = status.tenantName;
+  }
+  return { authEnv, loginStatus: status };
 };
 var init_authContext = __esm(() => {
   init_loginStatus();
@@ -87700,7 +88110,8 @@ var interactiveLoginWithDeps = async (options, deps) => {
     tenant,
     organization,
     interactive,
-    onEvent
+    onEvent,
+    timeoutMs
   } = options;
   const emit = (event) => {
     if (!onEvent)
@@ -87728,7 +88139,8 @@ var interactiveLoginWithDeps = async (options, deps) => {
       clientId,
       clientSecret,
       scope,
-      organization
+      organization,
+      timeoutMs
     });
     return {
       UIPATH_ACCESS_TOKEN: authTokens.accessToken,
@@ -88128,7 +88540,7 @@ __export(exports_browser_strategy, {
 });
 
 class BrowserAuthStrategy {
-  async execute(url2, _redirectUri, expectedState) {
+  async execute(url2, _redirectUri, expectedState, _opts) {
     const global5 = getGlobalThis();
     if (!global5?.window) {
       throw new Error("Browser environment required for authentication");
@@ -88203,10 +88615,11 @@ __export(exports_node_strategy, {
 });
 
 class NodeAuthStrategy {
-  async execute(url2, redirectUri, expectedState) {
+  async execute(url2, redirectUri, expectedState, opts) {
     const fs7 = getFileSystem();
     const callbackUrl = await startServer({
       redirectUri,
+      timeoutMs: opts?.timeoutMs,
       onListening: async () => {
         let safeUrl = "";
         for (const ch of url2) {
@@ -88270,6 +88683,7 @@ __export(exports_src2, {
   interactiveLogin: () => interactiveLogin,
   getLoginStatusWithDeps: () => getLoginStatusWithDeps,
   getLoginStatusAsync: () => getLoginStatusAsync,
+  getAuthEnv: () => getAuthEnv,
   getAuthContext: () => getAuthContext,
   fetchTenantsAndOrganizations: () => fetchTenantsAndOrganizations,
   clientCredentialsLogin: () => clientCredentialsLogin,
@@ -88291,7 +88705,8 @@ var authenticate = async ({
   clientSecret,
   redirectUri,
   scope,
-  organization
+  organization,
+  timeoutMs
 }) => {
   const config2 = await resolveConfigAsync({
     customAuthority: baseUrl,
@@ -88341,7 +88756,7 @@ var authenticate = async ({
     const { NodeAuthStrategy: NodeAuthStrategy2 } = await Promise.resolve().then(() => (init_node_strategy(), exports_node_strategy));
     strategy = new NodeAuthStrategy2;
   }
-  const code = await strategy.execute(authUrl, effectiveRedirectUriUrl, state);
+  const code = await strategy.execute(authUrl, effectiveRedirectUriUrl, state, { timeoutMs });
   return await exchangeCodeForTokens({
     code,
     codeVerifier: code_verifier,
@@ -88388,6 +88803,11 @@ var init_promptSelect = __esm(() => {
 });
 
 // src/services/auth.ts
+var exports_auth = {};
+__export(exports_auth, {
+  auth: () => auth
+});
+
 class NodeAuth {
   async interactiveLogin(options) {
     const { interactiveLogin: interactiveLogin2 } = await Promise.resolve().then(() => (init_src3(), exports_src2));
@@ -88473,24 +88893,44 @@ var AuthTelemetryEvents, getUserIdFromToken = (accessToken) => {
   } catch {
     return;
   }
-}, populateTelemetryAuthContext = async (deps = {}) => {
+}, readAuthIdentity = async (deps) => {
+  const envAuthEnabled = deps.isEnvAuthEnabled ?? isEnvAuthEnabled;
+  const readEnv = deps.readAuthFromEnv ?? readAuthFromEnv;
   const resolveEnvFilePath = deps.resolveEnvFilePath ?? resolveEnvFilePathAsync;
   const loadEnvFile = deps.loadEnvFile ?? loadEnvFileAsync;
+  if (envAuthEnabled()) {
+    const [error51, status] = catchError(() => readEnv());
+    if (error51 || !status)
+      return;
+    return {
+      accessToken: status.accessToken,
+      tenantId: status.tenantId,
+      organizationId: status.organizationId
+    };
+  }
   const [resolveError, resolved] = await catchError(resolveEnvFilePath(DEFAULT_ENV_FILENAME));
   if (resolveError || !resolved?.absolutePath)
     return;
   const [loadError, credentials] = await catchError(loadEnvFile({ envPath: resolved.absolutePath }));
   if (loadError || !credentials)
     return;
-  const accessToken = credentials.UIPATH_ACCESS_TOKEN;
-  if (!accessToken)
+  return {
+    accessToken: credentials.UIPATH_ACCESS_TOKEN,
+    tenantId: credentials.UIPATH_TENANT_ID,
+    organizationId: credentials.UIPATH_ORGANIZATION_ID
+  };
+}, populateTelemetryAuthContext = async (deps = {}) => {
+  const identity = await readAuthIdentity(deps);
+  if (!identity)
     return;
-  const userId = getUserIdFromToken(accessToken);
+  const userId = identity.accessToken ? getUserIdFromToken(identity.accessToken) : undefined;
   const defaultProps = {
     ...userId ? { CloudUserId: userId } : {},
-    ...credentials.UIPATH_TENANT_ID ? { CloudTenantId: credentials.UIPATH_TENANT_ID } : {},
-    ...credentials.UIPATH_ORGANIZATION_ID ? { CloudOrganizationId: credentials.UIPATH_ORGANIZATION_ID } : {}
+    ...identity.tenantId ? { CloudTenantId: identity.tenantId } : {},
+    ...identity.organizationId ? { CloudOrganizationId: identity.organizationId } : {}
   };
+  if (Object.keys(defaultProps).length === 0)
+    return;
   setGlobalTelemetryProperties(defaultProps);
   telemetry.setDefaultProperties(defaultProps);
   logger.debug("[Telemetry] auth context populated at startup");
@@ -88553,12 +88993,28 @@ function instructionsForLoginError(error51, message) {
   if (code === AUTH_TIMEOUT_ERROR_CODE) {
     return `The browser did not return an authorization code within the timeout. Make sure your default browser opened, complete the sign-in, then retry. ${ENV_AUTH_FALLBACK_HINT}`;
   }
+  const connectivity = describeConnectivityError(error51);
+  if (connectivity) {
+    return connectivity.instructions;
+  }
   return `Inspect command arguments and message and try again. ${ENV_AUTH_FALLBACK_HINT}`;
 }
+function loginErrorMessage(error51) {
+  const base = error51 instanceof Error ? error51.message : String(error51);
+  const connectivity = describeConnectivityError(error51);
+  if (connectivity && connectivity.message !== base) {
+    return `${base}: ${connectivity.message}`;
+  }
+  return base;
+}
 function instructionsForStatusError(err) {
   if (err instanceof EnvAuthConfigError) {
     return "Check the UIPATH_CLI_* environment variables and re-run.";
   }
+  const connectivity = describeConnectivityError(err);
+  if (connectivity) {
+    return connectivity.instructions;
+  }
   return "Failed to read login status. Check your credentials file.";
 }
 function buildRefreshData(status) {
@@ -88622,7 +89078,7 @@ function defaultRefreshFailureInstructions(status) {
   }
 }
 function registerLoginCommand(program2, context) {
-  const loginCommand = program2.command("login").description("Login to UiPath Cloud").option("-f, --file <folder>", "Path to credentials folder").option("--authority <url>", "Custom authority URL").option("--client-id <id>", "Client Id or Application Id. Use env.ENV_NAME to read from an environment variable").option("--client-secret <secret>", "Client Secret or Application Secret. Use env.ENV_NAME to read from an environment variable").option("-s, --scope <scopes>", "Custom scopes or Application scopes (External Apps). Space separated values.").option("-t, --tenant <name>", "Tenant name (non-interactive mode)").option("--organization <name>", "Organization logical name to pre-select during browser login (bypasses the org picker for users in multiple organizations)").option("--it, --interactive", "Interactively select tenant from list").examples(LOGIN_EXAMPLES).trackedAction(context, async (options) => {
+  const loginCommand = program2.command("login").description("Login to UiPath Cloud").option("-f, --file <folder>", "Path to credentials folder").option("--authority <url>", "Custom authority URL").option("--client-id <id>", "Client Id or Application Id. Use env.ENV_NAME to read from an environment variable").option("--client-secret <secret>", "Client Secret or Application Secret. Use env.ENV_NAME to read from an environment variable").option("-s, --scope <scopes>", "Custom scopes or Application scopes (External Apps). Space separated values.").option("-t, --tenant <name>", "Tenant name (non-interactive mode)").option("--organization <name>", "Organization logical name to pre-select during browser login (bypasses the org picker for users in multiple organizations)").examples(LOGIN_EXAMPLES).trackedAction(context, async (options) => {
     const envFilePath = resolveAuthFilePath(options.file);
     let clientId;
     let clientSecret;
@@ -88669,11 +89125,11 @@ function registerLoginCommand(program2, context) {
       scope: options.scope ? options.scope.split(" ") : undefined,
       tenant: options.tenant,
       organization: options.organization,
-      interactive: options.interactive,
+      interactive: canPrompt(),
       onEvent: handleAuthEvent
     }));
     if (error51) {
-      const message = error51 instanceof Error ? error51.message : String(error51);
+      const message = loginErrorMessage(error51);
       trackAuthLogin(authFlow, {
         success: false,
         errorMessage: message
@@ -88732,7 +89188,7 @@ function registerLoginCommand(program2, context) {
     hasClientCredentials: !!(options.clientId && options.clientSecret),
     hasTenant: !!options.tenant,
     hasOrganization: !!options.organization,
-    interactive: !!options.interactive
+    interactive: canPrompt()
   }));
   loginCommand.command("status").description("Show current login status and session information").examples(LOGIN_STATUS_EXAMPLES).trackedAction(context, async () => {
     const [statusError, status] = await catchError(auth.getLoginStatus({
@@ -88741,7 +89197,7 @@ function registerLoginCommand(program2, context) {
     if (statusError) {
       OutputFormatter.error({
         Result: RESULTS.ConfigError,
-        Message: statusError.message,
+        Message: loginErrorMessage(statusError),
         Instructions: instructionsForStatusError(statusError)
       });
       return;
@@ -88782,7 +89238,7 @@ function registerLoginCommand(program2, context) {
     if (statusError) {
       OutputFormatter.error({
         Result: RESULTS.AuthenticationError,
-        Message: `Could not read credentials: ${statusError.message}`,
+        Message: `Could not read credentials: ${loginErrorMessage(statusError)}`,
         Instructions: instructionsForStatusError(statusError)
       });
       context.exit(2);
@@ -88810,7 +89266,7 @@ function registerLoginCommand(program2, context) {
     if (statusError) {
       OutputFormatter.error({
         Result: RESULTS.ConfigError,
-        Message: statusError.message,
+        Message: loginErrorMessage(statusError),
         Instructions: instructionsForStatusError(statusError)
       });
       return;
@@ -88826,10 +89282,11 @@ function registerLoginCommand(program2, context) {
     }
     const [fetchError, data] = await catchError(auth.fetchTenants(status.baseUrl, status.accessToken, status.organizationId));
     if (fetchError) {
+      const connectivity = describeConnectivityError(fetchError);
       OutputFormatter.error({
         Result: RESULTS.Failure,
-        Message: fetchError.message,
-        Instructions: "Failed to fetch tenants. Check your network connection and try again."
+        Message: loginErrorMessage(fetchError),
+        Instructions: connectivity?.instructions ?? "Failed to fetch tenants. Check your network connection and try again."
       });
       return;
     }
@@ -88887,7 +89344,7 @@ function registerLoginCommand(program2, context) {
     if (statusError) {
       OutputFormatter.error({
         Result: RESULTS.ConfigError,
-        Message: statusError.message,
+        Message: loginErrorMessage(statusError),
         Instructions: instructionsForStatusError(statusError)
       });
       return;
@@ -105111,48 +105568,131 @@ var init_send_feedback = __esm(() => {
   ];
 });
 
+// src/commands/skills/agents/detect.ts
+import { spawn } from "node:child_process";
+function windowsExts() {
+  const fs7 = getFileSystem();
+  const raw = fs7.env.getenv("PATHEXT") ?? ".COM;.EXE;.BAT;.CMD";
+  return raw.split(";").map((e) => e.trim().toLowerCase()).filter(Boolean);
+}
+async function commandOnPath(...names) {
+  const isWin = process.platform === "win32";
+  const fs7 = getFileSystem();
+  const pathVar = fs7.env.getenv("PATH") ?? "";
+  if (!pathVar)
+    return false;
+  const dirs = pathVar.split(isWin ? ";" : ":").filter(Boolean);
+  const exts = isWin ? ["", ...windowsExts()] : [""];
+  for (const dir of dirs) {
+    for (const name of names) {
+      for (const ext of exts) {
+        const candidate = fs7.path.join(dir, `${name}${ext}`);
+        const [, exists] = await catchError(fs7.exists(candidate));
+        if (exists)
+          return true;
+      }
+    }
+  }
+  return false;
+}
+function runVersion(command, args, timeoutMs = VERSION_TIMEOUT_MS) {
+  return new Promise((resolve2) => {
+    const proc = process.platform === "win32" ? spawn([command, ...args].join(" "), [], {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: true
+    }) : spawn(command, [...args], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let out = "";
+    let settled = false;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve2(value);
+    };
+    const timer = setTimeout(() => {
+      proc.kill();
+      finish(null);
+    }, timeoutMs);
+    proc.stdout?.on("data", (d) => {
+      out += d.toString();
+    });
+    proc.stderr?.on("data", (d) => {
+      out += d.toString();
+    });
+    proc.on("error", () => finish(null));
+    proc.on("close", () => finish(out || null));
+  });
+}
+async function verifiedCommandOnPath(names, signature, versionArgs = ["--version"]) {
+  for (const name of names) {
+    if (!await commandOnPath(name))
+      continue;
+    const out = await runVersion(name, versionArgs);
+    if (out && signature.test(out))
+      return true;
+  }
+  return false;
+}
+async function homePathExists(...segments) {
+  const fs7 = getFileSystem();
+  const [, exists] = await catchError(fs7.exists(fs7.path.join(fs7.env.homedir(), ...segments)));
+  return exists ?? false;
+}
+var VERSION_TIMEOUT_MS = 5000;
+var init_detect = __esm(() => {
+  init_src2();
+  init_src();
+});
+
 // src/commands/skills/agents/autopilot.ts
 var def;
 var init_autopilot = __esm(() => {
+  init_detect();
   def = {
-    localSubdir: [".autopilot", "skills"]
+    localSubdir: [".autopilot", "skills"],
+    detect: () => homePathExists(".autopilot")
   };
 });
 
 // src/commands/skills/contentStore.ts
-import { spawn } from "node:child_process";
-import { randomUUID as randomUUID4 } from "node:crypto";
-async function fetchSkillsTo(targetPath, rootDir) {
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { gunzipSync } from "node:zlib";
+function loadChildProcess2() {
+  childProcessModulePromise2 ??= import("node:child_process");
+  return childProcessModulePromise2;
+}
+async function fetchSkillsTo(targetPath, _rootDir) {
   const fs7 = getFileSystem();
-  let needsClone = true;
-  if (await fs7.exists(fs7.path.join(targetPath, ".git"))) {
-    logger.info("Updating content store...");
-    const [pullError] = await catchError(runGit(["pull", "--ff-only"], targetPath));
-    if (pullError) {
-      logger.warn("git pull failed, re-cloning...");
-    } else {
-      needsClone = false;
-    }
+  const packageInfo = await fetchMatchingSkillsPackageInfo();
+  logger.info(`Downloading ${SKILLS_PACKAGE_NAME}@${packageInfo.version} content store...`);
+  const tmpPath = fs7.path.join(fs7.env.tmpdir(), `uipath-skills-store-${randomUUID5()}`);
+  const manifestPath = fs7.path.join(targetPath, MANIFEST_NAME);
+  let savedManifest = null;
+  if (await fs7.exists(targetPath)) {
+    savedManifest = await fs7.readFile(manifestPath, {
+      encoding: "utf-8"
+    });
   }
-  if (needsClone) {
-    logger.info("Downloading content store...");
-    let savedManifest = null;
-    const manifestPath = fs7.path.join(targetPath, MANIFEST_NAME);
+  try {
+    await fs7.mkdir(tmpPath);
+    await downloadAndExtractPackage(packageInfo, tmpPath);
+    if (!await fs7.exists(fs7.path.join(tmpPath, "skills"))) {
+      throw new Error(`${SKILLS_PACKAGE_NAME}@${packageInfo.version} does not contain a skills/ directory`);
+    }
+    await writeSourceMarker(tmpPath, packageInfo);
     if (await fs7.exists(targetPath)) {
-      savedManifest = await fs7.readFile(manifestPath, {
-        encoding: "utf-8"
-      });
       await fs7.rm(targetPath);
     }
     await fs7.mkdir(targetPath);
-    const [cloneError] = await catchError(runGit(["clone", "--depth", "1", REPO_URL, targetPath], rootDir));
-    if (cloneError) {
-      logger.info("git clone failed, falling back to zip download...");
-      await downloadAndExtractZip(targetPath);
-    }
+    await fs7.copyDirectory(tmpPath, targetPath);
     if (savedManifest !== null) {
       await fs7.writeFile(manifestPath, savedManifest);
     }
+  } finally {
+    await catchError(fs7.rm(tmpPath));
   }
 }
 async function getContentStore(rootDir) {
@@ -105274,88 +105814,543 @@ async function removeFromManifest(storePath, skillNames, agents) {
   }
   await writeManifest(storePath, manifest);
 }
-function runGit(args, cwd) {
-  return new Promise((resolve2, reject) => {
-    const isWindows = process.platform === "win32";
-    const proc = isWindows ? spawn(["git", ...args].map((a) => a.includes(" ") ? `"${a}"` : a).join(" "), [], {
-      cwd,
-      stdio: ["inherit", "pipe", "pipe"],
-      shell: true
-    }) : spawn("git", args, {
-      cwd,
-      stdio: ["inherit", "pipe", "pipe"]
-    });
+function registryPackagePath(packageName) {
+  return packageName.replaceAll("/", "%2f");
+}
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.codePointAt(end - 1) === 47) {
+    end--;
+  }
+  return value.slice(0, end);
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  return value;
+}
+function isDecimalInteger(value) {
+  return value.length > 0 && Array.from(value).every((char) => char >= "0" && char <= "9");
+}
+function isSemverIdentifierChar(char) {
+  const code = char.codePointAt(0);
+  return code !== undefined && (code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || char === "-");
+}
+function isSemverIdentifierList(value) {
+  return value.length > 0 && value.split(".").every((part) => part.length > 0 && Array.from(part).every(isSemverIdentifierChar));
+}
+function stripSemverBuild(version2) {
+  const parts = version2.split("+");
+  if (parts.length > 2)
+    return null;
+  const build = parts[1];
+  if (build !== undefined && !isSemverIdentifierList(build))
+    return null;
+  return parts[0];
+}
+function splitSemverPrerelease(version2) {
+  const prereleaseSeparator = version2.indexOf("-");
+  if (prereleaseSeparator === -1) {
+    return { core: version2 };
+  }
+  const prerelease = version2.slice(prereleaseSeparator + 1);
+  if (!isSemverIdentifierList(prerelease))
+    return null;
+  return {
+    core: version2.slice(0, prereleaseSeparator),
+    prerelease
+  };
+}
+function parseSemver(version2) {
+  const versionWithoutBuild = stripSemverBuild(version2);
+  if (!versionWithoutBuild)
+    return null;
+  const parsed = splitSemverPrerelease(versionWithoutBuild);
+  if (!parsed)
+    return null;
+  const coreParts = parsed.core.split(".");
+  if (coreParts.length !== 3 || !coreParts.every(isDecimalInteger)) {
+    return null;
+  }
+  return {
+    major: Number.parseInt(coreParts[0], 10),
+    minor: Number.parseInt(coreParts[1], 10),
+    patch: Number.parseInt(coreParts[2], 10),
+    ...parsed.prerelease ? { prerelease: parsed.prerelease } : {}
+  };
+}
+function parsePrereleasePart(value) {
+  if (!isDecimalInteger(value))
+    return { value };
+  return { value, numericValue: Number.parseInt(value, 10) };
+}
+function comparePrereleasePart(left, right) {
+  const leftNumericValue = left.numericValue;
+  const rightNumericValue = right.numericValue;
+  const leftIsNumeric = leftNumericValue !== undefined;
+  const rightIsNumeric = rightNumericValue !== undefined;
+  if (leftNumericValue !== undefined && rightNumericValue !== undefined) {
+    const numericDiff = leftNumericValue - rightNumericValue;
+    if (numericDiff !== 0)
+      return numericDiff;
+  }
+  if (leftIsNumeric !== rightIsNumeric) {
+    return leftIsNumeric ? -1 : 1;
+  }
+  if (left.value === right.value)
+    return 0;
+  return left.value.localeCompare(right.value);
+}
+function compareOptionalPrereleasePart(left, right) {
+  if (left === undefined)
+    return right === undefined ? 0 : -1;
+  if (right === undefined)
+    return 1;
+  return comparePrereleasePart(parsePrereleasePart(left), parsePrereleasePart(right));
+}
+function comparePrerelease(a, b) {
+  const aParts = a.split(".");
+  const bParts = b.split(".");
+  const length = Math.max(aParts.length, bParts.length);
+  for (let i = 0;i < length; i++) {
+    const comparison = compareOptionalPrereleasePart(aParts[i], bParts[i]);
+    if (comparison !== 0)
+      return comparison;
+  }
+  return 0;
+}
+function compareSemver2(a, b) {
+  const left = parseSemver(a);
+  const right = parseSemver(b);
+  if (!left || !right)
+    return a.localeCompare(b);
+  const coreDiff = left.major - right.major || left.minor - right.minor || left.patch - right.patch;
+  if (coreDiff !== 0)
+    return coreDiff;
+  if (!left.prerelease && !right.prerelease)
+    return 0;
+  if (!left.prerelease)
+    return 1;
+  if (!right.prerelease)
+    return -1;
+  return comparePrerelease(left.prerelease, right.prerelease);
+}
+function matchesCliVersionLine(version2, cliVersion) {
+  const parsed = parseSemver(version2);
+  if (!parsed)
+    return false;
+  if (parsed.major !== cliVersion.major || parsed.minor !== cliVersion.minor) {
+    return false;
+  }
+  return true;
+}
+function isStableVersion(version2) {
+  return parseSemver(version2)?.prerelease === undefined;
+}
+function getGhNpmRegistryToken() {
+  const envToken = globalThis.process?.env?.GH_NPM_REGISTRY_TOKEN;
+  return envToken || undefined;
+}
+function validateNpmArgument(arg) {
+  if (!SHELL_SAFE_ARG2.test(arg)) {
+    throw new Error(`Unsafe npm argument: '${arg}'`);
+  }
+}
+function validateNpmArguments(args) {
+  for (const arg of args) {
+    validateNpmArgument(arg);
+  }
+}
+function packageFetchHeaders(accept, authToken) {
+  return {
+    Accept: accept,
+    ...authToken ? { Authorization: `Bearer ${authToken}` } : {}
+  };
+}
+async function runNpmCommand(args, label, timeoutMs, cwd) {
+  validateNpmArguments(args);
+  const { spawn: spawn2 } = await loadChildProcess2();
+  const isWindows = process.platform === "win32";
+  return await new Promise((resolve2, reject) => {
+    let proc;
+    if (isWindows) {
+      if (!SHELL_SAFE_ARG2.test("npm")) {
+        reject(new Error("Unsafe executable: 'npm'"));
+        return;
+      }
+      const commandLine = ["npm", ...args].join(" ");
+      if (!SHELL_SAFE_COMMAND_LINE2.test(commandLine)) {
+        reject(new Error(`Unsafe command line: '${commandLine}'`));
+        return;
+      }
+      proc = spawn2(commandLine, [], { cwd, shell: true });
+    } else {
+      proc = spawn2("npm", args, { cwd });
+    }
     let stdout = "";
     let stderr = "";
-    proc.stdout?.on("data", (d) => {
-      stdout += d.toString();
+    const MAX_STDERR = 65536;
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
     });
-    proc.stderr?.on("data", (d) => {
-      stderr += d.toString();
+    proc.stderr?.on("data", (data) => {
+      if (stderr.length < MAX_STDERR) {
+        stderr += data.toString();
+      }
     });
     const timer = setTimeout(() => {
       proc.kill("SIGTERM");
-      reject(new Error(`git ${args[0]} timed out after 120s`));
-    }, 120000);
-    proc.on("error", (err) => {
+      reject(new Error(`npm ${label} timed out after ${timeoutMs / 1000}s`));
+    }, timeoutMs);
+    proc.on("error", (error51) => {
       clearTimeout(timer);
-      reject(err);
+      reject(mapNpmError(label, stderr, error51));
     });
     proc.on("close", (code) => {
       clearTimeout(timer);
-      code === 0 ? resolve2(stdout.trim()) : reject(new Error(stderr.trim() || `git ${args[0]} failed with code ${code}`));
+      if (code === 0) {
+        resolve2(stdout);
+        return;
+      }
+      reject(mapNpmError(label, stderr, code));
     });
   });
 }
-async function downloadAndExtractZip(storePath) {
-  const fs7 = getFileSystem();
-  const response = await fetch(ZIP_URL, {
+function mapNpmError(label, stderr, codeOrError) {
+  if (/E404/.test(stderr) || /404/.test(stderr)) {
+    return new Error(`${SKILLS_PACKAGE_NAME} not found in the registry`);
+  }
+  if (/E401|E403|ENEEDAUTH|need(s)? auth|authentication/i.test(stderr)) {
+    return new Error(`Authentication required for ${SKILLS_PACKAGE_NAME} (configure @uipath:registry and an auth token in .npmrc, or set GH_NPM_REGISTRY_TOKEN)`);
+  }
+  const detail = stderr.trim() || (codeOrError instanceof Error ? codeOrError.message : `exit ${codeOrError}`);
+  return new Error(`npm ${label} failed: ${detail}`);
+}
+function parseNpmJson(stdout, label) {
+  const [parseError, parsed] = catchError(() => JSON.parse(stdout));
+  if (parseError) {
+    throw new Error(`Unexpected npm ${label} output`);
+  }
+  return parsed;
+}
+async function npmViewJson(args) {
+  const stdout = await runNpmCommand(["view", ...args, "--json"], `view ${args.join(" ")}`, NPM_VIEW_TIMEOUT_MS2);
+  return parseNpmJson(stdout, "view");
+}
+function normalizeVersionList(value) {
+  if (Array.isArray(value)) {
+    return value.filter((version2) => {
+      return typeof version2 === "string";
+    });
+  }
+  if (typeof value === "string") {
+    return [value];
+  }
+  return [];
+}
+function requireString(value, message) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(message);
+  }
+  return value;
+}
+function registryFromTarball(tarballUrl) {
+  const [urlError, parsedUrl] = catchError(() => new URL(tarballUrl));
+  return urlError ? SKILLS_REGISTRY_URL : parsedUrl.origin;
+}
+async function fetchJson(url2, authToken) {
+  const response = await fetch(url2, {
+    headers: packageFetchHeaders("application/json", authToken),
+    signal: AbortSignal.timeout(60000)
+  });
+  if (!response.ok) {
+    throw new Error(`Registry returned ${response.status} ${response.statusText} for ${SKILLS_PACKAGE_NAME}`);
+  }
+  const data = asRecord(await response.json());
+  if (!data) {
+    throw new Error(`Registry returned invalid metadata for ${SKILLS_PACKAGE_NAME}`);
+  }
+  return data;
+}
+async function fetchMatchingSkillsPackageInfo() {
+  const cliVersion = parseSemver(package_default.version);
+  if (!cliVersion) {
+    throw new Error(`Invalid CLI version ${package_default.version}; expected semantic version major.minor.patch`);
+  }
+  const ghToken = getGhNpmRegistryToken();
+  if (ghToken) {
+    logger.debug(`GH_NPM_REGISTRY_TOKEN found; using ${SKILLS_GITHUB_REGISTRY_URL}`);
+    return await fetchMatchingSkillsPackageInfoFromRegistry(cliVersion, SKILLS_GITHUB_REGISTRY_URL, ghToken);
+  }
+  return await fetchMatchingSkillsPackageInfoWithNpm(cliVersion);
+}
+function pickMatchingSkillsVersion(versions2, cliVersion) {
+  const matchingVersions = versions2.filter((version2) => matchesCliVersionLine(version2, cliVersion));
+  const preferredVersions = cliVersion.prerelease === undefined ? matchingVersions.filter(isStableVersion) : matchingVersions;
+  const selectedVersion = (preferredVersions.length > 0 ? preferredVersions : matchingVersions).sort((a, b) => compareSemver2(b, a))[0];
+  if (!selectedVersion) {
+    throw new Error(`${SKILLS_PACKAGE_NAME} has no published version matching CLI ${cliVersion.major}.${cliVersion.minor}.x`);
+  }
+  return selectedVersion;
+}
+async function fetchMatchingSkillsPackageInfoWithNpm(cliVersion) {
+  const versions2 = normalizeVersionList(await npmViewJson([SKILLS_PACKAGE_NAME, "versions"]));
+  const selectedVersion = pickMatchingSkillsVersion(versions2, cliVersion);
+  const tarballUrl = requireString(await npmViewJson([
+    `${SKILLS_PACKAGE_NAME}@${selectedVersion}`,
+    "dist.tarball"
+  ]), `${SKILLS_PACKAGE_NAME}@${selectedVersion} does not declare dist.tarball`);
+  return {
+    version: selectedVersion,
+    tarballUrl,
+    registryUrl: registryFromTarball(tarballUrl)
+  };
+}
+async function fetchMatchingSkillsPackageInfoFromRegistry(cliVersion, registryUrl, authToken) {
+  const [urlError] = catchError(() => new URL(registryUrl));
+  if (urlError) {
+    throw new Error(`Invalid registry URL: "${registryUrl}"`);
+  }
+  const url2 = `${trimTrailingSlashes(registryUrl)}/${registryPackagePath(SKILLS_PACKAGE_NAME)}`;
+  const data = await fetchJson(url2, authToken);
+  const versions2 = asRecord(data.versions);
+  const selectedVersion = pickMatchingSkillsVersion(Object.keys(versions2 ?? {}), cliVersion);
+  const selectedPackageVersion = asRecord(versions2?.[selectedVersion]);
+  const dist = asRecord(selectedPackageVersion?.dist);
+  const tarballUrl = typeof dist?.tarball === "string" ? dist.tarball : undefined;
+  if (!tarballUrl) {
+    throw new Error(`${SKILLS_PACKAGE_NAME}@${selectedVersion} does not declare dist.tarball`);
+  }
+  return {
+    version: selectedVersion,
+    tarballUrl,
+    registryUrl,
+    authToken
+  };
+}
+async function downloadAndExtractPackage(packageInfo, destinationPath) {
+  if (!packageInfo.authToken) {
+    await packAndExtractPackage(packageInfo, destinationPath);
+    return;
+  }
+  const response = await fetch(packageInfo.tarballUrl, {
+    headers: packageFetchHeaders("application/octet-stream", packageInfo.authToken),
     signal: AbortSignal.timeout(60000)
   });
   if (!response.ok) {
-    throw new Error(`Failed to download zip: ${response.status}`);
+    throw new Error(`Failed to download ${SKILLS_PACKAGE_NAME}@${packageInfo.version}: ${response.status} ${response.statusText}`);
   }
-  const zipPath = fs7.path.join(fs7.env.tmpdir(), `uipath-skills-${randomUUID4()}.zip`);
   const arrayBuffer = await response.arrayBuffer();
-  await fs7.writeFile(zipPath, Buffer.from(arrayBuffer));
+  const tarData = gunzipSync(new Uint8Array(arrayBuffer));
+  await extractNpmTarballToDir(tarData, destinationPath);
+}
+async function packAndExtractPackage(packageInfo, destinationPath) {
+  const fs7 = getFileSystem();
+  const packDir = fs7.path.join(fs7.env.tmpdir(), `uipath-skills-pack-${randomUUID5()}`);
   try {
-    const isWindows = process.platform === "win32";
-    if (isWindows) {
-      await new Promise((resolve2, reject) => {
-        const proc = spawn("powershell", [
-          "-Command",
-          `Expand-Archive -Path '${zipPath}' -DestinationPath '${storePath}' -Force`
-        ], { stdio: "inherit" });
-        proc.on("error", reject);
-        proc.on("close", (code) => code === 0 ? resolve2() : reject(new Error(`Expand-Archive failed with code ${code}`)));
-      });
-    } else {
-      await new Promise((resolve2, reject) => {
-        const proc = spawn("unzip", ["-o", zipPath, "-d", storePath], {
-          stdio: "inherit"
-        });
-        proc.on("error", reject);
-        proc.on("close", (code) => code === 0 ? resolve2() : reject(new Error(`unzip failed with code ${code}`)));
-      });
+    await fs7.mkdir(packDir);
+    const stdout = await runNpmCommand(["pack", `${SKILLS_PACKAGE_NAME}@${packageInfo.version}`, "--json"], `pack ${SKILLS_PACKAGE_NAME}@${packageInfo.version}`, NPM_PACK_TIMEOUT_MS, packDir);
+    const packOutput = parseNpmJson(stdout, "pack");
+    const packedFile = readPackedFileName(packOutput);
+    const packedPath = fs7.path.join(packDir, packedFile);
+    const packedContent = await fs7.readFile(packedPath);
+    if (!packedContent) {
+      throw new Error(`npm pack did not create ${packedFile}`);
+    }
+    const tarData = gunzipSync(new Uint8Array(packedContent));
+    await extractNpmTarballToDir(tarData, destinationPath);
+  } finally {
+    await catchError(fs7.rm(packDir));
+  }
+}
+function readPackedFileName(packOutput) {
+  if (!Array.isArray(packOutput)) {
+    throw new TypeError(`Unexpected npm pack output for ${SKILLS_PACKAGE_NAME}`);
+  }
+  const firstEntry = asRecord(packOutput[0]);
+  const filename = typeof firstEntry?.filename === "string" ? firstEntry.filename : undefined;
+  if (!filename) {
+    throw new TypeError(`Unexpected npm pack output for ${SKILLS_PACKAGE_NAME}`);
+  }
+  if (filename.includes("/") || filename.includes("\\")) {
+    throw new Error(`Unsafe npm pack filename for ${SKILLS_PACKAGE_NAME}`);
+  }
+  return filename;
+}
+async function writeSourceMarker(storePath, packageInfo) {
+  const fs7 = getFileSystem();
+  const marker = {
+    source: "npm",
+    package: SKILLS_PACKAGE_NAME,
+    version: packageInfo.version,
+    registry: packageInfo.registryUrl,
+    tarball: packageInfo.tarballUrl,
+    fetchedAt: new Date().toISOString()
+  };
+  await fs7.writeFile(fs7.path.join(storePath, SOURCE_MARKER_NAME), `${JSON.stringify(marker, null, 4)}
+`);
+}
+function readTarString(data, offset, length) {
+  const field = data.subarray(offset, offset + length);
+  const nullIndex = field.indexOf(0);
+  const end = nullIndex >= 0 ? nullIndex : field.length;
+  return Buffer.from(field.subarray(0, end)).toString("utf-8");
+}
+function readTarOctal(data, offset, length) {
+  const raw = readTarString(data, offset, length).trim();
+  if (!raw)
+    return 0;
+  const parsed = Number.parseInt(raw, 8);
+  if (Number.isNaN(parsed)) {
+    throw new TypeError(`Invalid tar numeric field: ${raw}`);
+  }
+  return parsed;
+}
+function readTarPath(data, headerOffset) {
+  const name = readTarString(data, headerOffset, 100);
+  const prefix = readTarString(data, headerOffset + 345, 155);
+  return prefix ? `${prefix}/${name}` : name;
+}
+function isZeroBlock(data, offset) {
+  for (let i = offset;i < offset + TAR_BLOCK_SIZE; i++) {
+    if (data[i] !== 0)
+      return false;
+  }
+  return true;
+}
+function parsePaxAttributes(data) {
+  const text = Buffer.from(data).toString("utf-8");
+  const attributes = {};
+  let offset = 0;
+  while (offset < text.length) {
+    const spaceIndex = text.indexOf(" ", offset);
+    if (spaceIndex === -1)
+      break;
+    const lengthText = text.slice(offset, spaceIndex);
+    const recordLength = Number.parseInt(lengthText, 10);
+    if (!Number.isFinite(recordLength) || recordLength <= 0)
+      break;
+    const record3 = text.slice(spaceIndex + 1, offset + recordLength);
+    const equalsIndex = record3.indexOf("=");
+    if (equalsIndex > 0) {
+      const key = record3.slice(0, equalsIndex);
+      const rawValue = record3.slice(equalsIndex + 1);
+      const value = rawValue.endsWith(`
+`) ? rawValue.slice(0, -1) : rawValue;
+      attributes[key] = value;
+    }
+    offset += recordLength;
+  }
+  return attributes;
+}
+function stripNpmPackageRoot(entryName) {
+  const normalized = entryName.replaceAll("\\", "/");
+  if (normalized === "package" || normalized === "package/")
+    return "";
+  if (!normalized.startsWith("package/")) {
+    throw new Error(`Unexpected tarball root entry: ${entryName}`);
+  }
+  return normalized.slice("package/".length);
+}
+function resolveTarEntryPath(fs7, destinationDir, entryName) {
+  if (entryName.includes("\x00")) {
+    throw new Error(`Invalid tar entry path: ${entryName}`);
+  }
+  if (entryName.startsWith("/")) {
+    throw new Error(`Unsafe absolute tar entry path: ${entryName}`);
+  }
+  const root = fs7.path.resolve(destinationDir);
+  const target = fs7.path.resolve(root, entryName);
+  const relative2 = fs7.path.relative(root, target);
+  if (relative2.startsWith("..") || fs7.path.isAbsolute(relative2)) {
+    throw new Error(`Unsafe tar entry path: ${entryName}`);
+  }
+  return target;
+}
+function readNullTerminatedUtf8(data) {
+  const nullIndex = data.indexOf(0);
+  const end = nullIndex >= 0 ? nullIndex : data.length;
+  return Buffer.from(data.subarray(0, end)).toString("utf-8");
+}
+function readTarEntry(tarData, headerOffset) {
+  const typeFlag = String.fromCodePoint(tarData[headerOffset + 156] || 0);
+  const size = readTarOctal(tarData, headerOffset + 124, 12);
+  const dataOffset = headerOffset + TAR_BLOCK_SIZE;
+  const dataEnd = dataOffset + size;
+  if (dataEnd > tarData.length) {
+    throw new Error("Invalid tarball: entry extends past archive end");
+  }
+  const padding = (TAR_BLOCK_SIZE - size % TAR_BLOCK_SIZE) % TAR_BLOCK_SIZE;
+  return {
+    typeFlag,
+    headerPath: readTarPath(tarData, headerOffset),
+    entryData: tarData.subarray(dataOffset, dataEnd),
+    nextOffset: dataEnd + padding
+  };
+}
+function readTarPathOverride(typeFlag, entryData) {
+  if (typeFlag === "x")
+    return parsePaxAttributes(entryData).path;
+  if (typeFlag === "L")
+    return readNullTerminatedUtf8(entryData);
+  return;
+}
+function isTarPathOverrideEntry(typeFlag) {
+  return typeFlag === "x" || typeFlag === "L";
+}
+function isTarDirectoryEntry(typeFlag, entryName) {
+  return typeFlag === "5" || entryName.endsWith("/");
+}
+function isTarRegularFileEntry(typeFlag) {
+  return typeFlag === "0" || typeFlag === "\x00";
+}
+async function extractTarEntry2(fs7, destinationDir, entryName, entry) {
+  if (isTarDirectoryEntry(entry.typeFlag, entryName)) {
+    await fs7.mkdir(resolveTarEntryPath(fs7, destinationDir, entryName));
+    return;
+  }
+  if (!isTarRegularFileEntry(entry.typeFlag)) {
+    logger.debug(`Skipping unsupported tar entry type '${entry.typeFlag}' for ${entryName}`);
+    return;
+  }
+  const target = resolveTarEntryPath(fs7, destinationDir, entryName);
+  await fs7.writeFile(target, entry.entryData);
+}
+async function extractNpmTarballToDir(tarData, destinationDir) {
+  const fs7 = getFileSystem();
+  await fs7.mkdir(destinationDir);
+  let offset = 0;
+  let nextPath;
+  while (offset + TAR_BLOCK_SIZE <= tarData.length) {
+    if (isZeroBlock(tarData, offset))
+      break;
+    const entry = readTarEntry(tarData, offset);
+    offset = entry.nextOffset;
+    if (isTarPathOverrideEntry(entry.typeFlag)) {
+      nextPath = readTarPathOverride(entry.typeFlag, entry.entryData);
+      continue;
     }
-    const nestedDir = fs7.path.join(storePath, "skills-main");
-    if (await fs7.exists(nestedDir)) {
-      const entries = await fs7.readdir(nestedDir);
-      for (const entry of entries) {
-        await fs7.rename(fs7.path.join(nestedDir, entry), fs7.path.join(storePath, entry));
-      }
-      await fs7.rm(nestedDir);
+    if (entry.typeFlag === "g") {
+      continue;
     }
-  } finally {
-    await catchError(fs7.rm(zipPath));
+    const rawPath = nextPath ?? entry.headerPath;
+    nextPath = undefined;
+    const entryName = stripNpmPackageRoot(rawPath);
+    if (!entryName)
+      continue;
+    await extractTarEntry2(fs7, destinationDir, entryName, entry);
   }
 }
-var REPO_URL = "https://github.com/UiPath/skills.git", ZIP_URL = "https://github.com/UiPath/skills/archive/refs/heads/main.zip", STORE_NAME, MANIFEST_NAME = "manifest.json";
+var SKILLS_PACKAGE_NAME = "@uipath/skills", SKILLS_REGISTRY_URL = "https://registry.npmjs.org", SKILLS_GITHUB_REGISTRY_URL = "https://npm.pkg.github.com/", REPO_URL = "https://www.npmjs.com/package/@uipath/skills", SOURCE_MARKER_NAME = ".uipath-skills-source.json", STORE_NAME, TAR_BLOCK_SIZE = 512, NPM_VIEW_TIMEOUT_MS2 = 30000, NPM_PACK_TIMEOUT_MS = 60000, SHELL_SAFE_ARG2, SHELL_SAFE_COMMAND_LINE2, childProcessModulePromise2, MANIFEST_NAME = "manifest.json";
 var init_contentStore = __esm(() => {
   init_src2();
   init_src();
   init_js_yaml();
+  init_package();
   STORE_NAME = `${UIPATH_HOME_DIR}/.skills`;
+  SHELL_SAFE_ARG2 = /^[a-zA-Z0-9@/._-]+$/;
+  SHELL_SAFE_COMMAND_LINE2 = /^[a-zA-Z0-9@/._\- ]+$/;
 });
 
 // src/commands/skills/agents/claude.ts
@@ -105453,11 +106448,13 @@ var init_claude = __esm(() => {
   init_src2();
   init_src();
   init_contentStore();
+  init_detect();
   PLUGIN_REF = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
   def2 = {
     localSubdir: [".claude", "skills"],
     globalOnly: true,
     destinationHint: () => "installed via `claude plugin install`",
+    detect: () => verifiedCommandOnPath(["claude"], /Claude Code/i),
     install: async ({ storePath, rootDir }) => {
       await removeLegacySkillCopies(storePath, rootDir);
       await runClaude(["plugin", "marketplace", "add", MARKETPLACE_SOURCE]);
@@ -105483,48 +106480,68 @@ var init_claude = __esm(() => {
 // src/commands/skills/agents/codex.ts
 var def3;
 var init_codex = __esm(() => {
+  init_detect();
   def3 = {
-    localSubdir: [".agents", "skills"]
+    localSubdir: [".agents", "skills"],
+    detect: () => verifiedCommandOnPath(["codex"], /codex[- ]?cli/i)
   };
 });
 
 // src/commands/skills/agents/copilot.ts
 var def4;
 var init_copilot = __esm(() => {
+  init_detect();
   def4 = {
-    localSubdir: [".github", "skills"]
+    localSubdir: [".github", "skills"],
+    detect: () => verifiedCommandOnPath(["copilot"], /GitHub Copilot/i)
   };
 });
 
 // src/commands/skills/agents/cursor.ts
 var def5;
 var init_cursor = __esm(() => {
+  init_detect();
   def5 = {
-    localSubdir: [".cursor", "skills"]
+    localSubdir: [".cursor", "skills"],
+    detect: () => verifiedCommandOnPath(["cursor-agent", "agent"], /cursor/i, ["--help"])
   };
 });
 
 // src/commands/skills/agents/gemini.ts
 var def6;
 var init_gemini = __esm(() => {
+  init_detect();
   def6 = {
-    localSubdir: [".gemini", "skills"]
+    localSubdir: [".gemini", "skills"],
+    detect: () => verifiedCommandOnPath(["gemini"], /Gemini CLI/i, ["--help"])
   };
 });
 
-// src/commands/skills/agents/opencode.ts
+// src/commands/skills/agents/kiro.ts
 var def7;
-var init_opencode = __esm(() => {
+var init_kiro = __esm(() => {
+  init_detect();
   def7 = {
+    localSubdir: [".kiro", "skills"],
+    detect: () => homePathExists(".kiro")
+  };
+});
+
+// src/commands/skills/agents/opencode.ts
+var def8;
+var init_opencode = __esm(() => {
+  init_detect();
+  def8 = {
     localSubdir: [".opencode", "skills"],
-    globalSubdir: [".config", "opencode", "skills"]
+    globalSubdir: [".config", "opencode", "skills"],
+    detect: () => verifiedCommandOnPath(["opencode"], /opencode/i, ["--help"])
   };
 });
 
 // src/commands/skills/agents/index.ts
 function subdirFor(agent, isLocal) {
-  const def8 = AGENT_DEFS[agent];
-  return isLocal ? def8.localSubdir : def8.globalSubdir ?? def8.localSubdir;
+  const def9 = AGENT_DEFS[agent];
+  return isLocal ? def9.localSubdir : def9.globalSubdir ?? def9.localSubdir;
 }
 function getSkillsDir(agent, rootDir, isLocal) {
   const fs7 = getFileSystem();
@@ -105575,6 +106592,7 @@ var init_agents = __esm(() => {
   init_copilot();
   init_cursor();
   init_gemini();
+  init_kiro();
   init_opencode();
   AGENT_DEFS = {
     claude: def2,
@@ -105582,13 +106600,14 @@ var init_agents = __esm(() => {
     copilot: def4,
     gemini: def6,
     codex: def3,
-    opencode: def7,
-    autopilot: def
+    opencode: def8,
+    autopilot: def,
+    kiro: def7
   };
 });
 
 // src/commands/skills/skillCatalog.ts
-function asRecord(value) {
+function asRecord2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return;
   }
@@ -105628,7 +106647,7 @@ async function readSkillMetadata(skill) {
   } : parseSkillMd(content);
   const name = typeof parsed.meta.name === "string" && parsed.meta.name.trim() ? parsed.meta.name.trim() : skill.name;
   const description = typeof parsed.meta.description === "string" ? parsed.meta.description.trim() : skill.description ?? "";
-  const metadata = asRecord(parsed.meta.metadata);
+  const metadata = asRecord2(parsed.meta.metadata);
   return {
     name,
     description,
@@ -105885,7 +106904,7 @@ async function loadCatalogOrReport(options) {
     OutputFormatter.error({
       Result: RESULTS.Failure,
       Message: `Failed to load skills catalog: ${error51.message}`,
-      Instructions: "Check network connectivity and try again. Ensure git is installed. For zip-based installs, make sure PowerShell (on Windows) or the 'unzip' command (on macOS/Linux) is available."
+      Instructions: "Check network connectivity and try again. Ensure the @uipath/skills package is available from the configured npm registry."
     });
     processContext.exit(1);
     return null;
@@ -106054,7 +107073,8 @@ var init_prompt = __esm(() => {
     "gemini",
     "codex",
     "opencode",
-    "autopilot"
+    "autopilot",
+    "kiro"
   ];
   AGENT_DISPLAY_NAMES = {
     claude: "Claude Code (Plugin)",
@@ -106063,7 +107083,8 @@ var init_prompt = __esm(() => {
     gemini: "Gemini CLI",
     codex: "Codex",
     opencode: "OpenCode",
-    autopilot: "UiPath Autopilot"
+    autopilot: "UiPath Autopilot",
+    kiro: "Kiro (Amazon Q)"
   };
 });
 
@@ -106086,7 +107107,7 @@ async function resolveSkillsContext(options, operation) {
     OutputFormatter.error({
       Result: RESULTS.ConfigError,
       Message: "No skills found in content store.",
-      Instructions: "Check that the skills repository contains skills in the skills/ directory."
+      Instructions: "Check that the @uipath/skills package contains skills in the skills/ directory."
     });
     return null;
   }
@@ -106105,17 +107126,42 @@ async function resolveSkillsContext(options, operation) {
       return null;
     agents = [agent];
   } else {
-    const [agentErr, selected] = await catchError(promptAgentSelection(operation, isLocal));
-    if (agentErr)
-      handlePromptCancellation(agentErr, operation);
-    agents = selected;
+    const detected = await detectInstalledAgents(isLocal);
+    if (detected.length > 0) {
+      logger.info(`Detected installed agents: ${detected.join(", ")}. ` + "Installing skills for all of them. Pass --agent to target one.");
+      agents = detected;
+    } else if (!canPrompt()) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "No agents detected and prompting is disabled.",
+        Instructions: `No supported agent was found on PATH. Pass --agent <agent> (one of: ${ALL_AGENTS.join(", ")}), or re-run with --interactive to select.`
+      });
+      processContext.exit(1);
+      return null;
+    } else {
+      const [agentErr, selected] = await catchError(promptAgentSelection(operation, isLocal));
+      if (agentErr)
+        handlePromptCancellation(agentErr, operation);
+      agents = selected;
+    }
   }
   return { rootDir, storePath, selectedSkills, agents, isLocal };
 }
+async function detectInstalledAgents(isLocal) {
+  const candidates = ALL_AGENTS.filter((a) => !(isLocal && AGENT_DEFS[a].globalOnly));
+  const results = await Promise.all(candidates.map(async (a) => {
+    const detect = AGENT_DEFS[a].detect;
+    if (!detect)
+      return null;
+    const [, found] = await catchError(detect());
+    return found ? a : null;
+  }));
+  return results.filter((a) => a !== null);
+}
 async function runOneAgent(agent, operation, resolved) {
   const { rootDir, storePath, selectedSkills, isLocal } = resolved;
-  const def8 = AGENT_DEFS[agent];
-  const customHook = operation === "update" ? def8.update ?? def8.install : def8.install;
+  const def9 = AGENT_DEFS[agent];
+  const customHook = operation === "update" ? def9.update ?? def9.install : def9.install;
   if (customHook) {
     const [installError] = await catchError(customHook({ skills: selectedSkills, rootDir, storePath, isLocal }));
     if (installError) {
@@ -106219,7 +107265,7 @@ var init_skillsService = __esm(() => {
 
 // src/commands/skills/install.ts
 function registerInstallCommand(skillsCommand) {
-  skillsCommand.command("install").description("Download skills from UiPath and install them for your coding agents.").option("--agent <agent>", `Target agent: ${ALL_AGENTS.join(", ")}`).option("--local", "Install to current project instead of globally").examples(SKILLS_INSTALL_EXAMPLES).trackedAction(processContext, async (options) => {
+  skillsCommand.command("install").description("Download UiPath skills from the configured npm registry and install them for your coding agents.").option("--agent <agent>", `Target agent: ${ALL_AGENTS.join(", ")}`).option("--local", "Install to current project instead of globally").examples(SKILLS_INSTALL_EXAMPLES).trackedAction(processContext, async (options) => {
     const [contextError, resolved] = await catchError(resolveSkillsContext(options, "install"));
     if (contextError || !resolved) {
       if (contextError) {
@@ -106230,7 +107276,7 @@ function registerInstallCommand(skillsCommand) {
         OutputFormatter.error({
           Result: RESULTS.Failure,
           Message: `Failed to install skills: ${contextError.message}`,
-          Instructions: "Check network connectivity and try again. Ensure git is installed. For zip-based installs, make sure PowerShell (on Windows) or the 'unzip' command (on macOS/Linux) is available."
+          Instructions: "Check network connectivity and try again. Ensure the @uipath/skills package is available from the configured npm registry."
         });
       }
       return;
@@ -106280,103 +107326,129 @@ var init_install2 = __esm(() => {
 });
 
 // src/commands/skills/uninstall.ts
+async function resolveAgents(options, isLocal) {
+  if (options.agent) {
+    const agent = options.agent.trim().toLowerCase();
+    if (!ALL_AGENTS.includes(agent)) {
+      OutputFormatter.error({
+        Result: RESULTS.ValidationError,
+        Message: `Unknown agent: ${agent}`,
+        Instructions: `Available agents: ${ALL_AGENTS.join(", ")}`
+      });
+      return HANDLED;
+    }
+    if (rejectIfGlobalOnly(agent, isLocal, "uninstall"))
+      return HANDLED;
+    return [agent];
+  }
+  if (!canPrompt()) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: "No agent specified and prompting is disabled.",
+      Instructions: `Pass --agent <agent> (one of: ${ALL_AGENTS.join(", ")}), or re-run with --interactive to select.`
+    });
+    processContext.exit(1);
+    return HANDLED;
+  }
+  const [agentErr, selected] = await catchError(promptAgentSelection("uninstall", isLocal));
+  if (agentErr) {
+    if (agentErr instanceof Error && agentErr.name === "ExitPromptError") {
+      processContext.exit(130);
+      return HANDLED;
+    }
+    throw agentErr;
+  }
+  return selected;
+}
+async function readSkillNames(storePath) {
+  const [manifestErr, manifest] = await catchError(readManifest(storePath));
+  if (manifestErr || !manifest) {
+    OutputFormatter.error({
+      Result: RESULTS.ConfigError,
+      Message: `Failed to read manifest: ${manifestErr?.message ?? "unknown error"}`,
+      Instructions: "The manifest file may be missing or corrupted. Try reinstalling with 'uipath skills install'."
+    });
+    return HANDLED;
+  }
+  const skillNames = Object.keys(manifest.skills);
+  if (skillNames.length === 0) {
+    OutputFormatter.error({
+      Result: RESULTS.ConfigError,
+      Message: "No skills found to uninstall.",
+      Instructions: "No skills are currently installed. Use 'uipath skills install' to install them first."
+    });
+    return HANDLED;
+  }
+  return skillNames;
+}
+async function uninstallForAgent(targetAgent, ctx, uninstalled) {
+  const { skillNames, rootDir, storePath, isLocal } = ctx;
+  const def9 = AGENT_DEFS[targetAgent];
+  if (def9.uninstall) {
+    const [err] = await catchError(def9.uninstall({ skillNames, rootDir, storePath, isLocal }));
+    if (err) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Failed to uninstall skills for ${targetAgent}: ${err.message}`,
+        Instructions: "Check that the agent's CLI is installed and on PATH, and that you have permission to modify its configuration."
+      });
+      processContext.exit(1);
+      return HANDLED;
+    }
+    for (const name of skillNames) {
+      uninstalled.push(`${targetAgent}:${name}`);
+    }
+    return;
+  }
+  const skillsDir = getSkillsDir(targetAgent, rootDir, isLocal);
+  for (const name of skillNames) {
+    const [uninstallError] = await catchError(uninstallSkill(name, skillsDir));
+    if (uninstallError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Failed to uninstall ${name} for ${targetAgent}: ${uninstallError.message}`,
+        Instructions: "Check that the skill files exist and you have write permissions."
+      });
+      return HANDLED;
+    }
+    uninstalled.push(`${targetAgent}:${name}`);
+  }
+  const [catalogError] = await catchError(removeSkillCatalog(skillsDir));
+  if (catalogError) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: `Failed to remove skill catalog for ${targetAgent}: ${catalogError.message}`,
+      Instructions: "Check that the skill destination is writable and try again."
+    });
+    processContext.exit(1);
+    return HANDLED;
+  }
+  return;
+}
 function registerUninstallCommand(skillsCommand) {
   skillsCommand.command("uninstall").description("Remove previously installed skills from agent configurations.").option("--agent <agent>", `Target agent: ${ALL_AGENTS.join(", ")}`).option("--local", "Uninstall from current project instead of globally").examples(SKILLS_UNINSTALL_EXAMPLES).trackedAction(processContext, async (options) => {
     const isLocal = !!options.local;
     const fs7 = getFileSystem();
     const rootDir = isLocal ? fs7.env.cwd() : fs7.env.homedir();
     const storePath = fs7.path.join(rootDir, STORE_NAME);
-    let agents;
-    if (options.agent) {
-      const agent = options.agent.trim().toLowerCase();
-      if (!ALL_AGENTS.includes(agent)) {
-        OutputFormatter.error({
-          Result: RESULTS.ValidationError,
-          Message: `Unknown agent: ${agent}`,
-          Instructions: `Available agents: ${ALL_AGENTS.join(", ")}`
-        });
-        return;
-      }
-      if (rejectIfGlobalOnly(agent, isLocal, "uninstall"))
-        return;
-      agents = [agent];
-    } else {
-      const [agentErr, selected] = await catchError(promptAgentSelection("uninstall", isLocal));
-      if (agentErr) {
-        if (agentErr instanceof Error && agentErr.name === "ExitPromptError") {
-          processContext.exit(130);
-          return;
-        }
-        throw agentErr;
-      }
-      agents = selected;
-    }
-    const [manifestErr, manifest] = await catchError(readManifest(storePath));
-    if (manifestErr || !manifest) {
-      OutputFormatter.error({
-        Result: RESULTS.ConfigError,
-        Message: `Failed to read manifest: ${manifestErr?.message ?? "unknown error"}`,
-        Instructions: "The manifest file may be missing or corrupted. Try reinstalling with 'uipath skills install'."
-      });
+    const agents = await resolveAgents(options, isLocal);
+    if (agents === HANDLED)
       return;
-    }
-    const skillNames = Object.keys(manifest.skills);
-    if (skillNames.length === 0) {
-      OutputFormatter.error({
-        Result: RESULTS.ConfigError,
-        Message: "No skills found to uninstall.",
-        Instructions: "No skills are currently installed. Use 'uipath skills install' to install them first."
-      });
+    const skillNames = await readSkillNames(storePath);
+    if (skillNames === HANDLED)
       return;
-    }
     logger.info(`Uninstalling ${skillNames.length} skill(s) for ${agents.join(", ")}`);
     const uninstalled = [];
+    const ctx = {
+      skillNames,
+      rootDir,
+      storePath,
+      isLocal
+    };
     for (const targetAgent of agents) {
-      const def8 = AGENT_DEFS[targetAgent];
-      if (def8.uninstall) {
-        const [err] = await catchError(def8.uninstall({
-          skillNames,
-          rootDir,
-          storePath,
-          isLocal
-        }));
-        if (err) {
-          OutputFormatter.error({
-            Result: RESULTS.Failure,
-            Message: `Failed to uninstall skills for ${targetAgent}: ${err.message}`,
-            Instructions: "Check that the agent's CLI is installed and on PATH, and that you have permission to modify its configuration."
-          });
-          processContext.exit(1);
-          return;
-        }
-        for (const name of skillNames) {
-          uninstalled.push(`${targetAgent}:${name}`);
-        }
-        continue;
-      }
-      const skillsDir = getSkillsDir(targetAgent, rootDir, isLocal);
-      for (const name of skillNames) {
-        const [uninstallError] = await catchError(uninstallSkill(name, skillsDir));
-        if (uninstallError) {
-          OutputFormatter.error({
-            Result: RESULTS.Failure,
-            Message: `Failed to uninstall ${name} for ${targetAgent}: ${uninstallError.message}`,
-            Instructions: "Check that the skill files exist and you have write permissions."
-          });
-          return;
-        }
-        uninstalled.push(`${targetAgent}:${name}`);
-      }
-      const [catalogError] = await catchError(removeSkillCatalog(skillsDir));
-      if (catalogError) {
-        OutputFormatter.error({
-          Result: RESULTS.Failure,
-          Message: `Failed to remove skill catalog for ${targetAgent}: ${catalogError.message}`,
-          Instructions: "Check that the skill destination is writable and try again."
-        });
-        processContext.exit(1);
+      const result = await uninstallForAgent(targetAgent, ctx, uninstalled);
+      if (result === HANDLED)
         return;
-      }
     }
     const [manifestUpdateErr] = await catchError(removeFromManifest(storePath, skillNames, agents));
     if (manifestUpdateErr) {
@@ -106399,7 +107471,7 @@ function registerUninstallCommand(skillsCommand) {
     });
   });
 }
-var SKILLS_UNINSTALL_EXAMPLES;
+var SKILLS_UNINSTALL_EXAMPLES, HANDLED;
 var init_uninstall = __esm(() => {
   init_src2();
   init_src();
@@ -106422,10 +107494,11 @@ var init_uninstall = __esm(() => {
       }
     }
   ];
+  HANDLED = Symbol("handled");
 });
 
 // src/services/updateService.skills.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 async function runSkillsUpdate(opts) {
   const fs7 = getFileSystem();
   if (opts.agent !== undefined) {
@@ -106479,7 +107552,7 @@ async function runSkillsUpdate(opts) {
         error: {
           result: skillsErr?.result ?? "Failure",
           message: sectionErr.message,
-          instructions: skillsErr?.instructions ?? "Check network connectivity and try again. Ensure git is installed."
+          instructions: skillsErr?.instructions ?? "Check network connectivity and try again. Ensure the @uipath/skills package is available from the configured npm registry."
         }
       });
       continue;
@@ -106516,7 +107589,7 @@ async function updateOneSection(opts, candidate) {
     }
   }
   if (opts.dryRun) {
-    const tmpRoot = fs7.path.join(fs7.env.tmpdir(), `uipath-skills-dryrun-${randomUUID5()}`);
+    const tmpRoot = fs7.path.join(fs7.env.tmpdir(), `uipath-skills-dryrun-${randomUUID6()}`);
     try {
       await fs7.mkdir(tmpRoot);
       const tmpStore = fs7.path.join(tmpRoot, "store");
@@ -106570,7 +107643,7 @@ var init_updateService_skills = __esm(() => {
 
 // src/commands/skills/update.ts
 function registerUpdateCommand(skillsCommand) {
-  skillsCommand.command("update").description("Re-fetch skills from UiPath and reinstall to get the latest versions.").option("--agent <agent>", `Target agent: ${ALL_AGENTS.join(", ")}`).option("--local", "Update in current project instead of globally").examples(SKILLS_UPDATE_EXAMPLES).trackedAction(processContext, async (options) => {
+  skillsCommand.command("update").description("Re-fetch UiPath skills from the configured npm registry and reinstall the latest patch matching this CLI version line.").option("--agent <agent>", `Target agent: ${ALL_AGENTS.join(", ")}`).option("--local", "Update in current project instead of globally").examples(SKILLS_UPDATE_EXAMPLES).trackedAction(processContext, async (options) => {
     const local = options.local === true;
     const [err, report] = await catchError(runSkillsUpdate({
       dryRun: false,
@@ -106581,7 +107654,7 @@ function registerUpdateCommand(skillsCommand) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
         Message: `Failed to update skills: ${err.message}`,
-        Instructions: "Check network connectivity and try again. Ensure git is installed. On Windows, ensure PowerShell is available. On macOS/Linux, ensure the 'unzip' utility is installed."
+        Instructions: "Check network connectivity and try again. Ensure the @uipath/skills package is available from the configured npm registry."
       });
       processContext.exit(EXIT_CODES.Failure);
       return;
@@ -106624,7 +107697,7 @@ var init_update = __esm(() => {
   init_prompt();
   SKILLS_UPDATE_EXAMPLES = [
     {
-      Description: "Update skills for Claude Code to the latest versions",
+      Description: "Update skills for Claude Code to the latest matching CLI version line",
       Command: "uip skills update --agent claude",
       Output: {
         Code: "SkillsUpdate",
@@ -106665,8 +107738,8 @@ function registerSkillsCommand(program2) {
   const skillsCommand = program2.command("skills").description(`Install and manage UiPath skills for AI coding agents.
 
 ` + `Skills teach AI coding agents how to build UiPath automations, agents,
-` + `RPA workflows, flows, and orchestrations. They are fetched from the UiPath
-` + `skills repository on GitHub and installed for each agent.
+` + `RPA workflows, flows, and orchestrations. They are fetched from the
+` + `@uipath/skills npm package and installed for each agent.
 ` + getAgentsTable());
   registerCatalogCommands(skillsCommand);
   registerInstallCommand(skillsCommand);
@@ -106682,31 +107755,6 @@ var init_skills = __esm(() => {
   init_update();
 });
 
-// src/services/channel.ts
-function resolveChannel(cliVersion = package_default.version) {
-  const fileChannel = getCachedConfig().core?.updateChannel;
-  if (fileChannel && VALID_CHANNELS.has(fileChannel)) {
-    return fileChannel;
-  }
-  const prerelease = parsePrereleaseTag(cliVersion);
-  if (prerelease && VALID_CHANNELS.has(prerelease)) {
-    return prerelease;
-  }
-  return "stable";
-}
-function parsePrereleaseTag(version2) {
-  const dashIdx = version2.indexOf("-");
-  if (dashIdx === -1)
-    return;
-  return version2.slice(dashIdx + 1).split(".")[0];
-}
-var VALID_CHANNELS;
-var init_channel = __esm(() => {
-  init_package();
-  init_loadConfig();
-  VALID_CHANNELS = new Set(["alpha", "beta", "stable"]);
-});
-
 // src/commands/tools/install.ts
 function registerInstallCommand2(toolsCommand, _context, state) {
   const { resolveInstallPath, getCliVersionPrefix: getCliVersionPrefix2 } = state;
@@ -106732,21 +107780,21 @@ function registerInstallCommand2(toolsCommand, _context, state) {
     const [error51] = await catchError((async () => {
       const location = await resolveInstallPath(packageName);
       let packageSpec;
+      let registry3;
       if (explicitVersion) {
         packageSpec = `${packageName}@${explicitVersion}`;
       } else {
-        packageSpec = packageName;
         const cliPrefix = getCliVersionPrefix2();
-        const version2 = await toolService.searchLatestVersion(packageName, cliPrefix, {
-          channel: resolveChannel(),
-          allowLowerFallback: true
-        });
-        if (version2) {
-          packageSpec = `${packageName}@${version2}`;
+        const candidate = await toolService.resolveInstallCandidate(packageName, cliPrefix);
+        if (!candidate) {
+          throw new Error(`No compatible version of '${packageName}' found for the CLI's ${cliPrefix}x line on npm or GitHub Packages.`);
         }
+        packageSpec = `${packageName}@${candidate.version}`;
+        registry3 = candidate.registry;
       }
       await toolService.install(packageSpec, location.path, {
-        global: location.global
+        global: location.global,
+        registry: registry3
       });
       logger.info(`Installed to ${location.path}`);
       OutputFormatter.success({
@@ -106770,7 +107818,6 @@ function registerInstallCommand2(toolsCommand, _context, state) {
 var TOOLS_INSTALL_EXAMPLES;
 var init_install3 = __esm(() => {
   init_src2();
-  init_channel();
   init_toolService();
   TOOLS_INSTALL_EXAMPLES = [
     {
@@ -109950,31 +110997,31 @@ class StdinDiscarder {
     }
   }
   #realStart() {
-    const { stdin } = process20;
-    if (process20.platform === "win32" || !stdin?.isTTY || typeof stdin.setRawMode !== "function") {
+    const { stdin: stdin2 } = process20;
+    if (process20.platform === "win32" || !stdin2?.isTTY || typeof stdin2.setRawMode !== "function") {
       this.#stdin = undefined;
       return;
     }
-    this.#stdin = stdin;
-    this.#stdinWasPaused = stdin.isPaused();
-    this.#stdinWasRaw = Boolean(stdin.isRaw);
-    stdin.setRawMode(true);
-    stdin.prependListener("data", this.#handleInputBound);
+    this.#stdin = stdin2;
+    this.#stdinWasPaused = stdin2.isPaused();
+    this.#stdinWasRaw = Boolean(stdin2.isRaw);
+    stdin2.setRawMode(true);
+    stdin2.prependListener("data", this.#handleInputBound);
     if (this.#stdinWasPaused) {
-      stdin.resume();
+      stdin2.resume();
     }
   }
   #realStop() {
     if (!this.#stdin) {
       return;
     }
-    const stdin = this.#stdin;
-    stdin.off("data", this.#handleInputBound);
-    if (stdin.isTTY) {
-      stdin.setRawMode?.(this.#stdinWasRaw);
+    const stdin2 = this.#stdin;
+    stdin2.off("data", this.#handleInputBound);
+    if (stdin2.isTTY) {
+      stdin2.setRawMode?.(this.#stdinWasRaw);
     }
     if (this.#stdinWasPaused) {
-      stdin.pause();
+      stdin2.pause();
     }
     this.#stdin = undefined;
     this.#stdinWasPaused = false;
@@ -110455,6 +111502,31 @@ var init_ora = __esm(() => {
   validColors = new Set(["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray"]);
 });
 
+// src/services/channel.ts
+function resolveChannel(cliVersion = package_default.version) {
+  const fileChannel = getCachedConfig().core?.updateChannel;
+  if (fileChannel && VALID_CHANNELS.has(fileChannel)) {
+    return fileChannel;
+  }
+  const prerelease = parsePrereleaseTag(cliVersion);
+  if (prerelease && VALID_CHANNELS.has(prerelease)) {
+    return prerelease;
+  }
+  return "stable";
+}
+function parsePrereleaseTag(version2) {
+  const dashIdx = version2.indexOf("-");
+  if (dashIdx === -1)
+    return;
+  return version2.slice(dashIdx + 1).split(".")[0];
+}
+var init_channel = __esm(() => {
+  init_package();
+  init_loadConfig();
+  init_channels();
+  init_channels();
+});
+
 // src/services/updateService.tools.ts
 async function runToolsUpdate(opts, state) {
   const installed = getInstalledTools(state);
@@ -110529,7 +111601,6 @@ async function runToolsUpdate(opts, state) {
         const exact = pin && isExactPin(pin) ? formatVersionPin(pin) : undefined;
         const latest = await toolService.searchLatestVersion(fullName, prefix, {
           channel: opts.channel,
-          allowLowerFallback: pin === null,
           exact
         });
         if (latest) {
@@ -110539,7 +111610,7 @@ async function runToolsUpdate(opts, state) {
             name: tool.name,
             status: "failed",
             from: tool.version,
-            error: pin ? `No version found matching pinned ${formatVersionPin(pin)} in the ${prefix}x line` : `No compatible ${opts.channel} version found for CLI v${prefix}x or lower`
+            error: pin ? `No version found matching pinned ${formatVersionPin(pin)} in the ${prefix}x line` : `No compatible ${opts.channel} version found in the CLI's v${prefix}x line`
           });
           return;
         }
@@ -110790,22 +111861,23 @@ function detectCliInstallContext(execPath) {
     return { kind: "npm" };
   return { kind: "unknown" };
 }
-function describeUpdateCommand(target, ctx) {
+function describeUpdateCommand(target, ctx, global6 = true) {
   switch (ctx.kind) {
     case "brew":
       return `brew upgrade ${ctx.formula}`;
     case "npm":
+      return global6 ? `npm install -g ${target}` : `npm install ${target}`;
     case "unknown":
       return `npm install -g ${target}`;
   }
 }
-async function runCliSelfUpdate(target, ctx, installPath) {
+async function runCliSelfUpdate(target, ctx, installPath, global6) {
   switch (ctx.kind) {
     case "brew":
       await spawnBrewUpgrade(ctx.formula);
       return;
     case "npm":
-      await toolService.install(target, installPath, { global: true });
+      await toolService.install(target, installPath, { global: global6 });
       return;
   }
 }
@@ -110856,16 +111928,12 @@ async function checkCliVersion(opts) {
   if (opts.isDev) {
     return skipped(opts.cliPkgVersion, "dev mode");
   }
-  if (opts.isLocal) {
-    return skipped(opts.cliPkgVersion, "local install");
-  }
   const pin = opts.pin ?? null;
   const [err, latest] = await catchError(pin ? toolService.searchLatestVersion("@uipath/cli", pinnedPrefix(pin), {
     channel: opts.channel,
-    allowLowerFallback: false,
     exact: isExactPin(pin) ? formatVersionPin(pin) : undefined,
     timeoutMs: CLI_VERSION_PROBE_TIMEOUT_MS
-  }) : toolService.searchLatestVersion("@uipath/cli", undefined, {
+  }) : toolService.searchLatestVersion("@uipath/cli", majorMinorPrefix(opts.cliPkgVersion), {
     channel: opts.channel,
     timeoutMs: CLI_VERSION_PROBE_TIMEOUT_MS
   }));
@@ -110903,6 +111971,13 @@ async function checkCliVersion(opts) {
 function skipped(current, reason) {
   return { current, available: null, action: "skipped", reason };
 }
+function majorMinorPrefix(version2) {
+  const core2 = version2.split("-")[0];
+  const [major, minor] = core2.split(".");
+  if (!major || !minor)
+    return;
+  return `${major}.${minor}.`;
+}
 var CLI_VERSION_PROBE_TIMEOUT_MS = 8000;
 var init_updateService_cli = __esm(() => {
   init_src2();
@@ -110911,6 +111986,10 @@ var init_updateService_cli = __esm(() => {
 });
 
 // src/services/updateService.ts
+var exports_updateService = {};
+__export(exports_updateService, {
+  runUpdate: () => runUpdate
+});
 async function runUpdate(options, state, cliEnv) {
   const { sections, channel, dryRun } = options;
   const errors7 = [];
@@ -110965,7 +112044,6 @@ async function runUpdate(options, state, cliEnv) {
   let cliReport = sections.cli ? await checkCliVersion({
     channel,
     cliPkgVersion: cliEnv.cliPkgVersion,
-    isLocal: cliEnv.isLocal,
     isDev: cliEnv.isDev,
     pin: options.versionPin ?? null
   }) : null;
@@ -110980,8 +112058,9 @@ async function runUpdate(options, state, cliEnv) {
         logger.info(`Downgrading @uipath/cli ${noticeReport.current} → ${available} to match the pinned version.`);
       }
       const target = `@uipath/cli@${available}`;
-      const manualCommand = describeUpdateCommand(target, installCtx);
-      const [installErr] = await catchError(runCliSelfUpdate(target, installCtx, cliEnv.installPath));
+      const global6 = !cliEnv.isLocal;
+      const manualCommand = describeUpdateCommand(target, installCtx, global6);
+      const [installErr] = await catchError(runCliSelfUpdate(target, installCtx, cliEnv.installPath, global6));
       if (installErr) {
         const isWindows = process.platform === "win32";
         const instructions = isPermissionError(installErr) ? isWindows ? "Re-run from an elevated terminal (right-click → Run as administrator): uip update" : "Re-run with elevated permissions, e.g. sudo uip update" : `Run manually: ${manualCommand}`;
@@ -111041,7 +112120,7 @@ var init_updateService = __esm(() => {
 
 // src/commands/update.ts
 function registerUpdateCommand3(program2, _context, state) {
-  program2.command("update").description("Update installed UiPath tools and skills, and check for newer CLI").option("--dry-run", "Preview changes without applying them", false).option("--tools-only", "Skip skills section", false).option("--skills-only", "Skip tools section", false).option("--no-tools", "Do not update tools").option("--no-skills", "Do not update skills").option("--no-cli-check", "Do not probe for newer CLI version").option("--no-self", "Do not auto-update the CLI itself; only print a notice").option("--channel <channel>", "Override channel: stable | alpha | beta").option("--name <scoped-tool-name>", "Restrict tool update to one tool").option("--agent <agent>", "Restrict skill update to one agent").option("--local", "Restrict skills update to local scope only").option("--no-local", "Restrict skills update to global scope only").examples(UPDATE_EXAMPLES).trackedAction(processContext, async (raw) => {
+  program2.command("update").description("Update installed UiPath tools and skills, and check for newer CLI").option("--dry-run", "Preview changes without applying them", false).option("--tools-only", "Skip skills section", false).option("--skills-only", "Skip tools section", false).option("--no-tools", "Do not update tools").option("--no-skills", "Do not update skills").option("--no-cli-check", "Do not probe for newer CLI version").option("--no-self", "Do not auto-update the CLI itself; only print a notice").option("--channel <channel>", `Override channel: ${CHANNELS.join(" | ")}`).option("--name <scoped-tool-name>", "Restrict tool update to one tool").option("--agent <agent>", "Restrict skill update to one agent").option("--local", "Restrict skills update to local scope only").option("--no-local", "Restrict skills update to global scope only").examples(UPDATE_EXAMPLES).trackedAction(processContext, async (raw) => {
     if (raw.toolsOnly && raw.skillsOnly) {
       OutputFormatter.error({
         Result: RESULTS.ValidationError,
@@ -111075,7 +112154,7 @@ function registerUpdateCommand3(program2, _context, state) {
       OutputFormatter.error({
         Result: RESULTS.ValidationError,
         Message: `Invalid --channel value: ${raw.channel}`,
-        Instructions: "Valid values: stable, alpha, beta."
+        Instructions: `Valid values: ${CHANNELS.join(", ")}.`
       });
       processContext.exit(EXIT_CODES.ValidationError);
       return;
@@ -111136,11 +112215,11 @@ function registerUpdateCommand3(program2, _context, state) {
 function resolveChannelFlag(flag) {
   if (!flag)
     return resolveChannel();
-  if (!VALID_CHANNELS2.has(flag))
+  if (!VALID_CHANNELS.has(flag))
     return null;
   return flag;
 }
-var VALID_CHANNELS2, UPDATE_EXAMPLES;
+var UPDATE_EXAMPLES;
 var init_update3 = __esm(() => {
   init_src2();
   init_package();
@@ -111149,11 +112228,6 @@ var init_update3 = __esm(() => {
   init_toolService();
   init_updateService();
   init_versionPin();
-  VALID_CHANNELS2 = new Set([
-    "stable",
-    "alpha",
-    "beta"
-  ]);
   UPDATE_EXAMPLES = [
     {
       Description: "Update everything that is installed (CLI auto-updates)",
@@ -111245,6 +112319,27 @@ var init_update3 = __esm(() => {
           HasFailures: false
         }
       }
+    },
+    {
+      Description: "Update on the preview channel",
+      Command: "uip update --channel preview",
+      Output: {
+        Code: "UpdateResult",
+        Data: {
+          DryRun: false,
+          Channel: "preview",
+          Cli: {
+            current: "1.4.3",
+            available: "1.4.3",
+            action: "none",
+            reason: null
+          },
+          Tools: [],
+          Skills: { Sections: [] },
+          Errors: [],
+          HasFailures: false
+        }
+      }
     }
   ];
 });
@@ -111425,16 +112520,16 @@ class ToolManager {
       throw new Error(`Unknown tool verb '${verb}'.`);
     }
     logger.info(`Tool '${verb}' is not installed. Searching for compatible version...`);
-    const channel = resolveChannel();
-    const version2 = await toolService.searchLatestVersion(packageName, this.cliVersionPrefix, { allowLowerFallback: true, channel });
-    if (!version2) {
-      throw new Error(`No compatible ${channel} version of '${packageName}' found for CLI (needs ${this.cliVersionPrefix}x or lower).`);
+    const candidate = await toolService.resolveInstallCandidate(packageName, this.cliVersionPrefix);
+    if (!candidate) {
+      throw new Error(`No compatible version of '${packageName}' found for the CLI's ${this.cliVersionPrefix}x line on npm or GitHub Packages.`);
     }
-    const packageSpec = `${packageName}@${version2}`;
+    const packageSpec = `${packageName}@${candidate.version}`;
     const location = await this.resolveInstallPath();
-    logger.debug(`Installing ${packageSpec} to ${location.path} (global: ${location.global})`);
+    logger.debug(`Installing ${packageSpec} from ${candidate.registry} to ${location.path} (global: ${location.global})`);
     await toolService.install(packageSpec, location.path, {
-      global: location.global
+      global: location.global,
+      registry: candidate.registry
     });
     logger.info(`Installed ${packageSpec} successfully.`);
     logger.debug(`Re-discovering tools in [${this.toolsDirs.join(", ")}]...`);
@@ -111446,8 +112541,331 @@ class ToolManager {
 var init_tool_manager = __esm(() => {
   init_src2();
   init_toolLoader();
+  init_toolService();
+});
+
+// src/services/versionSync.ts
+async function maybeRunDailyVersionSync(context, state) {
+  const [err, reexeced] = await catchError(runSync(context, state, { reexec: true, fromLogin: false }));
+  if (err) {
+    logger.debug(`Version sync skipped due to error: ${err.message}`);
+    return false;
+  }
+  return reexeced;
+}
+async function runPostLoginVersionSync(context, state) {
+  const verb = extractVerb(context.args);
+  if (verb !== "login") {
+    logger.debug(`Post-login sync: not a login command (verb=${verb})`);
+    return;
+  }
+  if (process.exitCode) {
+    logger.debug(`Post-login sync: login failed (exitCode=${String(process.exitCode)}); skipping`);
+    return;
+  }
+  logger.debug("Post-login sync: login succeeded — checking env alignment");
+  const [err] = await catchError(runSync(context, state, { reexec: false, fromLogin: true }));
+  if (err) {
+    logger.debug(`Post-login version sync skipped: ${err.message}`);
+  }
+}
+async function runSync(context, state, opts) {
+  const trigger = opts.fromLogin ? "post-login" : "startup";
+  logger.debug(`Version sync evaluating (trigger=${trigger})`);
+  if (context.capabilities.isBrowser) {
+    logger.debug("Version sync skipped: browser environment");
+    return false;
+  }
+  if (process.env[REEXEC_GUARD_ENV]) {
+    logger.debug("Version sync skipped: re-exec child");
+    return false;
+  }
+  if (isTruthyEnv(process.env[DISABLE_ENV])) {
+    logger.debug(`Version sync skipped: ${DISABLE_ENV} is set`);
+    return false;
+  }
+  if (getCachedConfig().core?.autoVersionSync === "false") {
+    logger.debug("Version sync skipped: core.autoVersionSync=false");
+    return false;
+  }
+  if (!opts.fromLogin) {
+    const args = context.args;
+    if (args.some((a) => VERSION_HELP_FLAGS.has(a))) {
+      logger.debug("Version sync skipped: --version/--help");
+      return false;
+    }
+    const verb = extractVerb(args);
+    if (!verb || SKIP_VERBS.has(verb)) {
+      logger.debug(`Version sync skipped: command '${verb}' is exempt`);
+      return false;
+    }
+  }
+  if (isEnvAuthEnabled()) {
+    logger.debug("Version sync skipped: env-var auth (CI/headless)");
+    return false;
+  }
+  if (await isDevMode()) {
+    logger.debug("Version sync skipped: dev mode (monorepo checkout)");
+    return false;
+  }
+  const fs7 = getFileSystem();
+  return opts.fromLogin ? runLoginEnvSync(fs7) : runDailyAutoUpdate(state, fs7);
+}
+async function runLoginEnvSync(fs7) {
+  const { auth: auth2 } = await Promise.resolve().then(() => (init_auth(), exports_auth));
+  const [statusErr, status] = await catchError(auth2.getLoginStatus());
+  if (statusErr || status.loginStatus !== "Logged in" || !status.baseUrl) {
+    logger.debug(`Version sync skipped: not authenticated (status=${statusErr ? `error: ${statusErr.message}` : status.loginStatus})`);
+    return false;
+  }
+  const environment = mapAuthorityToEnvironment(status.baseUrl);
+  logger.debug(`Version sync: authority '${status.baseUrl}' → environment '${environment}'`);
+  if (environment === "unknown") {
+    logger.debug(`Authority '${status.baseUrl}' maps to no managed environment; skipping version sync`);
+    return false;
+  }
+  logger.debug(`Version sync: downloading ${VERSIONS_FILENAME} from ${VERSIONS_PACKAGE}`);
+  const versions2 = await downloadVersions();
+  if (!versions2)
+    return false;
+  const parsed = VersionsSchema.safeParse(versions2);
+  if (!parsed.success) {
+    logger.debug("cli-versions.json failed schema validation; skipping");
+    return false;
+  }
+  if (parsed.data.schemaVersion !== undefined && parsed.data.schemaVersion > SUPPORTED_SCHEMA_VERSION) {
+    logger.debug(`cli-versions.json schemaVersion ${parsed.data.schemaVersion} is newer than supported ${SUPPORTED_SCHEMA_VERSION}; skipping`);
+    return false;
+  }
+  const pinned = parsed.data.environments[environment]?.cliVersion;
+  if (!pinned) {
+    logger.debug(`No cliVersion pinned for '${environment}'; skipping`);
+    return false;
+  }
+  if (!isValidVersionPin(pinned)) {
+    logger.debug(`Pinned version '${pinned}' is not a valid pin; skipping`);
+    return false;
+  }
+  const cfg = getCachedConfig().core;
+  if (cfg?.versionSource === "manual") {
+    logger.debug(`core.version is manually pinned (${cfg.version ?? "?"}); not overriding from environment`);
+    return false;
+  }
+  if (cfg?.version !== pinned || cfg?.versionSource !== "environment") {
+    logger.info(`Setting core.version=${pinned} (source=environment) for '${environment}'`);
+    const { setCoreConfigValuesAsync: setCoreConfigValuesAsync2 } = await Promise.resolve().then(() => (init_loadConfig(), exports_loadConfig));
+    await setCoreConfigValuesAsync2({
+      version: pinned,
+      versionSource: "environment"
+    });
+  } else {
+    logger.debug(`core.version already ${pinned} (environment); re-checking alignment`);
+  }
+  await clearState(fs7);
+  return false;
+}
+async function runDailyAutoUpdate(state, fs7) {
+  const today = todayLocal();
+  const prev = await readState(fs7);
+  if (prev && prev.lastUpdateDate === today) {
+    logger.debug("Daily auto-update already ran today; skipping");
+    return false;
+  }
+  await writeState(fs7, { lastUpdateDate: today });
+  let effectivePin = resolvePinnedVersion();
+  if (effectivePin) {
+    logger.debug(`Daily auto-update: respecting core.version pin ${formatVersionPin(effectivePin)}`);
+  } else {
+    const major = package_default.version.split(".")[0];
+    const channel = resolveChannel();
+    logger.debug(`Daily auto-update: resolving latest @uipath/cli in major ${major}.x (channel ${channel})`);
+    const [resErr, latest] = await catchError(toolService.searchLatestVersion("@uipath/cli", `${major}.`, {
+      channel,
+      timeoutMs: DOWNLOAD_TIMEOUT_MS
+    }));
+    if (resErr || !latest) {
+      logger.debug(`Daily auto-update: no @uipath/cli version found in major ${major}.x; skipping`);
+      return false;
+    }
+    if (compareSemver(latest, package_default.version) <= 0) {
+      logger.debug(`Daily auto-update: already at the latest minor in major ${major}.x (current ${package_default.version}, latest ${latest}); skipping`);
+      return false;
+    }
+    effectivePin = majorMinorPinOf(latest);
+    if (!effectivePin) {
+      logger.debug(`Daily auto-update: could not parse resolved version '${latest}'; skipping`);
+      return false;
+    }
+    logger.debug(`Daily auto-update: targeting latest minor ${formatVersionPin(effectivePin)}.x (resolved ${latest})`);
+  }
+  return applyUpdate(state, fs7, effectivePin, true);
+}
+async function applyUpdate(state, fs7, effectivePin, reexec) {
+  const [locErr, location] = await catchError(state.resolveInstallPath());
+  if (locErr || !location) {
+    logger.debug(`Cannot resolve install location: ${String(locErr)}`);
+    return false;
+  }
+  const { runUpdate: runUpdate2 } = await Promise.resolve().then(() => (init_updateService(), exports_updateService));
+  const [updErr, report] = await catchError(runUpdate2({
+    dryRun: false,
+    channel: resolveChannel(),
+    sections: { tools: true, skills: true, cli: true },
+    tools: { name: undefined },
+    skills: { agent: undefined, local: undefined },
+    cli: { self: true },
+    versionPin: effectivePin
+  }, state, {
+    cliPkgVersion: package_default.version,
+    isLocal: !location.global,
+    isDev: false,
+    installPath: location.path
+  }));
+  if (updErr || !report) {
+    logger.debug(`Version sync update failed: ${updErr ? updErr.message : "no report"}`);
+    return false;
+  }
+  for (const e of report.Errors) {
+    logger.debug(`[${e.Subsystem}] ${e.Message} ${e.Instructions}`);
+  }
+  const cliUpdated = report.Cli?.action === "updated";
+  const toolsUpdated = !!report.Tools?.some((t) => t.status === "updated");
+  if (!cliUpdated && !toolsUpdated) {
+    logger.debug("Version sync: nothing changed; continuing in-process");
+    return false;
+  }
+  if (!reexec) {
+    logger.debug("Version sync applied; new version takes effect on the next run");
+    return false;
+  }
+  return reexecOriginalCommand(fs7);
+}
+async function reexecOriginalCommand(fs7) {
+  const { spawn: spawn3 } = await import("node:child_process");
+  const userArgs = process.argv.slice(2);
+  const env2 = { ...process.env, [REEXEC_GUARD_ENV]: "1" };
+  logger.info("Re-running the requested command on the updated CLI…");
+  const binName = process.argv[1] ? fs7.path.basename(process.argv[1]) : "uip";
+  const [primErr, primCode] = await catchError(runChild(spawn3, binName, userArgs, env2));
+  if (!primErr) {
+    process.exitCode = primCode ?? 1;
+    return true;
+  }
+  logger.debug(`Re-exec via PATH ('${binName}') failed: ${primErr.message}; trying node fallback`);
+  const entry = process.argv[1];
+  if (!entry)
+    return false;
+  const [fbErr, fbCode] = await catchError(runChild(spawn3, process.execPath, [entry, ...userArgs], env2));
+  if (fbErr) {
+    logger.debug(`Re-exec fallback failed: ${fbErr.message}`);
+    return false;
+  }
+  process.exitCode = fbCode ?? 1;
+  return true;
+}
+function runChild(spawnFn, command, args, env2) {
+  return new Promise((resolve2, reject) => {
+    const child = spawnFn(command, args, { stdio: "inherit", env: env2 });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2(code));
+  });
+}
+function mapAuthorityToEnvironment(baseUrl) {
+  const [err, host] = catchError(() => new URL(baseUrl).hostname.toLowerCase());
+  if (err || !host)
+    return "unknown";
+  if (host.includes("alpha"))
+    return "alpha";
+  if (host.includes("staging"))
+    return "staging";
+  if (host === "cloud.uipath.com")
+    return "cloud";
+  return "unknown";
+}
+function extractVerb(args) {
+  for (const a of stripGlobalOptions(args.slice(2)).args) {
+    if (a.startsWith("-"))
+      continue;
+    return a;
+  }
+  return;
+}
+function isTruthyEnv(value) {
+  if (!value)
+    return false;
+  const v = value.trim().toLowerCase();
+  return v !== "" && v !== "0" && v !== "false" && v !== "no";
+}
+function todayLocal() {
+  const d = new Date;
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${d.getFullYear()}-${month}-${day}`;
+}
+function stateFilePath(fs7) {
+  return fs7.path.join(fs7.env.homedir(), UIPATH_HOME_DIR, STATE_FILENAME);
+}
+async function readState(fs7) {
+  const [readErr, raw] = await catchError(fs7.readFile(stateFilePath(fs7), "utf-8"));
+  if (readErr || !raw)
+    return null;
+  const [parseErr, parsed] = catchError(() => JSON.parse(raw));
+  if (parseErr || typeof parsed?.lastUpdateDate !== "string") {
+    return null;
+  }
+  return { lastUpdateDate: parsed.lastUpdateDate };
+}
+async function writeState(fs7, state) {
+  await catchError(fs7.writeFile(stateFilePath(fs7), JSON.stringify(state, null, 2)));
+}
+async function clearState(fs7) {
+  const [rmErr] = await catchError(fs7.rm(stateFilePath(fs7)));
+  if (rmErr) {
+    logger.debug(`Failed to clear version sync state: ${rmErr.message}`);
+  }
+}
+async function downloadVersions() {
+  const [dlErr, raw] = await catchError(toolService.downloadPackageFile(VERSIONS_PACKAGE, VERSIONS_FILENAME, {
+    timeoutMs: DOWNLOAD_TIMEOUT_MS,
+    forcePublicRegistry: true
+  }));
+  if (dlErr) {
+    logger.debug(`Failed to download ${VERSIONS_FILENAME} from ${VERSIONS_PACKAGE}: ${dlErr.message}`);
+    return null;
+  }
+  const [jsonErr, json2] = catchError(() => JSON.parse(raw));
+  if (jsonErr) {
+    logger.debug(`Failed to parse ${VERSIONS_FILENAME}: ${jsonErr.message}`);
+    return null;
+  }
+  return json2;
+}
+var VERSIONS_PACKAGE = "@uipath/cli-meta", VERSIONS_FILENAME = "cli-versions.json", SUPPORTED_SCHEMA_VERSION = 1, DOWNLOAD_TIMEOUT_MS = 8000, STATE_FILENAME = "version-sync.json", REEXEC_GUARD_ENV = "UIPATH_CLI_VERSION_SYNC_REEXEC", DISABLE_ENV = "UIPATH_CLI_DISABLE_VERSION_SYNC", SKIP_VERBS, VERSION_HELP_FLAGS, VersionsSchema;
+var init_versionSync = __esm(() => {
+  init_src3();
+  init_src2();
+  init_src();
+  init_zod();
+  init_package();
+  init_loadConfig();
+  init_globalOptions();
   init_channel();
   init_toolService();
+  init_versionPin();
+  SKIP_VERBS = new Set([
+    "update",
+    "login",
+    "logout",
+    "mcp",
+    "completion",
+    "config",
+    "help"
+  ]);
+  VERSION_HELP_FLAGS = new Set(["-v", "--version", "-h", "--help"]);
+  VersionsSchema = exports_external.object({
+    schemaVersion: exports_external.number().optional(),
+    environments: exports_external.record(exports_external.string(), exports_external.object({ cliVersion: exports_external.string().min(1) }).passthrough())
+  }).passthrough();
 });
 
 // src/utils/autoInstall.ts
@@ -111497,6 +112915,10 @@ function registerToolCommands(program2, discovered, context) {
         });
         return;
       }
+      setGlobalTelemetryProperties({
+        toolName: tool.metadata.commandPrefix,
+        toolVersion: tool.metadata.version
+      });
       const idx = program2.commands.indexOf(toolCommand);
       if (idx >= 0) {
         program2.commands.splice(idx, 1);
@@ -111518,7 +112940,8 @@ function registerToolCommands(program2, discovered, context) {
       const prefixIdx = toolArgs.findIndex((a) => candidates.includes(a));
       const positionals = prefixIdx >= 0 ? toolArgs.slice(prefixIdx + 1).filter((a) => !a.startsWith("-")) : [];
       const unknownSub = findUnknownHelpCommand(realCommand, positionals, toolArgs);
-      if (unknownSub) {
+      const forwardsUnknownCommands = realCommand.listenerCount("command:*") > 0;
+      if (unknownSub && !forwardsUnknownCommands) {
         OutputFormatter.error({
           Result: RESULTS.ValidationError,
           Message: `error: unknown command '${unknownSub}'`,
@@ -111597,7 +113020,8 @@ async function buildNodeProgram(context) {
       };
       return {
         outputFormat: !formatWasExplicit && config2.core?.output ? config2.core.output : undefined,
-        level: !logLevelWasExplicit && config2.core?.logLevel ? levelMap[config2.core.logLevel] : undefined
+        level: !logLevelWasExplicit && config2.core?.logLevel ? levelMap[config2.core.logLevel] : undefined,
+        interactivityMode: config2.core?.interactive
       };
     },
     afterTelemetryInit: populateTelemetryAuthContext
@@ -111647,7 +113071,7 @@ async function buildNodeProgram(context) {
     discoveredTools
   });
   logger.debug("Node program built successfully — ready to parse args");
-  return { program: program2, cleanedArgs };
+  return { program: program2, cleanedArgs, updateState };
 }
 async function runNode(context) {
   const built = await buildNodeProgram(context);
@@ -111655,7 +113079,13 @@ async function runNode(context) {
     await telemetryFlushAndShutdown();
     return;
   }
+  const reexeced = await maybeRunDailyVersionSync(context, built.updateState);
+  if (reexeced) {
+    await telemetryFlushAndShutdown();
+    return;
+  }
   await parseAndExit(built.program, built.cleanedArgs, context);
+  await runPostLoginVersionSync(context, built.updateState);
 }
 var init_cli_node = __esm(() => {
   init_src2();
@@ -111674,6 +113104,7 @@ var init_cli_node = __esm(() => {
   init_authTelemetry();
   init_installPath();
   init_tool_manager();
+  init_versionSync();
   init_autoInstall();
   init_registerToolCommands();
   init_resolveToolsDirectories();
@@ -111738,14 +113169,37 @@ class TerminalSink {
   }
 }
 
+// src/system-ca.ts
+import * as tls from "node:tls";
+function installSystemCaTrust(tlsModule = tls) {
+  const getCertificates = tlsModule.getCACertificates;
+  const setDefaultCertificates = tlsModule.setDefaultCACertificates;
+  if (typeof getCertificates !== "function" || typeof setDefaultCertificates !== "function") {
+    return "unsupported";
+  }
+  try {
+    const system = getCertificates.call(tlsModule, "system");
+    if (!Array.isArray(system) || system.length === 0) {
+      return "empty";
+    }
+    const current = getCertificates.call(tlsModule, "default") ?? [];
+    setDefaultCertificates.call(tlsModule, [...current, ...system]);
+    return "applied";
+  } catch {
+    return "error";
+  }
+}
+
 // index.ts
 import { fileURLToPath as fileURLToPath4 } from "node:url";
+var systemCaTrust = installSystemCaTrust();
 process.stdout.on("error", (err) => {
   if (err.code === "EPIPE")
     process.exit(0);
 });
 process.stderr.on("error", () => {});
 configureLogger({ sink: new TerminalSink });
+logger.debug(`OS certificate-store trust: ${systemCaTrust}`);
 installConsoleGuard();
 var pollController = createPollAbortController();
 setProcessContextPollSignal(pollController.signal);