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

package/dist/{packager-tool-1shggyya.js → packager-tool-qjerhjyd.js}

@@ -1,30 +1,52 @@
-import {
-  catchError
-} from "./packager-tool-qa9gftnj.js";
 import {
   getFileSystem
-} from "./packager-tool-y4vgqz1w.js";
-import {
-  getGlobalThis,
-  isBrowser
-} from "./packager-tool-0gctz400.js";
-import {
-  AUTH_FILENAME,
-  DEFAULT_BASE_URL,
-  DEFAULT_REDIRECT_URI,
-  UIPATH_HOME_DIR
-} from "./packager-tool-yc4kw997.js";
+} from "./packager-tool-cmtxbmhx.js";
 import {
   __require
-} from "./packager-tool-1de529jm.js";
+} from "./packager-tool-epsr41wx.js";
+
+// ../auth/src/catch-error.ts
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function catchError(fnOrPromise) {
+  if (isPromiseLike(fnOrPromise)) {
+    return settlePromiseLike(fnOrPromise);
+  }
+  try {
+    const result = fnOrPromise();
+    if (isPromiseLike(result)) {
+      return settlePromiseLike(result);
+    }
+    return [undefined, result];
+  } catch (error) {
+    return [
+      error instanceof Error ? error : new Error(String(error)),
+      undefined
+    ];
+  }
+}
+function settlePromiseLike(thenable) {
+  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [
+    error instanceof Error ? error : new Error(String(error)),
+    undefined
+  ]);
+}
+
+// ../auth/src/constants.ts
+var UIPATH_HOME_DIR = ".uipath";
+var AUTH_FILENAME = ".auth";
+var DEFAULT_BASE_URL = "https://cloud.uipath.com";
+var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
+var AUTH_TIMEOUT_ERROR_CODE = "EAUTHTIMEOUT";
+var AUTH_CANCELLED_ERROR_CODE = "EAUTHCANCELLED";
+var AUTH_RECLAIMED_ERROR_CODE = "EAUTHRECLAIMED";
+var DEFAULT_REDIRECT_URI = "http://localhost:8104/oidc/login";
 
 // ../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 +311,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) {
@@ -462,6 +484,17 @@ var exchangeCodeForTokens = async ({
   return { accessToken, refreshToken };
 };
 
+// ../auth/src/utils/platform.ts
+function isBrowser() {
+  return typeof globalThis !== "undefined" && "window" in globalThis && "document" in globalThis;
+}
+function getGlobalThis() {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  return;
+}
+
 // ../auth/src/authProfile.ts
 var DEFAULT_AUTH_PROFILE = "default";
 var PROFILE_DIR = "profiles";
@@ -510,31 +543,6 @@ 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() {
   const scopedState = profileStorage.getStore();
   if (scopedState !== undefined) {
@@ -542,10 +550,6 @@ function getActiveAuthProfile() {
   }
   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) {
@@ -558,63 +562,6 @@ function getActiveAuthProfileFilePath() {
   const profile = getActiveAuthProfile();
   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 {
@@ -782,6 +729,8 @@ var ENV_AUTH_VARS = {
 };
 
 class EnvAuthConfigError extends Error {
+  errorCode = "configuration_error";
+  retry = "RetryWillNotFix";
   constructor(message) {
     super(message);
     this.name = "EnvAuthConfigError";
@@ -820,11 +769,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,
@@ -969,9 +918,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;
@@ -1127,9 +1073,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 +1094,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 +1141,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,
@@ -1231,7 +1179,7 @@ var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opt
     ...probe.unusable ? { unusable: probe.unusable } : {}
   };
 };
-var resolveEnvFilePathAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
+var resolveEnvFilePathAsync2 = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
   const location = await resolveEnvFileLocationAsync(envFilePath, opts);
   if (location.exists) {
     return { absolutePath: location.absolutePath };
@@ -1262,7 +1210,7 @@ var parseEnvContent = (content) => {
   }
   return env;
 };
-var loadEnvFileAsync = async ({ envPath }) => {
+var loadEnvFileAsync2 = async ({ envPath }) => {
   const fs = getFileSystem();
   const absolutePath = fs.path.isAbsolute(envPath) ? envPath : fs.path.join(fs.env.cwd(), envPath);
   if (!await fs.exists(absolutePath)) {
@@ -1284,7 +1232,7 @@ var saveEnvFileAsync = async ({
   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,12 +1256,6 @@ 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 = {}) => {
@@ -1321,8 +1263,8 @@ var getLoginStatusAsync = async (options = {}) => {
 };
 var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
   const {
-    resolveEnvFilePath = resolveEnvFilePathAsync,
-    loadEnvFile = loadEnvFileAsync,
+    resolveEnvFilePath = resolveEnvFilePathAsync2,
+    loadEnvFile = loadEnvFileAsync2,
     saveEnvFile = saveEnvFileAsync,
     getFs = getFileSystem,
     refreshToken: refreshTokenFn = refreshAccessToken,
@@ -1855,38 +1797,7 @@ function errorMessage(error) {
 }
 
 // ../auth/src/authContext.ts
-var getAuthContext = async (options = {}) => {
-  const status = await getLoginStatusAsync({
-    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.");
-  }
-  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.");
-  }
-  if (options.requireOrganizationName && !status.organizationName) {
-    throw new Error("Organization name not available. Ensure you are logged in with an organization context.");
-  }
-  if (options.requireTenantId && !status.tenantId) {
-    throw new Error("Tenant ID not available. Ensure UIPATH_TENANT_ID is set.");
-  }
-  if (options.requireTenantName && tenantName === undefined) {
-    throw new Error("Tenant not provided and UIPATH_TENANT_NAME not set. Run 'uip login' to select a tenant, or use 'uip login tenant set <tenant>' to switch tenants.");
-  }
-  return {
-    baseUrl: status.baseUrl,
-    accessToken: status.accessToken,
-    organizationId: status.organizationId,
-    organizationName: status.organizationName,
-    tenantId: status.tenantId,
-    tenantName,
-    identity: status.identity
-  };
-};
-var getAuthEnv = async (options = {}) => {
+var getAuthEnv2 = async (options = {}) => {
   const authEnv = {};
   let status;
   try {
@@ -1900,7 +1811,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)
@@ -1914,533 +1825,16 @@ var getAuthEnv = async (options = {}) => {
   }
   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,
@@ -2495,10 +1889,10 @@ var authenticate = async ({
   const authUrl = `${authorizationEndpoint}?${authParams.toString()}`;
   let strategy;
   if (isBrowser()) {
-    const { BrowserAuthStrategy } = await import("./browser-strategy-tyy1nbjg.js");
+    const { BrowserAuthStrategy } = await import("./browser-strategy-bxv33ex0.js");
     strategy = new BrowserAuthStrategy;
   } else {
-    const { NodeAuthStrategy } = await import("./node-strategy-nmepnk2k.js");
+    const { NodeAuthStrategy } = await import("./node-strategy-dhvvrt9n.js");
     strategy = new NodeAuthStrategy;
   }
   const code = await strategy.execute(authUrl, effectiveRedirectUriUrl, state, {
@@ -2518,6 +1912,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 { catchError, DEFAULT_AUTH_TIMEOUT_MS, AUTH_TIMEOUT_ERROR_CODE, AUTH_CANCELLED_ERROR_CODE, AUTH_RECLAIMED_ERROR_CODE, getGlobalThis, resolveEnvFilePathAsync2, loadEnvFileAsync2, getAuthEnv2, authenticate2 };
 
-//# debugId=6C6D8C0CEC26DA6E64756E2164756E21
+//# debugId=A75BC67F1A2D9AFD64756E2164756E21