@uipath/flow-tool 1.205.0-preview.276 → 1.206.0-preview.279

package/dist/{packager-tool-kn86394c.js → packager-tool-p123mtfx.js}

@@ -1,30 +1,27 @@
 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-1qg04b7q.js";
 import {
   getFileSystem
-} from "./packager-tool-myhbp761.js";
+} from "./packager-tool-vgrswa8p.js";
+import {
+  isBrowser2,
+  getGlobalThis
+} from "./packager-tool-zdqbp34f.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) => {
-  globalSlot[AUTH_FILE_CONFIG_KEY] = cfg ?? {};
-};
 var getAuthFileConfig = () => globalSlot[AUTH_FILE_CONFIG_KEY] ?? {};
 
 class InvalidBaseUrlError extends Error {
@@ -289,14 +286,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) {
@@ -464,6 +461,7 @@ var exchangeCodeForTokens = async ({
 
 // ../auth/src/authProfile.ts
 var DEFAULT_AUTH_PROFILE = "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");
@@ -510,42 +508,13 @@ function normalizeAuthProfileName(profile) {
   }
   return profile;
 }
-function setActiveAuthProfile(profile) {
-  const normalized = normalizeAuthProfileName(profile);
-  const scopedState = profileStorage.getStore();
-  if (scopedState !== undefined) {
-    if (normalized === undefined) {
-      delete scopedState.profile;
-      return;
-    }
-    scopedState.profile = normalized;
-    return;
-  }
-  if (normalized === undefined) {
-    delete globalSlot2[ACTIVE_AUTH_PROFILE_KEY];
-    return;
-  }
-  globalSlot2[ACTIVE_AUTH_PROFILE_KEY] = { profile: normalized };
-}
-function clearActiveAuthProfile() {
-  const scopedState = profileStorage.getStore();
-  if (scopedState !== undefined) {
-    delete scopedState.profile;
-    return;
-  }
-  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);
-  return profileStorage.run(normalized === undefined ? {} : { profile: normalized }, fn);
-}
 function resolveAuthProfileFilePath(profile) {
   const normalized = normalizeAuthProfileName(profile);
   if (normalized === undefined) {
@@ -555,66 +524,9 @@ function resolveAuthProfileFilePath(profile) {
   return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, PROFILE_DIR, normalized, AUTH_FILENAME);
 }
 function getActiveAuthProfileFilePath() {
-  const profile = getActiveAuthProfile();
+  const profile = getActiveAuthProfile2();
   return profile ? resolveAuthProfileFilePath(profile) : undefined;
 }
-function getAuthProfilesRootPath() {
-  const fs = getFileSystem();
-  return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, PROFILE_DIR);
-}
-function resolveAuthProfileDirPath(profile) {
-  const normalized = normalizeAuthProfileName(profile);
-  if (normalized === undefined) {
-    throw new AuthProfileValidationError(`"${DEFAULT_AUTH_PROFILE}" is the built-in profile and does not have a profile directory.`);
-  }
-  const fs = getFileSystem();
-  return fs.path.join(getAuthProfilesRootPath(), normalized);
-}
-async function listAuthProfileNamesAsync() {
-  const fs = getFileSystem();
-  const root = getAuthProfilesRootPath();
-  if (!await fs.exists(root)) {
-    return [];
-  }
-  const [readError, entries] = await catchError(fs.readdir(root));
-  if (readError || !entries) {
-    return [];
-  }
-  const names = [];
-  for (const entry of entries) {
-    if (!PROFILE_NAME_RE.test(entry) || entry === DEFAULT_AUTH_PROFILE) {
-      continue;
-    }
-    const stats = await fs.stat(fs.path.join(root, entry));
-    if (stats?.isDirectory()) {
-      names.push(entry);
-    }
-  }
-  return names.sort((a, b) => a.localeCompare(b));
-}
-async function authProfileExistsAsync(profile) {
-  const fs = getFileSystem();
-  const [pathError, dir] = catchError(() => resolveAuthProfileDirPath(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);
-  if (relativeToRoot === "" || relativeToRoot.startsWith("..") || fs.path.isAbsolute(relativeToRoot)) {
-    throw new AuthProfileValidationError(`Refusing to delete "${profile}": resolved path escapes the profiles directory.`);
-  }
-  const stats = await fs.stat(dir);
-  if (stats?.isDirectory() !== true) {
-    return;
-  }
-  await fs.rm(dir);
-  return dir;
-}
 
 // ../auth/src/utils/jwt.ts
 class InvalidIssuerError extends Error {
@@ -641,7 +553,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();
@@ -737,7 +649,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);
@@ -782,6 +694,8 @@ var ENV_AUTH_VARS = {
 };
 
 class EnvAuthConfigError extends Error {
+  errorCode = "configuration_error";
+  retry = "RetryWillNotFix";
   constructor(message) {
     super(message);
     this.name = "EnvAuthConfigError";
@@ -820,11 +734,11 @@ var readAuthFromEnv = () => {
     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}).`);
     }
-    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,
@@ -840,7 +754,7 @@ var readAuthFromEnv = () => {
   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 identity = resolveSessionIdentity2(accessToken);
   const scopes = readTokenScopes(accessToken);
   return {
     loginStatus,
@@ -969,9 +883,6 @@ var parseResourceUrl = (url) => {
   };
 };
 var ROBOT_CLIENT_LOADER_KEY = Symbol.for("@uipath/auth/RobotClientLoader");
-var registerRobotClientLoader = (loader) => {
-  globalThis[ROBOT_CLIENT_LOADER_KEY] = loader;
-};
 var getRegisteredRobotClientLoader = () => {
   const loader = globalThis[ROBOT_CLIENT_LOADER_KEY];
   return typeof loader === "function" ? loader : undefined;
@@ -988,7 +899,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) {
@@ -1127,9 +1038,12 @@ var refreshAccessToken = async ({
     body: tokenParams
   });
   const tokenData = await tokenResponse.json();
-  if (!tokenResponse.ok) {
+  if (tokenResponse.status === 400 || tokenResponse.status === 401) {
     throw new TokenRefreshOAuthError;
   }
+  if (!tokenResponse.ok) {
+    throw new Error(`Token refresh failed: HTTP ${tokenResponse.status}`);
+  }
   const newAccessToken = tokenData.access_token;
   const newRefreshToken = tokenData.refresh_token;
   if (typeof newAccessToken !== "string" || typeof newRefreshToken !== "string") {
@@ -1145,7 +1059,6 @@ var refreshAccessToken = async ({
 var AUTH_FLOW_ENV_VAR = "UIPATH_AUTH_FLOW";
 
 // ../auth/src/utils/envFile.ts
-var DEFAULT_AUTH_FILENAME = AUTH_FILENAME;
 var DEFAULT_ENV_FILENAME = `${UIPATH_HOME_DIR}/${AUTH_FILENAME}`;
 var KNOWN_ERROR_CODES = new Set([
   "EISDIR",
@@ -1193,20 +1106,20 @@ var probeAsync = async (fs, candidate) => {
 var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
   const fs = getFileSystem();
   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,
@@ -1308,15 +1221,9 @@ var saveEnvFileAsync = async ({
 };
 
 // ../auth/src/loginStatus.ts
-var CredentialSource;
-((CredentialSource2) => {
-  CredentialSource2["SavedLogin"] = "saved-login";
-  CredentialSource2["Robot"] = "robot";
-  CredentialSource2["EnvironmentVariables"] = "env-vars";
-})(CredentialSource ||= {});
 var defaultRobotTenantIdCache = new Map;
 var ROBOT_TENANT_LOOKUP_TIMEOUT_MS = 5000;
-var getLoginStatusAsync = async (options = {}) => {
+var getLoginStatusAsync2 = async (options = {}) => {
   return getLoginStatusWithDeps(options);
 };
 var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
@@ -1346,7 +1253,7 @@ var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
   if (isEnvAuthEnabled()) {
     return readAuthFromEnv();
   }
-  const activeProfile = getActiveAuthProfile();
+  const activeProfile = getActiveAuthProfile2();
   const activeProfileFilePath = getActiveAuthProfileFilePath();
   const usingActiveProfile = activeProfile !== undefined && (options.envFilePath === undefined || options.envFilePath === activeProfileFilePath);
   const envFilePath = options.envFilePath ?? activeProfileFilePath ?? DEFAULT_ENV_FILENAME;
@@ -1544,7 +1451,7 @@ async function buildFileStatus(tokens, credentials, globalHint) {
   return result;
 }
 function identityFields(accessToken, credentials) {
-  const identity = resolveSessionIdentity(accessToken, parseAuthFlow(credentials[AUTH_FLOW_ENV_VAR]));
+  const identity = resolveSessionIdentity2(accessToken, parseAuthFlow(credentials[AUTH_FLOW_ENV_VAR]));
   const scopes = readTokenScopes(accessToken);
   return {
     ...identity ? { identity } : {},
@@ -1552,7 +1459,7 @@ function identityFields(accessToken, credentials) {
   };
 }
 async function buildRobotStatus(robotCreds, deps) {
-  const identity = resolveSessionIdentity(robotCreds.accessToken);
+  const identity = resolveSessionIdentity2(robotCreds.accessToken);
   const scopes = readTokenScopes(robotCreds.accessToken);
   const tenant = robotCreds.tenantId ? { tenantId: robotCreds.tenantId } : await resolveRobotTenantId(robotCreds, deps);
   return {
@@ -1855,26 +1762,38 @@ function errorMessage(error) {
 }
 
 // ../auth/src/authContext.ts
-var getAuthContext = async (options = {}) => {
-  const status = await getLoginStatusAsync({
+class AuthContextUnavailableError 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 AuthContextUnavailableError(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 AuthContextUnavailableError("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 AuthContextUnavailableError("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 AuthContextUnavailableError(`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 AuthContextUnavailableError("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,561 +1805,16 @@ var getAuthContext = async (options = {}) => {
     identity: status.identity
   };
 };
-var 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 };
-};
-// ../auth/src/authProfileDetails.ts
-var ORGANIZATION_NAME_KEY = "UIPATH_ORGANIZATION_NAME";
-var TENANT_NAME_KEY = "UIPATH_TENANT_NAME";
-var URL_KEY = "UIPATH_URL";
-var ACCESS_TOKEN_KEY = "UIPATH_ACCESS_TOKEN";
-function statusFromToken(accessToken) {
-  if (!accessToken) {
-    return { status: "Not logged in" };
-  }
-  const expiration = getTokenExpiration(accessToken);
-  if (expiration === undefined) {
-    return { status: "Logged in" };
-  }
-  return {
-    status: expiration.getTime() <= Date.now() ? "Expired" : "Logged in",
-    expiresAt: expiration.toISOString()
-  };
-}
-async function describeAuthProfileAsync(name, filePath, active) {
-  const base = {
-    name,
-    active,
-    ...filePath ? { path: filePath } : {}
-  };
-  if (!filePath) {
-    return { ...base, status: "Not logged in" };
-  }
-  const fs = getFileSystem();
-  const [readError, content] = await catchError(fs.readFile(filePath, "utf-8"));
-  if (readError) {
-    return { ...base, status: "Unreadable" };
-  }
-  if (content === null || content === undefined) {
-    return { ...base, status: "Not logged in" };
-  }
-  const values = parseEnvContent(content);
-  return {
-    ...base,
-    ...values[ORGANIZATION_NAME_KEY] ? { organizationName: values[ORGANIZATION_NAME_KEY] } : {},
-    ...values[TENANT_NAME_KEY] ? { tenantName: values[TENANT_NAME_KEY] } : {},
-    ...values[URL_KEY] ? { url: values[URL_KEY] } : {},
-    ...statusFromToken(values[ACCESS_TOKEN_KEY])
-  };
-}
-async function describeAuthProfilesAsync() {
-  const activeProfile = getActiveAuthProfile();
-  const [defaultPathError, defaultLocation] = await catchError(resolveEnvFilePathAsync());
-  const rows = [
-    await describeAuthProfileAsync(DEFAULT_AUTH_PROFILE, defaultPathError ? undefined : defaultLocation?.absolutePath, activeProfile === undefined)
-  ];
-  for (const name of await listAuthProfileNamesAsync()) {
-    rows.push(await describeAuthProfileAsync(name, resolveAuthProfileFilePath(name), activeProfile === name));
-  }
-  return rows;
-}
-// ../auth/src/tokenGrant.ts
-var requestClientCredentialsToken = async ({
-  tokenEndpoint,
-  baseUrl,
-  params,
-  buildError
-}) => {
-  const tokenResponse = await fetch(tokenEndpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: new URLSearchParams(params)
-  });
-  const [parseError, tokenData] = await catchError(tokenResponse.json());
-  if (!tokenResponse.ok) {
-    const data = parseError ? {} : tokenData ?? {};
-    throw buildError({
-      status: tokenResponse.status,
-      errorType: data.error || "authentication_failed",
-      errorDesc: data.error_description || "Unknown error"
-    });
-  }
-  if (parseError || !tokenData) {
-    throw buildError({
-      status: tokenResponse.status,
-      errorType: "invalid_response",
-      errorDesc: "Token endpoint returned a non-JSON response."
-    });
-  }
-  if (!tokenData.access_token) {
-    throw buildError({
-      status: tokenResponse.status,
-      errorType: "invalid_response",
-      errorDesc: "Token endpoint response did not include an access_token."
-    });
-  }
-  return {
-    UIPATH_ACCESS_TOKEN: tokenData.access_token,
-    UIPATH_URL: baseUrl
-  };
-};
-
-// ../auth/src/clientCredentials.ts
-class ClientCredentialsAuthenticationError extends Error {
-  status;
-  constructor(message, status) {
-    super(message);
-    this.name = "ClientCredentialsAuthenticationError";
-    this.status = status;
-  }
-}
-var buildClientCredentialsError = ({
-  status,
-  errorType,
-  errorDesc
-}) => {
-  let troubleshooting = "";
-  if (errorType === "invalid_client" || status === 401) {
-    troubleshooting = `
-
-Troubleshooting:` + `
-  • Verify your Client ID is correct` + `
-  • Ensure your Client Secret hasn't expired` + `
-  • Check that the external application is enabled in UiPath` + `
-  • Confirm you're using the correct authority URL`;
-  } else if (errorType === "invalid_scope") {
-    troubleshooting = `
-
-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})
-` + `Error: ${errorType}
-` + `Details: ${errorDesc}${troubleshooting}`, status);
-};
-var clientCredentialsLogin = async ({
-  clientId,
-  clientSecret,
-  scope,
-  authority
-}) => {
-  const config = await resolveConfigAsync({
-    customAuthority: authority,
-    customClientId: clientId,
-    customClientSecret: clientSecret,
-    customScopes: scope
-  });
-  const params = {
-    grant_type: "client_credentials",
-    client_id: config.clientId,
-    client_secret: config.clientSecret ?? ""
-  };
-  if (config.scopes.length > 0) {
-    params.scope = config.scopes.join(" ");
-  }
-  return await requestClientCredentialsToken({
-    tokenEndpoint: config.tokenEndpoint,
-    baseUrl: config.baseUrl,
-    params,
-    buildError: buildClientCredentialsError
-  });
-};
-// ../auth/src/federatedCredentials.ts
-var JWT_BEARER_ASSERTION_TYPE = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer";
-
-class FederatedCredentialsAuthenticationError extends Error {
-  status;
-  constructor(message, status) {
-    super(message);
-    this.name = "FederatedCredentialsAuthenticationError";
-    this.status = status;
-  }
-}
-var buildFederatedError = ({
-  status,
-  errorType,
-  errorDesc
-}) => {
-  let troubleshooting = "";
-  if (errorType === "invalid_client" || errorType === "invalid_grant" || errorType === "invalid_request" || status === 401) {
-    troubleshooting = `
-
-Troubleshooting:` + `
-  • Verify your Client ID matches the external application` + `
-  • Confirm a federated credential is registered on the app whose` + `
-    issuer, audience, and subject exactly match the token's claims` + `
-    (list them: uip admin external-apps federated-credentials list <client-id>)` + `
-  • Check the token was issued by the expected provider and has not expired` + `
-  • Confirm you're using the correct authority URL`;
-  } else if (errorType === "invalid_scope") {
-    troubleshooting = `
-
-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})
-` + `Error: ${errorType}
-` + `Details: ${errorDesc}${troubleshooting}`, status);
-};
-var federatedCredentialsLogin = async ({
-  clientId,
-  clientAssertion,
-  scope,
-  authority
-}) => {
-  const config = await resolveConfigAsync({
-    customAuthority: authority,
-    customClientId: clientId,
-    customClientAssertion: clientAssertion,
-    customScopes: scope
-  });
-  const params = {
-    grant_type: "client_credentials",
-    client_id: config.clientId,
-    client_assertion: clientAssertion,
-    client_assertion_type: JWT_BEARER_ASSERTION_TYPE
-  };
-  if (config.scopes.length > 0) {
-    params.scope = config.scopes.join(" ");
-  }
-  return await requestClientCredentialsToken({
-    tokenEndpoint: config.tokenEndpoint,
-    baseUrl: config.baseUrl,
-    params,
-    buildError: buildFederatedError
-  });
-};
 // ../auth/src/selectTenant.ts
 var TENANT_SELECTION_REQUIRED_CODE = "TENANT_SELECTION_REQUIRED";
 var INVALID_TENANT_CODE = "INVALID_TENANT";
-
-class TenantSelectionError extends Error {
-  availableTenants;
-  organizationName;
-  constructor(message, organizationName, availableTenants) {
-    super(message);
-    this.organizationName = organizationName;
-    this.availableTenants = availableTenants;
-  }
-}
-
-class TenantSelectionRequiredError extends TenantSelectionError {
-  code = TENANT_SELECTION_REQUIRED_CODE;
-  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;
-  requestedTenant;
-  constructor(requestedTenant, organizationName, availableTenants) {
-    super(`Invalid tenant requested: "${requestedTenant}"
-` + `Organization: ${organizationName}
-` + `Available tenants: ${availableTenants.join(", ")}`, organizationName, availableTenants);
-    this.name = "InvalidTenantError";
-    this.requestedTenant = requestedTenant;
-  }
-}
 var TENANT_SELECTION_CODES = new Set([
   TENANT_SELECTION_REQUIRED_CODE,
   INVALID_TENANT_CODE
 ]);
-function isTenantSelectionError(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 = {}) => {
-  const {
-    fetchTenantsAndOrgs = fetchTenantsAndOrganizations,
-    selectFromList
-  } = deps;
-  const data = await fetchTenantsAndOrgs(baseUrl, accessToken, organizationId);
-  const { tenants, organization } = data;
-  if (!tenants || tenants.length === 0) {
-    throw new Error("No tenants found for this organization");
-  }
-  const tenantNames = tenants.map((tenant) => tenant.name);
-  let selectedIndex;
-  if (targetTenantName !== undefined) {
-    selectedIndex = tenants.findIndex((tenant) => tenant.name === targetTenantName);
-    if (selectedIndex === -1) {
-      throw new InvalidTenantError(targetTenantName, organization.name, tenantNames);
-    }
-  } else if (tenants.length === 1) {
-    selectedIndex = 0;
-  } else if (interactive) {
-    if (!selectFromList) {
-      throw new Error("Interactive tenant selection requires a `selectFromList` callback. " + "Pass one via the `deps` argument of `selectTenantWithDeps`.");
-    }
-    selectedIndex = await selectFromList(tenantNames, "Select a tenant:");
-  } else {
-    throw new TenantSelectionRequiredError(organization.name, tenantNames);
-  }
-  const selectedTenant = tenants[selectedIndex];
-  return [selectedTenant.name, selectedTenant.id, organization.name];
-};
-
-// ../auth/src/interactive.ts
-var interactiveLoginWithDeps = async (options, deps) => {
-  const {
-    resolveConfig = resolveConfigAsync,
-    clientCredentials = clientCredentialsLogin,
-    federatedCredentials = federatedCredentialsLogin,
-    auth = authenticate,
-    saveEnvFile = saveEnvFileAsync,
-    loadEnvFile = loadEnvFileAsync,
-    getFs = getFileSystem,
-    jwtParser = parseJWT,
-    issuerAsserter = assertIssuerMatchesAuthority,
-    tenantSelector = (baseUrl, accessToken, organizationId, tenantName, interactive2) => selectTenantWithDeps(baseUrl, accessToken, organizationId, tenantName, interactive2, { selectFromList: options.selectFromList })
-  } = deps;
-  const {
-    envFilePath,
-    scope,
-    authority,
-    clientId,
-    clientSecret,
-    clientAssertion,
-    tenant,
-    organization,
-    interactive,
-    onEvent,
-    timeoutMs,
-    noBrowser,
-    signal
-  } = options;
-  const emit = (event) => {
-    if (!onEvent)
-      return;
-    try {
-      onEvent(event);
-    } catch {}
-  };
-  const deliverAuthUrl = (url) => {
-    try {
-      onEvent?.({ type: "auth-url", url });
-    } catch (error) {
-      throw new Error("Failed to deliver the authorize URL to the onEvent subscriber; " + "cannot continue headless login.", { cause: error });
-    }
-  };
-  const config = await resolveConfig({
-    customAuthority: authority,
-    customClientId: clientId,
-    customClientSecret: clientSecret,
-    customClientAssertion: clientAssertion
-  });
-  const { clientSecret: resolvedSecret } = config;
-  if (noBrowser && !resolvedSecret && !clientAssertion && !onEvent) {
-    throw new Error("noBrowser login requires an onEvent subscriber to receive the " + "auth-url event — the authorize URL is delivered through it.");
-  }
-  const authFlow = clientAssertion ? "federated_credentials" : resolvedSecret ? "client_credentials" : "authorization_code";
-  const authPromise = clientAssertion ? (async () => {
-    return await federatedCredentials({
-      clientId: config.clientId,
-      clientAssertion,
-      authority: config.baseUrl,
-      scope
-    });
-  })() : resolvedSecret ? (async () => {
-    return await clientCredentials({
-      clientId: config.clientId,
-      clientSecret: resolvedSecret,
-      authority: config.baseUrl,
-      scope
-    });
-  })() : (async () => {
-    const authTokens = await auth({
-      baseUrl: authority,
-      clientId,
-      clientSecret,
-      scope,
-      organization,
-      timeoutMs,
-      noBrowser,
-      signal,
-      onAuthUrl: noBrowser ? (url) => deliverAuthUrl(url) : undefined,
-      onPortReclaimed: ({ pid }) => emit({
-        type: "port-reclaimed",
-        message: `A previous 'uip login'${pid === undefined ? "" : ` (PID ${pid})`} was still holding the callback port ` + `(${new URL(DEFAULT_REDIRECT_URI).port}) and was released; continuing with this login.`
-      })
-    });
-    return {
-      UIPATH_ACCESS_TOKEN: authTokens.accessToken,
-      UIPATH_REFRESH_TOKEN: authTokens.refreshToken
-    };
-  })();
-  const [authError, tokens] = await catchError(authPromise);
-  if (authError) {
-    throw authError;
-  }
-  issuerAsserter(tokens.UIPATH_ACCESS_TOKEN, config.baseUrl);
-  const credentials = {
-    ...tokens,
-    UIPATH_URL: config.baseUrl,
-    [AUTH_FLOW_ENV_VAR]: authFlow
-  };
-  if (authFlow !== "authorization_code") {
-    credentials.UIPATH_REFRESH_TOKEN = undefined;
-  }
-  try {
-    const tokenData = jwtParser(tokens.UIPATH_ACCESS_TOKEN);
-    const orgId = tokenData.prtId || tokenData.organizationId || tokenData.prt_id;
-    if (typeof orgId !== "string" || orgId.length === 0) {
-      throw new Error("Organization ID not available from login token. Cannot establish an active tenant.");
-    }
-    credentials.UIPATH_ORGANIZATION_ID = orgId;
-    if (organization) {
-      credentials.UIPATH_ORGANIZATION_NAME = organization;
-    }
-    const [tenantName, tenantId, orgName] = await tenantSelector(config.baseUrl, tokens.UIPATH_ACCESS_TOKEN, orgId, tenant, interactive);
-    credentials.UIPATH_ORGANIZATION_NAME = orgName;
-    credentials.UIPATH_TENANT_NAME = tenantName;
-    credentials.UIPATH_TENANT_ID = tenantId;
-  } catch (error) {
-    if (!isTenantSelectionError(error)) {
-      emit({
-        type: "tenant-fetch-failed",
-        message: error instanceof Error ? error.message : String(error)
-      });
-    }
-    throw error;
-  }
-  const fs = getFs();
-  const requestedPath = envFilePath ?? DEFAULT_ENV_FILENAME;
-  let savePath = requestedPath;
-  let savedLocally = false;
-  if (!fs.path.isAbsolute(savePath)) {
-    let searchDir = fs.env.cwd();
-    while (true) {
-      const candidate = fs.path.join(searchDir, savePath);
-      if (await fs.exists(candidate)) {
-        try {
-          const existing = await loadEnvFile({
-            envPath: candidate
-          });
-          if (existing.UIPATH_ACCESS_TOKEN) {
-            savePath = candidate;
-            savedLocally = true;
-            break;
-          }
-        } catch {}
-      }
-      const parentDir = fs.path.dirname(searchDir);
-      if (parentDir === searchDir) {
-        break;
-      }
-      searchDir = parentDir;
-    }
-  }
-  let saveRelease;
-  try {
-    if (typeof fs.acquireLock === "function") {
-      saveRelease = await fs.acquireLock(savePath);
-    }
-  } catch {
-    saveRelease = undefined;
-  }
-  try {
-    await saveEnvFile({
-      envPath: savePath,
-      data: credentials,
-      merge: true
-    });
-  } finally {
-    if (saveRelease) {
-      await saveRelease().catch(() => {});
-    }
-  }
-  const reportedPath = fs.path.isAbsolute(savePath) ? savePath : fs.path.join(fs.env.homedir(), savePath);
-  emit({
-    type: "saved",
-    path: reportedPath,
-    locality: savedLocally ? "local" : "global"
-  });
-  return credentials;
-};
-var interactiveLogin = async (options) => {
-  return interactiveLoginWithDeps(options, {});
-};
-// ../auth/src/logout.ts
-async function logoutWithDeps(options, deps = {}) {
-  const {
-    resolveEnvFilePath = resolveEnvFilePathAsync,
-    getFileSystem: getFs = getFileSystem,
-    clearBreaker = clearRefreshBreaker,
-    getActiveProfileFilePath = getActiveAuthProfileFilePath
-  } = deps;
-  const fs = getFs();
-  const { absolutePath } = await resolveEnvFilePath(options.file ?? getActiveProfileFilePath());
-  if (absolutePath && await fs.exists(absolutePath)) {
-    let release;
-    try {
-      if (typeof fs.acquireLock === "function") {
-        release = await fs.acquireLock(absolutePath);
-      }
-    } catch {
-      release = undefined;
-    }
-    try {
-      await fs.rm(absolutePath);
-      await clearBreaker(absolutePath);
-    } finally {
-      if (release) {
-        await release().catch(() => {});
-      }
-    }
-    return {
-      success: true,
-      message: `Logged out successfully. Removed ${absolutePath}`,
-      removedPath: absolutePath
-    };
-  }
-  return {
-    success: false,
-    message: "No credentials file found. You are already logged out.",
-    reason: "no_credentials_file"
-  };
-}
-async function logout(options) {
-  return logoutWithDeps(options);
-}
 
 // ../auth/src/index.ts
-var authenticate = async ({
+var authenticate2 = async ({
   baseUrl,
   clientId,
   clientSecret,
@@ -2470,7 +1844,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 +1868,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-gnftxwsf.js");
     strategy = new BrowserAuthStrategy;
   } else {
-    const { NodeAuthStrategy } = await import("./node-strategy-1dmmhvf3.js");
+    const { NodeAuthStrategy } = await import("./node-strategy-wrjxmbzt.js");
     strategy = new NodeAuthStrategy;
   }
   const code = await strategy.execute(authUrl, effectiveRedirectUriUrl, state, {
@@ -2518,6 +1892,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 { INHERITED_AUTH_PROFILE_ENV2, getActiveAuthProfile2, resolveSessionIdentity2, getLoginStatusAsync2, getAuthContext2, authenticate2 };
 
-//# debugId=7292022086A0BDF264756E2164756E21
+//# debugId=C74D85E4430C6FA964756E2164756E21