@uipath/case-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/{packager-tool-yn33pw57.js → packager-tool-dn9d4ywm.js}

@@ -1,33 +1,33 @@
 import {
-  getGlobalThis,
-  isBrowser
-} from "./packager-tool-0gctz400.js";
-import {
-  catchError
-} from "./packager-tool-qa9gftnj.js";
-import {
+  UIPATH_HOME_DIR,
   AUTH_FILENAME,
   DEFAULT_BASE_URL,
-  DEFAULT_REDIRECT_URI,
-  UIPATH_HOME_DIR
-} from "./packager-tool-yc4kw997.js";
+  DEFAULT_REDIRECT_URI
+} from "./packager-tool-q26hncjr.js";
 import {
-  getFileSystem
-} from "./packager-tool-hdxtgckw.js";
+  getFileSystem2
+} from "./packager-tool-z070caqq.js";
+import {
+  isBrowser2,
+  getGlobalThis
+} from "./packager-tool-z9fmqtm6.js";
+import {
+  catchError
+} from "./packager-tool-mxgybnmt.js";
 import {
   __require
-} from "./packager-tool-1yh8g550.js";
+} from "./packager-tool-6an893wm.js";
 
 // ../auth/src/config.ts
 var DEFAULT_CLIENT_ID = "36dea5b8-e8bb-423d-8e7b-c808df8f1c00";
 var AUTH_FILE_CONFIG_KEY = Symbol.for("@uipath/auth/AuthFileConfig");
 var globalSlot = globalThis;
-var setAuthFileConfig = (cfg) => {
+var setAuthFileConfig2 = (cfg) => {
   globalSlot[AUTH_FILE_CONFIG_KEY] = cfg ?? {};
 };
 var getAuthFileConfig = () => globalSlot[AUTH_FILE_CONFIG_KEY] ?? {};
 
-class InvalidBaseUrlError extends Error {
+class InvalidBaseUrlError2 extends Error {
   url;
   reason;
   constructor(url, reason) {
@@ -64,10 +64,10 @@ var normalizeAndValidateBaseUrl = (rawUrl) => {
   const [urlError, url] = catchError(() => new URL(resolvedBaseUrl));
   if (urlError) {
     const shapeHint = !hasScheme && !hostCandidate.includes(".") ? ` "${rawUrl.trim()}" is not a URL or a host name. Pass the full authority URL — https://<host>, or just <host> (https:// is assumed).` : ` ${urlError instanceof Error ? urlError.message : "Unknown error"}`;
-    throw new InvalidBaseUrlError(baseUrl, `Malformed URL.${shapeHint}`);
+    throw new InvalidBaseUrlError2(baseUrl, `Malformed URL.${shapeHint}`);
   }
   if (url.protocol !== "https:") {
-    throw new InvalidBaseUrlError(baseUrl, `Authority must use https:// scheme, got ${url.protocol}//. OIDC token exchange requires TLS end-to-end.`);
+    throw new InvalidBaseUrlError2(baseUrl, `Authority must use https:// scheme, got ${url.protocol}//. OIDC token exchange requires TLS end-to-end.`);
   }
   return url.pathname.length > 1 ? url.origin : baseUrl;
 };
@@ -289,14 +289,14 @@ function ClientSecretPost2(clientSecret) {
     return ClientSecretPost(clientSecret);
   }
   tbi ||= new WeakMap;
-  return (as, client, body, headers2) => {
+  return (as, client, body, headers) => {
     let auth;
     if (!(auth = tbi.get(client))) {
       assertString2(client.client_secret, '"metadata.client_secret"');
       auth = ClientSecretPost(client.client_secret);
       tbi.set(client, auth);
     }
-    return auth(as, client, body, headers2);
+    return auth(as, client, body, headers);
   };
 }
 function assertString2(input, it) {
@@ -463,7 +463,8 @@ var exchangeCodeForTokens = async ({
 };
 
 // ../auth/src/authProfile.ts
-var DEFAULT_AUTH_PROFILE = "default";
+var DEFAULT_AUTH_PROFILE2 = "default";
+var INHERITED_AUTH_PROFILE_ENV2 = "UIPATH_CLI_INHERITED_PROFILE";
 var PROFILE_DIR = "profiles";
 var PROFILE_NAME_RE = /^[A-Za-z0-9._-]+$/;
 var ACTIVE_AUTH_PROFILE_KEY = Symbol.for("@uipath/auth/ActiveAuthProfile");
@@ -495,23 +496,23 @@ function getProfileStorage() {
 }
 var profileStorage = getProfileStorage();
 
-class AuthProfileValidationError extends Error {
+class AuthProfileValidationError2 extends Error {
   constructor(message) {
     super(message);
     this.name = "AuthProfileValidationError";
   }
 }
-function normalizeAuthProfileName(profile) {
-  if (profile === undefined || profile === DEFAULT_AUTH_PROFILE) {
+function normalizeAuthProfileName2(profile) {
+  if (profile === undefined || profile === DEFAULT_AUTH_PROFILE2) {
     return;
   }
   if (profile.length === 0 || profile === "." || profile === ".." || !PROFILE_NAME_RE.test(profile)) {
-    throw new AuthProfileValidationError(`Invalid profile name "${profile}". Profile names may contain only letters, numbers, '.', '_', and '-'.`);
+    throw new AuthProfileValidationError2(`Invalid profile name "${profile}". Profile names may contain only letters, numbers, '.', '_', and '-'.`);
   }
   return profile;
 }
-function setActiveAuthProfile(profile) {
-  const normalized = normalizeAuthProfileName(profile);
+function setActiveAuthProfile2(profile) {
+  const normalized = normalizeAuthProfileName2(profile);
   const scopedState = profileStorage.getStore();
   if (scopedState !== undefined) {
     if (normalized === undefined) {
@@ -527,7 +528,7 @@ function setActiveAuthProfile(profile) {
   }
   globalSlot2[ACTIVE_AUTH_PROFILE_KEY] = { profile: normalized };
 }
-function clearActiveAuthProfile() {
+function clearActiveAuthProfile2() {
   const scopedState = profileStorage.getStore();
   if (scopedState !== undefined) {
     delete scopedState.profile;
@@ -535,44 +536,44 @@ function clearActiveAuthProfile() {
   }
   delete globalSlot2[ACTIVE_AUTH_PROFILE_KEY];
 }
-function getActiveAuthProfile() {
+function getActiveAuthProfile2() {
   const scopedState = profileStorage.getStore();
   if (scopedState !== undefined) {
     return scopedState.profile;
   }
   return globalSlot2[ACTIVE_AUTH_PROFILE_KEY]?.profile;
 }
-function runWithAuthProfile(profile, fn) {
-  const normalized = normalizeAuthProfileName(profile);
+function runWithAuthProfile2(profile, fn) {
+  const normalized = normalizeAuthProfileName2(profile);
   return profileStorage.run(normalized === undefined ? {} : { profile: normalized }, fn);
 }
-function resolveAuthProfileFilePath(profile) {
-  const normalized = normalizeAuthProfileName(profile);
+function resolveAuthProfileFilePath2(profile) {
+  const normalized = normalizeAuthProfileName2(profile);
   if (normalized === undefined) {
-    throw new AuthProfileValidationError(`"${DEFAULT_AUTH_PROFILE}" is the built-in profile and does not have a profile file path.`);
+    throw new AuthProfileValidationError2(`"${DEFAULT_AUTH_PROFILE2}" is the built-in profile and does not have a profile file path.`);
   }
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, PROFILE_DIR, normalized, AUTH_FILENAME);
 }
-function getActiveAuthProfileFilePath() {
-  const profile = getActiveAuthProfile();
-  return profile ? resolveAuthProfileFilePath(profile) : undefined;
+function getActiveAuthProfileFilePath2() {
+  const profile = getActiveAuthProfile2();
+  return profile ? resolveAuthProfileFilePath2(profile) : undefined;
 }
-function getAuthProfilesRootPath() {
-  const fs = getFileSystem();
+function getAuthProfilesRootPath2() {
+  const fs = getFileSystem2();
   return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, PROFILE_DIR);
 }
-function resolveAuthProfileDirPath(profile) {
-  const normalized = normalizeAuthProfileName(profile);
+function resolveAuthProfileDirPath2(profile) {
+  const normalized = normalizeAuthProfileName2(profile);
   if (normalized === undefined) {
-    throw new AuthProfileValidationError(`"${DEFAULT_AUTH_PROFILE}" is the built-in profile and does not have a profile directory.`);
+    throw new AuthProfileValidationError2(`"${DEFAULT_AUTH_PROFILE2}" is the built-in profile and does not have a profile directory.`);
   }
-  const fs = getFileSystem();
-  return fs.path.join(getAuthProfilesRootPath(), normalized);
+  const fs = getFileSystem2();
+  return fs.path.join(getAuthProfilesRootPath2(), normalized);
 }
-async function listAuthProfileNamesAsync() {
-  const fs = getFileSystem();
-  const root = getAuthProfilesRootPath();
+async function listAuthProfileNamesAsync2() {
+  const fs = getFileSystem2();
+  const root = getAuthProfilesRootPath2();
   if (!await fs.exists(root)) {
     return [];
   }
@@ -582,7 +583,7 @@ async function listAuthProfileNamesAsync() {
   }
   const names = [];
   for (const entry of entries) {
-    if (!PROFILE_NAME_RE.test(entry) || entry === DEFAULT_AUTH_PROFILE) {
+    if (!PROFILE_NAME_RE.test(entry) || entry === DEFAULT_AUTH_PROFILE2) {
       continue;
     }
     const stats = await fs.stat(fs.path.join(root, entry));
@@ -592,21 +593,21 @@ async function listAuthProfileNamesAsync() {
   }
   return names.sort((a, b) => a.localeCompare(b));
 }
-async function authProfileExistsAsync(profile) {
-  const fs = getFileSystem();
-  const [pathError, dir] = catchError(() => resolveAuthProfileDirPath(profile));
+async function authProfileExistsAsync2(profile) {
+  const fs = getFileSystem2();
+  const [pathError, dir] = catchError(() => resolveAuthProfileDirPath2(profile));
   if (pathError || dir === undefined) {
     return false;
   }
   const stats = await fs.stat(dir);
   return stats?.isDirectory() === true;
 }
-async function deleteAuthProfileAsync(profile) {
-  const dir = resolveAuthProfileDirPath(profile);
-  const fs = getFileSystem();
-  const relativeToRoot = fs.path.relative(getAuthProfilesRootPath(), dir);
+async function deleteAuthProfileAsync2(profile) {
+  const dir = resolveAuthProfileDirPath2(profile);
+  const fs = getFileSystem2();
+  const relativeToRoot = fs.path.relative(getAuthProfilesRootPath2(), dir);
   if (relativeToRoot === "" || relativeToRoot.startsWith("..") || fs.path.isAbsolute(relativeToRoot)) {
-    throw new AuthProfileValidationError(`Refusing to delete "${profile}": resolved path escapes the profiles directory.`);
+    throw new AuthProfileValidationError2(`Refusing to delete "${profile}": resolved path escapes the profiles directory.`);
   }
   const stats = await fs.stat(dir);
   if (stats?.isDirectory() !== true) {
@@ -632,7 +633,7 @@ class InvalidIssuerError extends Error {
     this.name = "InvalidIssuerError";
   }
 }
-var parseJWT = (token) => {
+var parseJWT2 = (token) => {
   try {
     const parts = token.split(".");
     const base64Url = parts[1];
@@ -641,7 +642,7 @@ var parseJWT = (token) => {
     }
     const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
     let decodedString;
-    if (isBrowser() && typeof atob !== "undefined") {
+    if (isBrowser2() && typeof atob !== "undefined") {
       decodedString = atob(base64);
     } else {
       decodedString = Buffer.from(base64, "base64").toString();
@@ -656,7 +657,7 @@ var parseJWT = (token) => {
 var assertIssuerMatchesAuthority = (token, authority) => {
   let payload;
   try {
-    payload = parseJWT(token);
+    payload = parseJWT2(token);
   } catch (error) {
     throw new InvalidIssuerError(`${authority.replace(/\/+$/, "")}/identity_`, `<unparseable: ${error instanceof Error ? error.message : "unknown error"}>`);
   }
@@ -688,9 +689,9 @@ var getTokenExpiration = (accessToken) => {
 };
 
 // ../auth/src/sessionIdentity.ts
-var parseAuthFlow = (value) => value === "authorization_code" || value === "client_credentials" || value === "federated_credentials" ? value : undefined;
+var parseAuthFlow2 = (value) => value === "authorization_code" || value === "client_credentials" || value === "federated_credentials" ? value : undefined;
 var decodeClaims = (accessToken) => {
-  const [error, claims] = catchError(() => parseJWT(accessToken));
+  const [error, claims] = catchError(() => parseJWT2(accessToken));
   return error ? undefined : claims;
 };
 var asString = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
@@ -737,7 +738,7 @@ var pickScopes = (claims) => {
   const scopes = Array.isArray(raw) ? raw.filter((entry) => asString(entry) !== undefined) : typeof raw === "string" ? raw.split(/\s+/).filter(Boolean) : [];
   return scopes.length > 0 ? scopes : undefined;
 };
-var resolveSessionIdentity = (accessToken, authFlow) => {
+var resolveSessionIdentity2 = (accessToken, authFlow) => {
   const claims = accessToken ? decodeClaims(accessToken) : undefined;
   const email = pickEmail(claims);
   const type = resolveIdentityType(claims, authFlow, email);
@@ -768,12 +769,12 @@ var resolveSessionIdentity = (accessToken, authFlow) => {
     identity.applicationSubtype = applicationSubtype;
   return identity;
 };
-var readTokenScopes = (accessToken) => accessToken ? pickScopes(decodeClaims(accessToken)) : undefined;
+var readTokenScopes2 = (accessToken) => accessToken ? pickScopes(decodeClaims(accessToken)) : undefined;
 
 // ../auth/src/envAuth.ts
-var ENV_AUTH_ENABLE_VAR = "UIPATH_CLI_ENABLE_ENV_AUTH";
-var ENFORCE_ROBOT_AUTH_VAR = "UIPATH_CLI_ENFORCE_ROBOT_AUTH";
-var ENV_AUTH_VARS = {
+var ENV_AUTH_ENABLE_VAR2 = "UIPATH_CLI_ENABLE_ENV_AUTH";
+var ENFORCE_ROBOT_AUTH_VAR2 = "UIPATH_CLI_ENFORCE_ROBOT_AUTH";
+var ENV_AUTH_VARS2 = {
   token: "UIPATH_CLI_AUTH_TOKEN",
   organizationName: "UIPATH_CLI_ORGANIZATION_NAME",
   organizationId: "UIPATH_CLI_ORGANIZATION_ID",
@@ -781,18 +782,20 @@ var ENV_AUTH_VARS = {
   tenantId: "UIPATH_CLI_TENANT_ID"
 };
 
-class EnvAuthConfigError extends Error {
+class EnvAuthConfigError2 extends Error {
+  errorCode = "configuration_error";
+  retry = "RetryWillNotFix";
   constructor(message) {
     super(message);
     this.name = "EnvAuthConfigError";
   }
 }
-var isEnvAuthEnabled = () => process.env[ENV_AUTH_ENABLE_VAR] === "true";
-var isRobotAuthEnforced = () => process.env[ENFORCE_ROBOT_AUTH_VAR] === "true";
+var isEnvAuthEnabled2 = () => process.env[ENV_AUTH_ENABLE_VAR2] === "true";
+var isRobotAuthEnforced2 = () => process.env[ENFORCE_ROBOT_AUTH_VAR2] === "true";
 var requireEnv = (name) => {
   const value = process.env[name];
   if (!value) {
-    throw new EnvAuthConfigError(`${ENV_AUTH_ENABLE_VAR}=true but ${name} is not set. ` + `Set ${name} to enable env-var authentication.`);
+    throw new EnvAuthConfigError2(`${ENV_AUTH_ENABLE_VAR2}=true but ${name} is not set. ` + `Set ${name} to enable env-var authentication.`);
   }
   return value;
 };
@@ -800,31 +803,31 @@ var OPAQUE_TOKEN_BASE_URL_VAR = "UIPATH_URL";
 var resolveBaseUrl = (rawUrl, failureContext) => {
   const [baseUrlError, baseUrl] = catchError(() => normalizeAndValidateBaseUrl(rawUrl));
   if (baseUrlError) {
-    if (baseUrlError instanceof InvalidBaseUrlError) {
+    if (baseUrlError instanceof InvalidBaseUrlError2) {
       throw baseUrlError;
     }
-    throw new EnvAuthConfigError(`${failureContext}: ` + `${baseUrlError instanceof Error ? baseUrlError.message : String(baseUrlError)}`);
+    throw new EnvAuthConfigError2(`${failureContext}: ` + `${baseUrlError instanceof Error ? baseUrlError.message : String(baseUrlError)}`);
   }
   return baseUrl;
 };
-var readAuthFromEnv = () => {
-  const accessToken = requireEnv(ENV_AUTH_VARS.token);
-  const organizationName = requireEnv(ENV_AUTH_VARS.organizationName);
-  const organizationId = requireEnv(ENV_AUTH_VARS.organizationId);
-  const tenantName = requireEnv(ENV_AUTH_VARS.tenantName);
-  const tenantId = requireEnv(ENV_AUTH_VARS.tenantId);
-  const [parseError, payload] = catchError(() => parseJWT(accessToken));
+var readAuthFromEnv2 = () => {
+  const accessToken = requireEnv(ENV_AUTH_VARS2.token);
+  const organizationName = requireEnv(ENV_AUTH_VARS2.organizationName);
+  const organizationId = requireEnv(ENV_AUTH_VARS2.organizationId);
+  const tenantName = requireEnv(ENV_AUTH_VARS2.tenantName);
+  const tenantId = requireEnv(ENV_AUTH_VARS2.tenantId);
+  const [parseError, payload] = catchError(() => parseJWT2(accessToken));
   if (parseError) {
     const parseErrorMessage = parseError instanceof Error ? parseError.message : String(parseError);
     const rawUrl = process.env[OPAQUE_TOKEN_BASE_URL_VAR];
     if (!rawUrl) {
-      throw new EnvAuthConfigError(`${ENV_AUTH_VARS.token} is not a JWT (treating it as an opaque token, ` + `e.g. a Personal Access Token). Set ${OPAQUE_TOKEN_BASE_URL_VAR} to the ` + `UiPath base URL if this is a PAT, or fix the token if it was meant to ` + `be a JWT (parse error: ${parseErrorMessage}).`);
+      throw new EnvAuthConfigError2(`${ENV_AUTH_VARS2.token} is not a JWT (treating it as an opaque token, ` + `e.g. a Personal Access Token). Set ${OPAQUE_TOKEN_BASE_URL_VAR} to the ` + `UiPath base URL if this is a PAT, or fix the token if it was meant to ` + `be a JWT (parse error: ${parseErrorMessage}).`);
     }
-    const baseUrl2 = resolveBaseUrl(rawUrl, `Failed to validate ${OPAQUE_TOKEN_BASE_URL_VAR}`);
+    const baseUrl = resolveBaseUrl(rawUrl, `Failed to validate ${OPAQUE_TOKEN_BASE_URL_VAR}`);
     return {
       loginStatus: "Logged in",
       accessToken,
-      baseUrl: baseUrl2,
+      baseUrl,
       organizationName,
       organizationId,
       tenantName,
@@ -835,13 +838,13 @@ var readAuthFromEnv = () => {
   }
   const iss = payload.iss;
   if (typeof iss !== "string" || iss.length === 0) {
-    throw new EnvAuthConfigError(`${ENV_AUTH_VARS.token} has no 'iss' claim; cannot determine ` + `the UiPath server. Ensure the token was issued by a UiPath identity server.`);
+    throw new EnvAuthConfigError2(`${ENV_AUTH_VARS2.token} has no 'iss' claim; cannot determine ` + `the UiPath server. Ensure the token was issued by a UiPath identity server.`);
   }
   const baseUrl = resolveBaseUrl(iss, "Failed to derive server URL from token 'iss' claim");
   const expiration = getTokenExpiration(accessToken);
   const loginStatus = expiration && expiration <= new Date ? "Expired" : "Logged in";
-  const identity = resolveSessionIdentity(accessToken);
-  const scopes = readTokenScopes(accessToken);
+  const identity = resolveSessionIdentity2(accessToken);
+  const scopes = readTokenScopes2(accessToken);
   return {
     loginStatus,
     accessToken,
@@ -862,7 +865,7 @@ var BREAKER_SUFFIX = ".refresh-state";
 var BACKOFF_BASE_MS = 60000;
 var BACKOFF_CAP_MS = 60 * 60 * 1000;
 var SURFACE_WINDOW_MS = 60 * 60 * 1000;
-async function refreshTokenFingerprint(refreshToken) {
+async function refreshTokenFingerprint2(refreshToken) {
   const bytes = new TextEncoder().encode(refreshToken);
   if (globalThis.crypto?.subtle) {
     const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
@@ -874,8 +877,8 @@ async function refreshTokenFingerprint(refreshToken) {
 function breakerPathFor(authPath) {
   return `${authPath}${BREAKER_SUFFIX}`;
 }
-async function loadRefreshBreaker(authPath) {
-  const fs = getFileSystem();
+async function loadRefreshBreaker2(authPath) {
+  const fs = getFileSystem2();
   try {
     const content = await fs.readFile(breakerPathFor(authPath), "utf-8");
     if (!content)
@@ -886,9 +889,9 @@ async function loadRefreshBreaker(authPath) {
     return {};
   }
 }
-async function saveRefreshBreaker(authPath, state) {
+async function saveRefreshBreaker2(authPath, state) {
   try {
-    const fs = getFileSystem();
+    const fs = getFileSystem2();
     const path = breakerPathFor(authPath);
     await fs.mkdir(fs.path.dirname(path));
     const tempPath = `${path}.tmp`;
@@ -896,8 +899,8 @@ async function saveRefreshBreaker(authPath, state) {
     await fs.rename(tempPath, path);
   } catch {}
 }
-async function clearRefreshBreaker(authPath) {
-  const fs = getFileSystem();
+async function clearRefreshBreaker2(authPath) {
+  const fs = getFileSystem2();
   const path = breakerPathFor(authPath);
   try {
     if (await fs.exists(path)) {
@@ -922,7 +925,7 @@ var ROBOT_USER_SERVICES_PIPE = "UiPathUserServices";
 var ROBOT_USER_SERVICES_ALTERNATE_PIPE = `${ROBOT_USER_SERVICES_PIPE}Alternate`;
 var PIPE_NAME_MAX_LENGTH = 103;
 var getRobotIpcPipeNames = async () => {
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   const username = fs.env.getenv("USER") ?? fs.env.getenv("USERNAME");
   if (!username) {
     throw new Error("Unable to determine current username");
@@ -938,7 +941,7 @@ var defaultIsRobotIpcAvailable = async () => {
   if (pipeNamesError || !pipeNames) {
     return false;
   }
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   for (const pipeName of pipeNames) {
     const [existsError, exists] = await catchError(fs.exists(pipeName));
     if (!existsError && exists === true) {
@@ -969,7 +972,7 @@ var parseResourceUrl = (url) => {
   };
 };
 var ROBOT_CLIENT_LOADER_KEY = Symbol.for("@uipath/auth/RobotClientLoader");
-var registerRobotClientLoader = (loader) => {
+var registerRobotClientLoader2 = (loader) => {
   globalThis[ROBOT_CLIENT_LOADER_KEY] = loader;
 };
 var getRegisteredRobotClientLoader = () => {
@@ -988,7 +991,7 @@ var defaultLoadModule = async () => {
   return mod;
 };
 var tryRobotClientFallback = async (options = {}) => {
-  if (isBrowser())
+  if (isBrowser2())
     return;
   if (!options.force) {
     if (process.env.CI || process.env.GITHUB_ACTIONS) {
@@ -1030,7 +1033,7 @@ var tryRobotClientFallback = async (options = {}) => {
     let organizationIdFromToken;
     let tenantIdFromToken;
     let issuerFromToken;
-    const [jwtError, claims] = catchError(() => parseJWT(accessToken));
+    const [jwtError, claims] = catchError(() => parseJWT2(accessToken));
     if (!jwtError && claims) {
       const rawOrgId = claims.prtId ?? claims.organizationId ?? claims.prt_id;
       if (typeof rawOrgId === "string" && rawOrgId.length > 0) {
@@ -1072,7 +1075,7 @@ var describeNonJsonResponse = (organizationId, response, parseError) => {
   const contentType = response.headers.get("content-type") ?? "unknown";
   return `The organization service returned a '${contentType}' response instead ` + `of JSON: ${parseError.message}. ${organizationHint(organizationId)}`;
 };
-var fetchTenantsAndOrganizations = async (baseUrl, accessToken, organizationId, signal) => {
+var fetchTenantsAndOrganizations2 = async (baseUrl, accessToken, organizationId, signal) => {
   const url = `${baseUrl}/${organizationId}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo`;
   const response = await fetch(url, {
     headers: {
@@ -1098,17 +1101,17 @@ var fetchTenantsAndOrganizations = async (baseUrl, accessToken, organizationId,
 // ../auth/src/tokenRefresh.ts
 var TOKEN_REFRESH_REAUTHENTICATE_MESSAGE = "Token refresh failed. Run 'uip login' to re-authenticate.";
 
-class TokenRefreshOAuthError extends Error {
+class TokenRefreshOAuthError2 extends Error {
   __brand = "TokenRefreshOAuthError";
   constructor() {
     super(TOKEN_REFRESH_REAUTHENTICATE_MESSAGE);
     this.name = "TokenRefreshOAuthError";
   }
 }
-function isTokenRefreshOAuthFailure(error) {
-  return error instanceof TokenRefreshOAuthError;
+function isTokenRefreshOAuthFailure2(error) {
+  return error instanceof TokenRefreshOAuthError2;
 }
-var refreshAccessToken = async ({
+var refreshAccessToken2 = async ({
   refreshToken,
   tokenEndpoint,
   clientId,
@@ -1127,8 +1130,11 @@ var refreshAccessToken = async ({
     body: tokenParams
   });
   const tokenData = await tokenResponse.json();
+  if (tokenResponse.status === 400 || tokenResponse.status === 401) {
+    throw new TokenRefreshOAuthError2;
+  }
   if (!tokenResponse.ok) {
-    throw new TokenRefreshOAuthError;
+    throw new Error(`Token refresh failed: HTTP ${tokenResponse.status}`);
   }
   const newAccessToken = tokenData.access_token;
   const newRefreshToken = tokenData.refresh_token;
@@ -1142,11 +1148,11 @@ var refreshAccessToken = async ({
 };
 
 // ../auth/src/types.ts
-var AUTH_FLOW_ENV_VAR = "UIPATH_AUTH_FLOW";
+var AUTH_FLOW_ENV_VAR2 = "UIPATH_AUTH_FLOW";
 
 // ../auth/src/utils/envFile.ts
-var DEFAULT_AUTH_FILENAME = AUTH_FILENAME;
-var DEFAULT_ENV_FILENAME = `${UIPATH_HOME_DIR}/${AUTH_FILENAME}`;
+var DEFAULT_AUTH_FILENAME2 = AUTH_FILENAME;
+var DEFAULT_ENV_FILENAME2 = `${UIPATH_HOME_DIR}/${AUTH_FILENAME}`;
 var KNOWN_ERROR_CODES = new Set([
   "EISDIR",
   "EACCES",
@@ -1190,23 +1196,23 @@ var probeAsync = async (fs, candidate) => {
     };
   }
 };
-var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
-  const fs = getFileSystem();
+var resolveEnvFileLocationAsync2 = async (envFilePath = DEFAULT_ENV_FILENAME2, opts) => {
+  const fs = getFileSystem2();
   if (fs.path.isAbsolute(envFilePath)) {
-    const probe2 = await probeAsync(fs, envFilePath);
-    return probe2.exists ? { exists: true, absolutePath: envFilePath, source: "absolute" } : {
+    const probe = await probeAsync(fs, envFilePath);
+    return probe.exists ? { exists: true, absolutePath: envFilePath, source: "absolute" } : {
       exists: false,
       absolutePath: envFilePath,
       source: "absolute",
-      ...probe2.unusable ? { unusable: probe2.unusable } : {}
+      ...probe.unusable ? { unusable: probe.unusable } : {}
     };
   }
   const cwd = opts?.cwd ?? fs.env.cwd();
   let searchDir = cwd;
   while (true) {
     const candidate = fs.path.join(searchDir, envFilePath);
-    const probe2 = await probeAsync(fs, candidate);
-    if (probe2.exists) {
+    const probe = await probeAsync(fs, candidate);
+    if (probe.exists) {
       return {
         exists: true,
         absolutePath: candidate,
@@ -1231,8 +1237,8 @@ var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opt
     ...probe.unusable ? { unusable: probe.unusable } : {}
   };
 };
-var resolveEnvFilePathAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
-  const location = await resolveEnvFileLocationAsync(envFilePath, opts);
+var resolveEnvFilePathAsync2 = async (envFilePath = DEFAULT_ENV_FILENAME2, opts) => {
+  const location = await resolveEnvFileLocationAsync2(envFilePath, opts);
   if (location.exists) {
     return { absolutePath: location.absolutePath };
   }
@@ -1262,8 +1268,8 @@ var parseEnvContent = (content) => {
   }
   return env;
 };
-var loadEnvFileAsync = async ({ envPath }) => {
-  const fs = getFileSystem();
+var loadEnvFileAsync2 = async ({ envPath }) => {
+  const fs = getFileSystem2();
   const absolutePath = fs.path.isAbsolute(envPath) ? envPath : fs.path.join(fs.env.cwd(), envPath);
   if (!await fs.exists(absolutePath)) {
     throw new Error(`Environment file not found: ${envPath}`);
@@ -1274,17 +1280,17 @@ var loadEnvFileAsync = async ({ envPath }) => {
   }
   return parseEnvContent(content);
 };
-var saveEnvFileAsync = async ({
+var saveEnvFileAsync2 = async ({
   envPath,
   data,
   merge = true
 }) => {
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   const absolutePath = fs.path.isAbsolute(envPath) ? envPath : fs.path.join(fs.env.homedir(), envPath);
   let existingData = {};
   if (merge && await fs.exists(absolutePath)) {
     try {
-      existingData = await loadEnvFileAsync({ envPath: absolutePath });
+      existingData = await loadEnvFileAsync2({ envPath: absolutePath });
     } catch {}
   }
   const finalData = { ...existingData, ...data };
@@ -1308,48 +1314,48 @@ var saveEnvFileAsync = async ({
 };
 
 // ../auth/src/loginStatus.ts
-var CredentialSource;
-((CredentialSource2) => {
-  CredentialSource2["SavedLogin"] = "saved-login";
-  CredentialSource2["Robot"] = "robot";
-  CredentialSource2["EnvironmentVariables"] = "env-vars";
-})(CredentialSource ||= {});
+var CredentialSource2;
+((CredentialSource) => {
+  CredentialSource["SavedLogin"] = "saved-login";
+  CredentialSource["Robot"] = "robot";
+  CredentialSource["EnvironmentVariables"] = "env-vars";
+})(CredentialSource2 ||= {});
 var defaultRobotTenantIdCache = new Map;
 var ROBOT_TENANT_LOOKUP_TIMEOUT_MS = 5000;
-var getLoginStatusAsync = async (options = {}) => {
-  return getLoginStatusWithDeps(options);
+var getLoginStatusAsync2 = async (options = {}) => {
+  return getLoginStatusWithDeps2(options);
 };
-var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
+var getLoginStatusWithDeps2 = async (options = {}, deps = {}) => {
   const {
-    resolveEnvFilePath = resolveEnvFilePathAsync,
-    loadEnvFile = loadEnvFileAsync,
-    saveEnvFile = saveEnvFileAsync,
-    getFs = getFileSystem,
-    refreshToken: refreshTokenFn = refreshAccessToken,
+    resolveEnvFilePath = resolveEnvFilePathAsync2,
+    loadEnvFile = loadEnvFileAsync2,
+    saveEnvFile = saveEnvFileAsync2,
+    getFs = getFileSystem2,
+    refreshToken: refreshTokenFn = refreshAccessToken2,
     resolveConfig = resolveConfigAsync,
     robotFallback = tryRobotClientFallback,
-    fetchTenantsAndOrgs = fetchTenantsAndOrganizations,
+    fetchTenantsAndOrgs = fetchTenantsAndOrganizations2,
     robotTenantIdCache = defaultRobotTenantIdCache,
     robotTenantLookupTimeoutMs = ROBOT_TENANT_LOOKUP_TIMEOUT_MS,
-    loadBreaker = loadRefreshBreaker,
-    saveBreaker = saveRefreshBreaker,
-    clearBreaker = clearRefreshBreaker
+    loadBreaker = loadRefreshBreaker2,
+    saveBreaker = saveRefreshBreaker2,
+    clearBreaker = clearRefreshBreaker2
   } = deps;
   const robotDeps = {
     fetchTenantsAndOrgs,
     cache: robotTenantIdCache,
     lookupTimeoutMs: robotTenantLookupTimeoutMs
   };
-  if (isRobotAuthEnforced()) {
+  if (isRobotAuthEnforced2()) {
     return resolveRobotEnforcedStatus(robotFallback, robotDeps);
   }
-  if (isEnvAuthEnabled()) {
-    return readAuthFromEnv();
+  if (isEnvAuthEnabled2()) {
+    return readAuthFromEnv2();
   }
-  const activeProfile = getActiveAuthProfile();
-  const activeProfileFilePath = getActiveAuthProfileFilePath();
+  const activeProfile = getActiveAuthProfile2();
+  const activeProfileFilePath = getActiveAuthProfileFilePath2();
   const usingActiveProfile = activeProfile !== undefined && (options.envFilePath === undefined || options.envFilePath === activeProfileFilePath);
-  const envFilePath = options.envFilePath ?? activeProfileFilePath ?? DEFAULT_ENV_FILENAME;
+  const envFilePath = options.envFilePath ?? activeProfileFilePath ?? DEFAULT_ENV_FILENAME2;
   const { ensureTokenValidityMinutes } = options;
   const { absolutePath } = await resolveEnvFilePath(envFilePath);
   if (absolutePath === undefined) {
@@ -1402,14 +1408,14 @@ var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
   return buildFileStatus(tokens, credentials, globalHint);
 };
 async function resolveRobotEnforcedStatus(robotFallback, deps) {
-  if (isEnvAuthEnabled()) {
-    throw new EnvAuthConfigError(`${ENV_AUTH_ENABLE_VAR}=true and ${ENFORCE_ROBOT_AUTH_VAR}=true ` + `are mutually exclusive. Unset one of them and re-run.`);
+  if (isEnvAuthEnabled2()) {
+    throw new EnvAuthConfigError2(`${ENV_AUTH_ENABLE_VAR2}=true and ${ENFORCE_ROBOT_AUTH_VAR2}=true ` + `are mutually exclusive. Unset one of them and re-run.`);
   }
   const robotCreds = await robotFallback({ force: true });
   if (!robotCreds) {
     return {
       loginStatus: "Not logged in",
-      hint: `${ENFORCE_ROBOT_AUTH_VAR}=true but the UiPath Robot ` + `session is unavailable. Start and sign in to the Assistant, ` + `or unset ${ENFORCE_ROBOT_AUTH_VAR} to fall back to file or ` + `env-var authentication.`
+      hint: `${ENFORCE_ROBOT_AUTH_VAR2}=true but the UiPath Robot ` + `session is unavailable. Start and sign in to the Assistant, ` + `or unset ${ENFORCE_ROBOT_AUTH_VAR2} to fall back to file or ` + `env-var authentication.`
     };
   }
   return buildRobotStatus(robotCreds, deps);
@@ -1544,16 +1550,16 @@ async function buildFileStatus(tokens, credentials, globalHint) {
   return result;
 }
 function identityFields(accessToken, credentials) {
-  const identity = resolveSessionIdentity(accessToken, parseAuthFlow(credentials[AUTH_FLOW_ENV_VAR]));
-  const scopes = readTokenScopes(accessToken);
+  const identity = resolveSessionIdentity2(accessToken, parseAuthFlow2(credentials[AUTH_FLOW_ENV_VAR2]));
+  const scopes = readTokenScopes2(accessToken);
   return {
     ...identity ? { identity } : {},
     ...scopes ? { scopes } : {}
   };
 }
 async function buildRobotStatus(robotCreds, deps) {
-  const identity = resolveSessionIdentity(robotCreds.accessToken);
-  const scopes = readTokenScopes(robotCreds.accessToken);
+  const identity = resolveSessionIdentity2(robotCreds.accessToken);
+  const scopes = readTokenScopes2(robotCreds.accessToken);
   const tenant = robotCreds.tenantId ? { tenantId: robotCreds.tenantId } : await resolveRobotTenantId(robotCreds, deps);
   return {
     loginStatus: "Logged in",
@@ -1634,7 +1640,7 @@ async function circuitBreakerShortCircuit(ctx) {
     saveBreaker,
     clearBreaker
   } = ctx;
-  const fingerprint = await refreshTokenFingerprint(refreshToken);
+  const fingerprint = await refreshTokenFingerprint2(refreshToken);
   const breaker = await loadBreaker(absolutePath).catch(() => ({}));
   if (breaker.deadTokenFp && breaker.deadTokenFp !== fingerprint) {
     await clearBreaker(absolutePath);
@@ -1767,10 +1773,10 @@ async function runRefreshLocked(inputs) {
     refreshedAccess = refreshed.accessToken;
     refreshedRefresh = refreshed.refreshToken;
   } catch (error) {
-    const isOAuthFailure = isTokenRefreshOAuthFailure(error);
+    const isOAuthFailure = isTokenRefreshOAuthFailure2(error);
     const hint = isOAuthFailure ? "Run 'uip login' to re-authenticate — the stored refresh token is invalid or expired. In a non-interactive context, authenticate with: uip login --client-id <id> --client-secret <secret> -t <tenant>." : "Token refresh failed. Check your network connection, then retry or run 'uip login' to re-authenticate.";
     const message = isOAuthFailure ? normalizeTokenRefreshFailure() : normalizeTokenRefreshUnavailableFailure();
-    const fp = await refreshTokenFingerprint(tokenForIdP);
+    const fp = await refreshTokenFingerprint2(tokenForIdP);
     if (isOAuthFailure) {
       await saveBreaker(absolutePath, { deadTokenFp: fp });
     } else {
@@ -1855,26 +1861,38 @@ function errorMessage(error) {
 }
 
 // ../auth/src/authContext.ts
-var getAuthContext = async (options = {}) => {
-  const status = await getLoginStatusAsync({
+class AuthContextUnavailableError2 extends Error {
+  instructionContext;
+  sessionHint;
+  errorCode = "authentication_required";
+  retry = "RetryWillNotFix";
+  constructor(message, instructionContext = "auth", sessionHint) {
+    super(message);
+    this.instructionContext = instructionContext;
+    this.sessionHint = sessionHint;
+    this.name = "AuthContextUnavailableError";
+  }
+}
+var getAuthContext2 = async (options = {}) => {
+  const status = await getLoginStatusAsync2({
     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.");
+    throw new AuthContextUnavailableError2(status.hint ? `Not logged in. ${status.hint}` : "Not logged in. Run 'uip login' first.", "auth", status.hint);
   }
-  const tenantName = options.tenant ?? status.tenantName;
+  const tenantName = options.tenant || status.tenantName;
   if (options.requireOrganizationId && !status.organizationId) {
-    throw new Error("Organization ID not available. Ensure you are logged in with an organization context.");
+    throw new AuthContextUnavailableError2("Organization ID not available. Ensure you are logged in with an organization context.", "identity");
   }
   if (options.requireOrganizationName && !status.organizationName) {
-    throw new Error("Organization name not available. Ensure you are logged in with an organization context.");
+    throw new AuthContextUnavailableError2("Organization name not available. Ensure you are logged in with an organization context.", "identity");
   }
   if (options.requireTenantId && !status.tenantId) {
-    throw new Error("Tenant ID not available. Ensure UIPATH_TENANT_ID is set.");
+    throw new AuthContextUnavailableError2(`Tenant ID not available. Ensure UIPATH_TENANT_ID is set.${status.hint ? ` ${status.hint}` : ""}`, "identity", status.hint);
   }
-  if (options.requireTenantName && tenantName === undefined) {
-    throw new Error("Tenant not provided and UIPATH_TENANT_NAME not set. Run 'uip login' to select a tenant, or use 'uip login tenant set <tenant>' to switch tenants.");
+  if (options.requireTenantName && !tenantName) {
+    throw new AuthContextUnavailableError2("Tenant not provided and UIPATH_TENANT_NAME not set. Run 'uip login' to select a tenant, or use 'uip login tenant set <tenant>' to switch tenants.", "identity");
   }
   return {
     baseUrl: status.baseUrl,
@@ -1886,11 +1904,11 @@ var getAuthContext = async (options = {}) => {
     identity: status.identity
   };
 };
-var getAuthEnv = async (options = {}) => {
+var getAuthEnv2 = async (options = {}) => {
   const authEnv = {};
   let status;
   try {
-    status = await getLoginStatusAsync(options);
+    status = await getLoginStatusAsync2(options);
   } catch {
     return { authEnv };
   }
@@ -1900,7 +1918,7 @@ var getAuthEnv = async (options = {}) => {
       const org = status.organizationName || status.organizationId;
       const tenant = status.tenantName || status.tenantId;
       if (org && tenant) {
-        authEnv.UIPATH_URL = `${status.baseUrl.replace(/\/+$/, "")}/${org}/${tenant}`;
+        authEnv.UIPATH_URL = `${status.baseUrl.replace(/\/+$/, "")}/${encodeURIComponent(org)}/${encodeURIComponent(tenant)}`;
       }
     }
     if (status.organizationId)
@@ -1941,7 +1959,7 @@ async function describeAuthProfileAsync(name, filePath, active) {
   if (!filePath) {
     return { ...base, status: "Not logged in" };
   }
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   const [readError, content] = await catchError(fs.readFile(filePath, "utf-8"));
   if (readError) {
     return { ...base, status: "Unreadable" };
@@ -1958,14 +1976,14 @@ async function describeAuthProfileAsync(name, filePath, active) {
     ...statusFromToken(values[ACCESS_TOKEN_KEY])
   };
 }
-async function describeAuthProfilesAsync() {
-  const activeProfile = getActiveAuthProfile();
-  const [defaultPathError, defaultLocation] = await catchError(resolveEnvFilePathAsync());
+async function describeAuthProfilesAsync2() {
+  const activeProfile = getActiveAuthProfile2();
+  const [defaultPathError, defaultLocation] = await catchError(resolveEnvFilePathAsync2());
   const rows = [
-    await describeAuthProfileAsync(DEFAULT_AUTH_PROFILE, defaultPathError ? undefined : defaultLocation?.absolutePath, activeProfile === undefined)
+    await describeAuthProfileAsync(DEFAULT_AUTH_PROFILE2, defaultPathError ? undefined : defaultLocation?.absolutePath, activeProfile === undefined)
   ];
-  for (const name of await listAuthProfileNamesAsync()) {
-    rows.push(await describeAuthProfileAsync(name, resolveAuthProfileFilePath(name), activeProfile === name));
+  for (const name of await listAuthProfileNamesAsync2()) {
+    rows.push(await describeAuthProfileAsync(name, resolveAuthProfileFilePath2(name), activeProfile === name));
   }
   return rows;
 }
@@ -2013,7 +2031,7 @@ var requestClientCredentialsToken = async ({
 };
 
 // ../auth/src/clientCredentials.ts
-class ClientCredentialsAuthenticationError extends Error {
+class ClientCredentialsAuthenticationError2 extends Error {
   status;
   constructor(message, status) {
     super(message);
@@ -2042,11 +2060,11 @@ Troubleshooting:` + `
   • The requested scopes may not be available for your account` + `
   • Try using default scopes or contact your UiPath administrator`;
   }
-  return new ClientCredentialsAuthenticationError(`Client Credentials authentication failed (${status})
+  return new ClientCredentialsAuthenticationError2(`Client Credentials authentication failed (${status})
 ` + `Error: ${errorType}
 ` + `Details: ${errorDesc}${troubleshooting}`, status);
 };
-var clientCredentialsLogin = async ({
+var clientCredentialsLogin2 = async ({
   clientId,
   clientSecret,
   scope,
@@ -2074,9 +2092,9 @@ var clientCredentialsLogin = async ({
   });
 };
 // ../auth/src/federatedCredentials.ts
-var JWT_BEARER_ASSERTION_TYPE = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer";
+var JWT_BEARER_ASSERTION_TYPE2 = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer";
 
-class FederatedCredentialsAuthenticationError extends Error {
+class FederatedCredentialsAuthenticationError2 extends Error {
   status;
   constructor(message, status) {
     super(message);
@@ -2107,11 +2125,11 @@ Troubleshooting:` + `
   • The requested scopes may not be available for your application` + `
   • Try using default scopes or contact your UiPath administrator`;
   }
-  return new FederatedCredentialsAuthenticationError(`Federated Credentials authentication failed (${status})
+  return new FederatedCredentialsAuthenticationError2(`Federated Credentials authentication failed (${status})
 ` + `Error: ${errorType}
 ` + `Details: ${errorDesc}${troubleshooting}`, status);
 };
-var federatedCredentialsLogin = async ({
+var federatedCredentialsLogin2 = async ({
   clientId,
   clientAssertion,
   scope,
@@ -2127,7 +2145,7 @@ var federatedCredentialsLogin = async ({
     grant_type: "client_credentials",
     client_id: config.clientId,
     client_assertion: clientAssertion,
-    client_assertion_type: JWT_BEARER_ASSERTION_TYPE
+    client_assertion_type: JWT_BEARER_ASSERTION_TYPE2
   };
   if (config.scopes.length > 0) {
     params.scope = config.scopes.join(" ");
@@ -2140,10 +2158,10 @@ var federatedCredentialsLogin = async ({
   });
 };
 // ../auth/src/selectTenant.ts
-var TENANT_SELECTION_REQUIRED_CODE = "TENANT_SELECTION_REQUIRED";
-var INVALID_TENANT_CODE = "INVALID_TENANT";
+var TENANT_SELECTION_REQUIRED_CODE2 = "TENANT_SELECTION_REQUIRED";
+var INVALID_TENANT_CODE2 = "INVALID_TENANT";
 
-class TenantSelectionError extends Error {
+class TenantSelectionError2 extends Error {
   availableTenants;
   organizationName;
   constructor(message, organizationName, availableTenants) {
@@ -2153,16 +2171,16 @@ class TenantSelectionError extends Error {
   }
 }
 
-class TenantSelectionRequiredError extends TenantSelectionError {
-  code = TENANT_SELECTION_REQUIRED_CODE;
+class TenantSelectionRequiredError2 extends TenantSelectionError2 {
+  code = TENANT_SELECTION_REQUIRED_CODE2;
   constructor(organizationName, availableTenants) {
     super(`Multiple tenants available in organization "${organizationName}"; none selected.`, organizationName, availableTenants);
     this.name = "TenantSelectionRequiredError";
   }
 }
 
-class InvalidTenantError extends TenantSelectionError {
-  code = INVALID_TENANT_CODE;
+class InvalidTenantError2 extends TenantSelectionError2 {
+  code = INVALID_TENANT_CODE2;
   requestedTenant;
   constructor(requestedTenant, organizationName, availableTenants) {
     super(`Invalid tenant requested: "${requestedTenant}"
@@ -2173,19 +2191,19 @@ class InvalidTenantError extends TenantSelectionError {
   }
 }
 var TENANT_SELECTION_CODES = new Set([
-  TENANT_SELECTION_REQUIRED_CODE,
-  INVALID_TENANT_CODE
+  TENANT_SELECTION_REQUIRED_CODE2,
+  INVALID_TENANT_CODE2
 ]);
-function isTenantSelectionError(error) {
+function isTenantSelectionError2(error) {
   if (!(error instanceof Object) || !("code" in error)) {
     return false;
   }
   const code = error.code;
   return typeof code === "string" && TENANT_SELECTION_CODES.has(code) && Array.isArray(error.availableTenants);
 }
-var selectTenantWithDeps = async (baseUrl, accessToken, organizationId, targetTenantName, interactive, deps = {}) => {
+var selectTenantWithDeps2 = async (baseUrl, accessToken, organizationId, targetTenantName, interactive, deps = {}) => {
   const {
-    fetchTenantsAndOrgs = fetchTenantsAndOrganizations,
+    fetchTenantsAndOrgs = fetchTenantsAndOrganizations2,
     selectFromList
   } = deps;
   const data = await fetchTenantsAndOrgs(baseUrl, accessToken, organizationId);
@@ -2198,7 +2216,7 @@ var selectTenantWithDeps = async (baseUrl, accessToken, organizationId, targetTe
   if (targetTenantName !== undefined) {
     selectedIndex = tenants.findIndex((tenant) => tenant.name === targetTenantName);
     if (selectedIndex === -1) {
-      throw new InvalidTenantError(targetTenantName, organization.name, tenantNames);
+      throw new InvalidTenantError2(targetTenantName, organization.name, tenantNames);
     }
   } else if (tenants.length === 1) {
     selectedIndex = 0;
@@ -2208,25 +2226,25 @@ var selectTenantWithDeps = async (baseUrl, accessToken, organizationId, targetTe
     }
     selectedIndex = await selectFromList(tenantNames, "Select a tenant:");
   } else {
-    throw new TenantSelectionRequiredError(organization.name, tenantNames);
+    throw new TenantSelectionRequiredError2(organization.name, tenantNames);
   }
   const selectedTenant = tenants[selectedIndex];
   return [selectedTenant.name, selectedTenant.id, organization.name];
 };
 
 // ../auth/src/interactive.ts
-var interactiveLoginWithDeps = async (options, deps) => {
+var interactiveLoginWithDeps2 = async (options, deps) => {
   const {
     resolveConfig = resolveConfigAsync,
-    clientCredentials = clientCredentialsLogin,
-    federatedCredentials = federatedCredentialsLogin,
-    auth = authenticate,
-    saveEnvFile = saveEnvFileAsync,
-    loadEnvFile = loadEnvFileAsync,
-    getFs = getFileSystem,
-    jwtParser = parseJWT,
+    clientCredentials = clientCredentialsLogin2,
+    federatedCredentials = federatedCredentialsLogin2,
+    auth = authenticate2,
+    saveEnvFile = saveEnvFileAsync2,
+    loadEnvFile = loadEnvFileAsync2,
+    getFs = getFileSystem2,
+    jwtParser = parseJWT2,
     issuerAsserter = assertIssuerMatchesAuthority,
-    tenantSelector = (baseUrl, accessToken, organizationId, tenantName, interactive2) => selectTenantWithDeps(baseUrl, accessToken, organizationId, tenantName, interactive2, { selectFromList: options.selectFromList })
+    tenantSelector = (baseUrl, accessToken, organizationId, tenantName, interactive) => selectTenantWithDeps2(baseUrl, accessToken, organizationId, tenantName, interactive, { selectFromList: options.selectFromList })
   } = deps;
   const {
     envFilePath,
@@ -2311,7 +2329,7 @@ var interactiveLoginWithDeps = async (options, deps) => {
   const credentials = {
     ...tokens,
     UIPATH_URL: config.baseUrl,
-    [AUTH_FLOW_ENV_VAR]: authFlow
+    [AUTH_FLOW_ENV_VAR2]: authFlow
   };
   if (authFlow !== "authorization_code") {
     credentials.UIPATH_REFRESH_TOKEN = undefined;
@@ -2331,7 +2349,7 @@ var interactiveLoginWithDeps = async (options, deps) => {
     credentials.UIPATH_TENANT_NAME = tenantName;
     credentials.UIPATH_TENANT_ID = tenantId;
   } catch (error) {
-    if (!isTenantSelectionError(error)) {
+    if (!isTenantSelectionError2(error)) {
       emit({
         type: "tenant-fetch-failed",
         message: error instanceof Error ? error.message : String(error)
@@ -2340,7 +2358,7 @@ var interactiveLoginWithDeps = async (options, deps) => {
     throw error;
   }
   const fs = getFs();
-  const requestedPath = envFilePath ?? DEFAULT_ENV_FILENAME;
+  const requestedPath = envFilePath ?? DEFAULT_ENV_FILENAME2;
   let savePath = requestedPath;
   let savedLocally = false;
   if (!fs.path.isAbsolute(savePath)) {
@@ -2366,8 +2384,12 @@ var interactiveLoginWithDeps = async (options, deps) => {
       searchDir = parentDir;
     }
   }
+  if (!fs.path.isAbsolute(savePath)) {
+    savePath = fs.path.join(fs.env.homedir(), savePath);
+  }
   let saveRelease;
   try {
+    await fs.mkdir(fs.path.dirname(savePath));
     if (typeof fs.acquireLock === "function") {
       saveRelease = await fs.acquireLock(savePath);
     }
@@ -2385,24 +2407,23 @@ var interactiveLoginWithDeps = async (options, deps) => {
       await saveRelease().catch(() => {});
     }
   }
-  const reportedPath = fs.path.isAbsolute(savePath) ? savePath : fs.path.join(fs.env.homedir(), savePath);
   emit({
     type: "saved",
-    path: reportedPath,
+    path: savePath,
     locality: savedLocally ? "local" : "global"
   });
   return credentials;
 };
-var interactiveLogin = async (options) => {
-  return interactiveLoginWithDeps(options, {});
+var interactiveLogin2 = async (options) => {
+  return interactiveLoginWithDeps2(options, {});
 };
 // ../auth/src/logout.ts
-async function logoutWithDeps(options, deps = {}) {
+async function logoutWithDeps2(options, deps = {}) {
   const {
-    resolveEnvFilePath = resolveEnvFilePathAsync,
-    getFileSystem: getFs = getFileSystem,
-    clearBreaker = clearRefreshBreaker,
-    getActiveProfileFilePath = getActiveAuthProfileFilePath
+    resolveEnvFilePath = resolveEnvFilePathAsync2,
+    getFileSystem: getFs = getFileSystem2,
+    clearBreaker = clearRefreshBreaker2,
+    getActiveProfileFilePath = getActiveAuthProfileFilePath2
   } = deps;
   const fs = getFs();
   const { absolutePath } = await resolveEnvFilePath(options.file ?? getActiveProfileFilePath());
@@ -2435,12 +2456,12 @@ async function logoutWithDeps(options, deps = {}) {
     reason: "no_credentials_file"
   };
 }
-async function logout(options) {
-  return logoutWithDeps(options);
+async function logout2(options) {
+  return logoutWithDeps2(options);
 }
 
 // ../auth/src/index.ts
-var authenticate = async ({
+var authenticate2 = async ({
   baseUrl,
   clientId,
   clientSecret,
@@ -2470,7 +2491,7 @@ var authenticate = async ({
   let effectiveRedirectUri;
   if (redirectUri) {
     effectiveRedirectUri = redirectUri.toString();
-  } else if (isBrowser()) {
+  } else if (isBrowser2()) {
     const origin = getGlobalThis()?.window?.location?.origin ?? "";
     effectiveRedirectUri = `${origin}/oidc/login`;
   } else {
@@ -2494,11 +2515,11 @@ var authenticate = async ({
   }
   const authUrl = `${authorizationEndpoint}?${authParams.toString()}`;
   let strategy;
-  if (isBrowser()) {
-    const { BrowserAuthStrategy } = await import("./browser-strategy-6atc7v8s.js");
+  if (isBrowser2()) {
+    const { BrowserAuthStrategy } = await import("./browser-strategy-627rrg7z.js");
     strategy = new BrowserAuthStrategy;
   } else {
-    const { NodeAuthStrategy } = await import("./node-strategy-v442hwgd.js");
+    const { NodeAuthStrategy } = await import("./node-strategy-2mqzg36t.js");
     strategy = new NodeAuthStrategy;
   }
   const code = await strategy.execute(authUrl, effectiveRedirectUriUrl, state, {
@@ -2518,6 +2539,6 @@ var authenticate = async ({
   });
 };
 
-export { setAuthFileConfig, InvalidBaseUrlError, DEFAULT_AUTH_PROFILE, AuthProfileValidationError, normalizeAuthProfileName, setActiveAuthProfile, clearActiveAuthProfile, getActiveAuthProfile, runWithAuthProfile, resolveAuthProfileFilePath, getActiveAuthProfileFilePath, getAuthProfilesRootPath, resolveAuthProfileDirPath, listAuthProfileNamesAsync, authProfileExistsAsync, deleteAuthProfileAsync, parseJWT, parseAuthFlow, resolveSessionIdentity, readTokenScopes, ENV_AUTH_ENABLE_VAR, ENFORCE_ROBOT_AUTH_VAR, ENV_AUTH_VARS, EnvAuthConfigError, isEnvAuthEnabled, isRobotAuthEnforced, readAuthFromEnv, refreshTokenFingerprint, loadRefreshBreaker, saveRefreshBreaker, clearRefreshBreaker, registerRobotClientLoader, fetchTenantsAndOrganizations, TokenRefreshOAuthError, isTokenRefreshOAuthFailure, refreshAccessToken, AUTH_FLOW_ENV_VAR, DEFAULT_AUTH_FILENAME, DEFAULT_ENV_FILENAME, resolveEnvFileLocationAsync, resolveEnvFilePathAsync, loadEnvFileAsync, saveEnvFileAsync, CredentialSource, getLoginStatusAsync, getLoginStatusWithDeps, getAuthContext, getAuthEnv, describeAuthProfilesAsync, ClientCredentialsAuthenticationError, clientCredentialsLogin, JWT_BEARER_ASSERTION_TYPE, FederatedCredentialsAuthenticationError, federatedCredentialsLogin, TENANT_SELECTION_REQUIRED_CODE, INVALID_TENANT_CODE, TenantSelectionError, TenantSelectionRequiredError, InvalidTenantError, isTenantSelectionError, selectTenantWithDeps, interactiveLoginWithDeps, interactiveLogin, logoutWithDeps, logout, authenticate };
+export { setAuthFileConfig2, InvalidBaseUrlError2, DEFAULT_AUTH_PROFILE2, INHERITED_AUTH_PROFILE_ENV2, AuthProfileValidationError2, normalizeAuthProfileName2, setActiveAuthProfile2, clearActiveAuthProfile2, getActiveAuthProfile2, runWithAuthProfile2, resolveAuthProfileFilePath2, getActiveAuthProfileFilePath2, getAuthProfilesRootPath2, resolveAuthProfileDirPath2, listAuthProfileNamesAsync2, authProfileExistsAsync2, deleteAuthProfileAsync2, parseJWT2, parseAuthFlow2, resolveSessionIdentity2, readTokenScopes2, ENV_AUTH_ENABLE_VAR2, ENFORCE_ROBOT_AUTH_VAR2, ENV_AUTH_VARS2, EnvAuthConfigError2, isEnvAuthEnabled2, isRobotAuthEnforced2, readAuthFromEnv2, refreshTokenFingerprint2, loadRefreshBreaker2, saveRefreshBreaker2, clearRefreshBreaker2, registerRobotClientLoader2, fetchTenantsAndOrganizations2, TokenRefreshOAuthError2, isTokenRefreshOAuthFailure2, refreshAccessToken2, AUTH_FLOW_ENV_VAR2, DEFAULT_AUTH_FILENAME2, DEFAULT_ENV_FILENAME2, resolveEnvFileLocationAsync2, resolveEnvFilePathAsync2, loadEnvFileAsync2, saveEnvFileAsync2, CredentialSource2, getLoginStatusAsync2, getLoginStatusWithDeps2, AuthContextUnavailableError2, getAuthContext2, getAuthEnv2, describeAuthProfilesAsync2, ClientCredentialsAuthenticationError2, clientCredentialsLogin2, JWT_BEARER_ASSERTION_TYPE2, FederatedCredentialsAuthenticationError2, federatedCredentialsLogin2, TENANT_SELECTION_REQUIRED_CODE2, INVALID_TENANT_CODE2, TenantSelectionError2, TenantSelectionRequiredError2, InvalidTenantError2, isTenantSelectionError2, selectTenantWithDeps2, interactiveLoginWithDeps2, interactiveLogin2, logoutWithDeps2, logout2, authenticate2 };
 
-//# debugId=7292022086A0BDF264756E2164756E21
+//# debugId=2A9B3B8B0AC5890564756E2164756E21