@uipath/auth 1.1.0 → 1.196.0

package/dist/index.js

@@ -728,6 +728,7 @@ var init_open = __esm(() => {
 });
 
 // ../filesystem/src/node.ts
+import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import * as fs6 from "node:fs/promises";
 import * as os2 from "node:os";
@@ -809,6 +810,90 @@ class NodeFileSystem {
   async mkdir(dirPath) {
     await fs6.mkdir(dirPath, { recursive: true });
   }
+  async acquireLock(lockPath) {
+    const canonicalPath = await this.canonicalizeLockTarget(lockPath);
+    const lockFile = `${canonicalPath}.lock`;
+    const ownerId = randomUUID();
+    const start = Date.now();
+    while (true) {
+      try {
+        await fs6.writeFile(lockFile, ownerId, { flag: "wx" });
+        return this.createLockRelease(lockFile, ownerId);
+      } catch (error) {
+        if (!this.hasErrnoCode(error, "EEXIST")) {
+          throw error;
+        }
+        const stats = await fs6.stat(lockFile).catch(() => null);
+        if (stats && Date.now() - stats.mtimeMs > LOCK_STALE_MS) {
+          const reclaimed = await fs6.rm(lockFile, { force: true }).then(() => true).catch(() => false);
+          if (reclaimed)
+            continue;
+        }
+        if (Date.now() - start > LOCK_MAX_WAIT_MS) {
+          throw new Error(`ELOCKED: timed out waiting for lock on ${canonicalPath}`);
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, LOCK_RETRY_MIN_MS + Math.random() * LOCK_RETRY_JITTER_MS));
+      }
+    }
+  }
+  async canonicalizeLockTarget(lockPath) {
+    const absolute = path2.resolve(lockPath);
+    const fullReal = await fs6.realpath(absolute).catch(() => null);
+    if (fullReal)
+      return fullReal;
+    const parent = path2.dirname(absolute);
+    const base = path2.basename(absolute);
+    const canonicalParent = await fs6.realpath(parent).catch(() => parent);
+    return path2.join(canonicalParent, base);
+  }
+  createLockRelease(lockFile, ownerId) {
+    const heartbeatStart = Date.now();
+    let heartbeatTimer;
+    let stopped = false;
+    const stopHeartbeat = () => {
+      stopped = true;
+      if (heartbeatTimer)
+        clearTimeout(heartbeatTimer);
+    };
+    const scheduleNextHeartbeat = () => {
+      if (stopped)
+        return;
+      if (Date.now() - heartbeatStart >= LOCK_MAX_HOLD_MS) {
+        stopped = true;
+        return;
+      }
+      heartbeatTimer = setTimeout(() => {
+        runHeartbeat();
+      }, LOCK_HEARTBEAT_MS);
+      heartbeatTimer.unref?.();
+    };
+    const runHeartbeat = async () => {
+      if (stopped)
+        return;
+      const current = await fs6.readFile(lockFile, "utf-8").catch(() => null);
+      if (stopped)
+        return;
+      if (current !== ownerId) {
+        stopped = true;
+        return;
+      }
+      const now = Date.now() / 1000;
+      await fs6.utimes(lockFile, now, now).catch(() => {});
+      scheduleNextHeartbeat();
+    };
+    scheduleNextHeartbeat();
+    let released = false;
+    return async () => {
+      if (released)
+        return;
+      released = true;
+      stopHeartbeat();
+      const current = await fs6.readFile(lockFile, "utf-8").catch(() => null);
+      if (current === ownerId) {
+        await fs6.rm(lockFile, { force: true });
+      }
+    };
+  }
   async rm(filePath) {
     await fs6.rm(filePath, { recursive: true, force: true });
   }
@@ -854,9 +939,13 @@ class NodeFileSystem {
     }
   }
   isEnoent(error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+    return this.hasErrnoCode(error, "ENOENT");
+  }
+  hasErrnoCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
   }
 }
+var LOCK_HEARTBEAT_MS = 5000, LOCK_STALE_MS = 15000, LOCK_MAX_WAIT_MS = 20000, LOCK_MAX_HOLD_MS = 60000, LOCK_RETRY_MIN_MS = 100, LOCK_RETRY_JITTER_MS = 200;
 var init_node = __esm(() => {
   init_open();
 });
@@ -870,7 +959,7 @@ var init_src = __esm(() => {
 
 // ../../node_modules/@uipath/coreipc/index.js
 var require_coreipc = __commonJS((exports, module) => {
-  var __dirname = "/Users/alexandru.oltean/github/cli/node_modules/@uipath/coreipc";
+  var __dirname = "/home/runner/work/cli/cli/node_modules/@uipath/coreipc";
   /*! For license information please see index.js.LICENSE.txt */
   (function(e, t) {
     typeof exports == "object" && typeof module == "object" ? module.exports = t() : typeof define == "function" && define.amd ? define([], t) : typeof exports == "object" ? exports.ipc = t() : e.ipc = t();
@@ -19063,81 +19152,6 @@ var require_dist = __commonJS((exports) => {
   __exportStar(require_agent(), exports);
 });
 
-// src/strategies/browser-strategy.ts
-var exports_browser_strategy = {};
-__export(exports_browser_strategy, {
-  BrowserAuthStrategy: () => BrowserAuthStrategy
-});
-
-class BrowserAuthStrategy {
-  async execute(url, _redirectUri, expectedState) {
-    const global2 = getGlobalThis();
-    if (!global2?.window) {
-      throw new Error("Browser environment required for authentication");
-    }
-    const screenWidth = global2.window.screen?.width ?? 1024;
-    const screenHeight = global2.window.screen?.height ?? 768;
-    const width = 600;
-    const height = 700;
-    const left = screenWidth / 2 - width / 2;
-    const top = screenHeight / 2 - height / 2;
-    if (!global2.window.open) {
-      throw new Error("window.open is not available");
-    }
-    const popupResult = global2.window.open(url, "uip_auth", `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes,status=yes`);
-    const popup = popupResult;
-    if (!popup) {
-      throw new Error(`Authentication popup was blocked by your browser.
-
-` + `To continue:
-` + `1. Look for a popup blocker icon in your address bar
-` + `2. Allow popups for this site
-` + `3. Try logging in again
-
-` + "If using an ad blocker, you may need to temporarily disable it.");
-    }
-    return new Promise((resolve2, reject) => {
-      const messageHandler = (event) => {
-        if (event.data?.type === "UIP_AUTH_CODE" && event.data.code) {
-          if (event.data.state !== expectedState) {
-            cleanup();
-            reject(new Error("OAuth state mismatch — the callback state does not match the expected value. " + "This may indicate a CSRF attack. Please try signing in again."));
-            popup.close();
-            return;
-          }
-          cleanup();
-          resolve2(event.data.code);
-          popup.close();
-        } else if (event.data?.type === "UIP_AUTH_ERROR") {
-          cleanup();
-          const errorMsg = event.data.error || "Authentication failed";
-          reject(new Error(`Authentication failed: ${errorMsg}
-
-` + "Please check your credentials and try again. " + "If the problem persists, verify your UiPath account is active."));
-          popup.close();
-        }
-      };
-      const cleanup = () => {
-        global2.window?.removeEventListener?.("message", messageHandler);
-        if (timer)
-          clearInterval(timer);
-      };
-      if (global2.window?.addEventListener) {
-        global2.window.addEventListener("message", messageHandler);
-      }
-      const timer = setInterval(() => {
-        if (popup.closed) {
-          cleanup();
-          reject(new Error(`Authentication was cancelled.
-
-` + "The authentication popup was closed before completing the login process. " + "Please try again and complete the authentication flow."));
-        }
-      }, 1000);
-    });
-  }
-}
-var init_browser_strategy = () => {};
-
 // src/getBaseHtml.ts
 var getBaseHtml = ({ title, message, type }) => {
   const icon = type === "success" ? "✓" : "✕";
@@ -19284,7 +19298,7 @@ var getBaseHtml = ({ title, message, type }) => {
 };
 
 // src/server.ts
-var startServer = async ({
+var AUTH_TIMEOUT_ERROR_CODE = "EAUTHTIMEOUT", startServer = async ({
   redirectUri,
   timeoutMs = DEFAULT_AUTH_TIMEOUT_MS,
   onListening
@@ -19355,7 +19369,18 @@ var startServer = async ({
       reject(new Error("No authorization code received"));
       return;
     });
-    server.listen(Number(redirectUri.port), redirectUri.hostname, () => {
+    const timeoutHandle = setTimeout(() => {
+      server.close();
+      const err = new Error("Authentication timeout");
+      err.code = AUTH_TIMEOUT_ERROR_CODE;
+      reject(err);
+    }, timeoutMs);
+    const bindHost = redirectUri.hostname === "localhost" ? "127.0.0.1" : redirectUri.hostname;
+    server.on("error", (err) => {
+      clearTimeout(timeoutHandle);
+      reject(err);
+    });
+    server.listen(Number(redirectUri.port), bindHost, () => {
       if (onListening) {
         Promise.resolve(onListening()).catch((err) => {
           server.close();
@@ -19364,10 +19389,6 @@ var startServer = async ({
         });
       }
     });
-    const timeoutHandle = setTimeout(() => {
-      server.close();
-      reject(new Error("Authentication timeout"));
-    }, timeoutMs);
     server.on("close", () => {
       clearTimeout(timeoutHandle);
     });
@@ -19377,6 +19398,81 @@ var init_server = __esm(() => {
   init_constants();
 });
 
+// src/strategies/browser-strategy.ts
+var exports_browser_strategy = {};
+__export(exports_browser_strategy, {
+  BrowserAuthStrategy: () => BrowserAuthStrategy
+});
+
+class BrowserAuthStrategy {
+  async execute(url, _redirectUri, expectedState, _opts) {
+    const global2 = getGlobalThis();
+    if (!global2?.window) {
+      throw new Error("Browser environment required for authentication");
+    }
+    const screenWidth = global2.window.screen?.width ?? 1024;
+    const screenHeight = global2.window.screen?.height ?? 768;
+    const width = 600;
+    const height = 700;
+    const left = screenWidth / 2 - width / 2;
+    const top = screenHeight / 2 - height / 2;
+    if (!global2.window.open) {
+      throw new Error("window.open is not available");
+    }
+    const popupResult = global2.window.open(url, "uip_auth", `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes,status=yes`);
+    const popup = popupResult;
+    if (!popup) {
+      throw new Error(`Authentication popup was blocked by your browser.
+
+` + `To continue:
+` + `1. Look for a popup blocker icon in your address bar
+` + `2. Allow popups for this site
+` + `3. Try logging in again
+
+` + "If using an ad blocker, you may need to temporarily disable it.");
+    }
+    return new Promise((resolve2, reject) => {
+      const messageHandler = (event) => {
+        if (event.data?.type === "UIP_AUTH_CODE" && event.data.code) {
+          if (event.data.state !== expectedState) {
+            cleanup();
+            reject(new Error("OAuth state mismatch — the callback state does not match the expected value. " + "This may indicate a CSRF attack. Please try signing in again."));
+            popup.close();
+            return;
+          }
+          cleanup();
+          resolve2(event.data.code);
+          popup.close();
+        } else if (event.data?.type === "UIP_AUTH_ERROR") {
+          cleanup();
+          const errorMsg = event.data.error || "Authentication failed";
+          reject(new Error(`Authentication failed: ${errorMsg}
+
+` + "Please check your credentials and try again. " + "If the problem persists, verify your UiPath account is active."));
+          popup.close();
+        }
+      };
+      const cleanup = () => {
+        global2.window?.removeEventListener?.("message", messageHandler);
+        if (timer)
+          clearInterval(timer);
+      };
+      if (global2.window?.addEventListener) {
+        global2.window.addEventListener("message", messageHandler);
+      }
+      const timer = setInterval(() => {
+        if (popup.closed) {
+          cleanup();
+          reject(new Error(`Authentication was cancelled.
+
+` + "The authentication popup was closed before completing the login process. " + "Please try again and complete the authentication flow."));
+        }
+      }, 1000);
+    });
+  }
+}
+var init_browser_strategy = () => {};
+
 // src/strategies/node-strategy.ts
 var exports_node_strategy = {};
 __export(exports_node_strategy, {
@@ -19384,10 +19480,11 @@ __export(exports_node_strategy, {
 });
 
 class NodeAuthStrategy {
-  async execute(url, redirectUri, expectedState) {
+  async execute(url, redirectUri, expectedState, opts) {
     const fs7 = getFileSystem();
     const callbackUrl = await startServer({
       redirectUri,
+      timeoutMs: opts?.timeoutMs,
       onListening: async () => {
         let safeUrl = "";
         for (const ch of url) {
@@ -19455,32 +19552,7 @@ class InvalidBaseUrlError extends Error {
     this.name = "InvalidBaseUrlError";
   }
 }
-var DEFAULT_SCOPES = [
-  "offline_access",
-  "ProcessMining",
-  "OrchestratorApiUserAccess",
-  "StudioWebBackend",
-  "IdentityServerApi",
-  "ConnectionService",
-  "DataService",
-  "DataServiceApiUserAccess",
-  "DocumentUnderstanding",
-  "EnterpriseContextService",
-  "Directory",
-  "JamJamApi",
-  "LLMGateway",
-  "LLMOps",
-  "OMS",
-  "RCS.FolderAuthorization",
-  "RCS.TagsManagement",
-  "TestmanagerApiUserAccess",
-  "AutomationSolutions",
-  "StudioWebTypeCacheService",
-  "Docs.GPT.Search",
-  "Insights",
-  "ReferenceToken",
-  "Audit.Read"
-];
+var DEFAULT_SCOPES = ["openid", "profile", "offline_access"];
 var normalizeAndValidateBaseUrl = (rawUrl) => {
   let baseUrl = rawUrl;
   if (baseUrl.endsWith("/identity_/")) {
@@ -19530,7 +19602,8 @@ var resolveConfigAsync = async ({
   if (!clientSecret && fileAuth.clientSecret) {
     clientSecret = fileAuth.clientSecret;
   }
-  const scopes = customScopes && customScopes.length > 0 ? customScopes : fileAuth.scopes && fileAuth.scopes.length > 0 ? fileAuth.scopes : DEFAULT_SCOPES;
+  const isExternalAppAuth = clientId !== DEFAULT_CLIENT_ID && Boolean(clientSecret);
+  const scopes = customScopes && customScopes.length > 0 ? customScopes : fileAuth.scopes && fileAuth.scopes.length > 0 ? fileAuth.scopes : isExternalAppAuth ? [] : DEFAULT_SCOPES;
   return {
     clientId,
     clientSecret,
@@ -20366,11 +20439,11 @@ var parseResourceUrl = (url) => {
   if (error || !parsed)
     return;
   const segments = parsed.pathname.split("/").filter(Boolean);
-  const organizationName = segments[0];
-  const tenantName = segments[1];
-  if (!organizationName || !tenantName)
-    return;
-  return { baseUrl: parsed.origin, organizationName, tenantName };
+  return {
+    baseUrl: parsed.origin,
+    organizationName: segments[0],
+    tenantName: segments[1]
+  };
 };
 var defaultLoadModule = async () => {
   const [error, mod] = await catchError(() => Promise.resolve().then(() => __toESM(require_dist(), 1)));
@@ -20421,6 +20494,7 @@ var tryRobotClientFallback = async (options = {}) => {
     }
     let organizationIdFromToken;
     let tenantIdFromToken;
+    let issuerFromToken;
     const [jwtError, claims] = catchError(() => parseJWT(accessToken));
     if (!jwtError && claims) {
       const rawOrgId = claims.prtId ?? claims.organizationId ?? claims.prt_id;
@@ -20431,6 +20505,10 @@ var tryRobotClientFallback = async (options = {}) => {
       if (typeof tenantClaim === "string" && tenantClaim.length > 0) {
         tenantIdFromToken = tenantClaim;
       }
+      const issClaim = claims.iss;
+      if (typeof issClaim === "string" && issClaim.length > 0) {
+        issuerFromToken = issClaim;
+      }
     }
     printNoticeOnce();
     return {
@@ -20439,7 +20517,8 @@ var tryRobotClientFallback = async (options = {}) => {
       organizationName: parsedUrl.organizationName,
       organizationId: organizationIdFromToken ?? parsedUrl.organizationName,
       tenantName: parsedUrl.tenantName,
-      tenantId: tenantIdFromToken
+      tenantId: tenantIdFromToken,
+      issuer: issuerFromToken
     };
   } catch {
     return;
@@ -20542,7 +20621,7 @@ var probeAsync = async (fs7, candidate) => {
     };
   }
 };
-var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME) => {
+var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
   const fs7 = getFileSystem();
   if (fs7.path.isAbsolute(envFilePath)) {
     const probe2 = await probeAsync(fs7, envFilePath);
@@ -20553,7 +20632,7 @@ var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME) =>
       ...probe2.unusable ? { unusable: probe2.unusable } : {}
     };
   }
-  const cwd = fs7.env.cwd();
+  const cwd = opts?.cwd ?? fs7.env.cwd();
   let searchDir = cwd;
   while (true) {
     const candidate = fs7.path.join(searchDir, envFilePath);
@@ -20583,8 +20662,8 @@ var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME) =>
     ...probe.unusable ? { unusable: probe.unusable } : {}
   };
 };
-var resolveEnvFilePathAsync = async (envFilePath = DEFAULT_ENV_FILENAME) => {
-  const location = await resolveEnvFileLocationAsync(envFilePath);
+var resolveEnvFilePathAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
+  const location = await resolveEnvFileLocationAsync(envFilePath, opts);
   if (location.exists) {
     return { absolutePath: location.absolutePath };
   }
@@ -20668,6 +20747,129 @@ function normalizeTokenRefreshFailure() {
 function normalizeTokenRefreshUnavailableFailure() {
   return "token refresh failed before authentication completed";
 }
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function computeExpirationThreshold(ensureTokenValidityMinutes) {
+  return new Date(Date.now() + (ensureTokenValidityMinutes ?? 0) * 60 * 1000);
+}
+async function runRefreshLocked(inputs) {
+  const {
+    absolutePath,
+    refreshToken: callerRefreshToken,
+    customAuthority,
+    ensureTokenValidityMinutes,
+    loadEnvFile,
+    saveEnvFile,
+    refreshFn,
+    resolveConfig
+  } = inputs;
+  const expirationThreshold = computeExpirationThreshold(ensureTokenValidityMinutes);
+  let fresh;
+  try {
+    fresh = await loadEnvFile({ envPath: absolutePath });
+  } catch (error) {
+    return {
+      kind: "fail",
+      status: {
+        loginStatus: "Refresh Failed",
+        hint: "Could not read the auth file while refreshing. Retry, or run 'uip login' to re-authenticate.",
+        tokenRefresh: {
+          attempted: false,
+          success: false,
+          errorMessage: `auth file read failed: ${errorMessage(error)}`
+        }
+      }
+    };
+  }
+  const freshAccess = fresh.UIPATH_ACCESS_TOKEN;
+  const freshExp = freshAccess ? getTokenExpiration(freshAccess) : undefined;
+  if (freshAccess && freshExp && freshExp > expirationThreshold) {
+    return {
+      kind: "ok",
+      accessToken: freshAccess,
+      refreshToken: fresh.UIPATH_REFRESH_TOKEN ?? callerRefreshToken,
+      expiration: freshExp,
+      tokenRefresh: { attempted: false, success: true }
+    };
+  }
+  const tokenForIdP = fresh.UIPATH_REFRESH_TOKEN ?? callerRefreshToken;
+  let refreshedAccess;
+  let refreshedRefresh;
+  try {
+    const config = await resolveConfig({ customAuthority });
+    const refreshed = await refreshFn({
+      refreshToken: tokenForIdP,
+      tokenEndpoint: config.tokenEndpoint,
+      clientId: config.clientId,
+      expectedAuthority: customAuthority
+    });
+    refreshedAccess = refreshed.accessToken;
+    refreshedRefresh = refreshed.refreshToken;
+  } catch (error) {
+    const isOAuthFailure = isTokenRefreshOAuthFailure(error);
+    const hint = isOAuthFailure ? "Run 'uip login' to re-authenticate — the stored refresh token is invalid or expired." : "Token refresh failed. Check your network connection, then retry or run 'uip login' to re-authenticate.";
+    const message = isOAuthFailure ? normalizeTokenRefreshFailure() : normalizeTokenRefreshUnavailableFailure();
+    return {
+      kind: "fail",
+      status: {
+        loginStatus: "Refresh Failed",
+        hint,
+        tokenRefresh: {
+          attempted: true,
+          success: false,
+          errorMessage: message
+        }
+      }
+    };
+  }
+  const refreshedExp = getTokenExpiration(refreshedAccess);
+  if (!refreshedExp || refreshedExp <= new Date) {
+    return {
+      kind: "fail",
+      status: {
+        loginStatus: "Refresh Failed",
+        hint: "The identity server returned an unusable token. Run 'uip login' to re-authenticate.",
+        tokenRefresh: {
+          attempted: true,
+          success: false,
+          errorMessage: "refreshed token has no valid expiration claim"
+        }
+      }
+    };
+  }
+  try {
+    await saveEnvFile({
+      envPath: absolutePath,
+      data: {
+        UIPATH_ACCESS_TOKEN: refreshedAccess,
+        UIPATH_REFRESH_TOKEN: refreshedRefresh
+      },
+      merge: true
+    });
+    return {
+      kind: "ok",
+      accessToken: refreshedAccess,
+      refreshToken: refreshedRefresh,
+      expiration: refreshedExp,
+      tokenRefresh: { attempted: true, success: true }
+    };
+  } catch (error) {
+    const msg = errorMessage(error);
+    return {
+      kind: "ok",
+      accessToken: refreshedAccess,
+      refreshToken: refreshedRefresh,
+      expiration: refreshedExp,
+      persistenceWarning: `Access token refreshed in memory but could not be written to ${absolutePath}: ${msg}. The next CLI invocation will fail until the file can be updated — run 'uip login' to re-authenticate.`,
+      tokenRefresh: {
+        attempted: true,
+        success: true,
+        errorMessage: `persistence failed: ${msg}`
+      }
+    };
+  }
+}
 var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
   const {
     resolveEnvFilePath = resolveEnvFilePathAsync,
@@ -20698,6 +20900,7 @@ var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
       organizationId: robotCreds.organizationId,
       tenantName: robotCreds.tenantName,
       tenantId: robotCreds.tenantId,
+      issuer: robotCreds.issuer,
       expiration: expiration2,
       source: "robot" /* Robot */
     };
@@ -20719,6 +20922,7 @@ var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
         organizationId: robotCreds.organizationId,
         tenantName: robotCreds.tenantName,
         tenantId: robotCreds.tenantId,
+        issuer: robotCreds.issuer,
         expiration: expiration2,
         source: "robot" /* Robot */
       };
@@ -20742,73 +20946,103 @@ var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
   let refreshToken = credentials.UIPATH_REFRESH_TOKEN;
   let expiration = getTokenExpiration(accessToken);
   let persistenceWarning;
+  let lockReleaseFailed = false;
   let tokenRefresh;
-  const expirationThreshold = new Date(Date.now() + (ensureTokenValidityMinutes ?? 0) * 60 * 1000);
-  if (expiration && expiration <= expirationThreshold && refreshToken) {
-    let refreshedAccess;
-    let refreshedRefresh;
+  const outerThreshold = computeExpirationThreshold(ensureTokenValidityMinutes);
+  const tryGlobalCredsHint = async () => {
+    const fs7 = getFs();
+    const globalPath = fs7.path.join(fs7.env.homedir(), envFilePath);
+    if (absolutePath === globalPath)
+      return;
+    if (!await fs7.exists(globalPath))
+      return;
     try {
-      const config = await resolveConfig({
-        customAuthority: credentials.UIPATH_URL
-      });
-      const refreshed = await refreshTokenFn({
-        refreshToken,
-        tokenEndpoint: config.tokenEndpoint,
-        clientId: config.clientId,
-        expectedAuthority: credentials.UIPATH_URL
-      });
-      refreshedAccess = refreshed.accessToken;
-      refreshedRefresh = refreshed.refreshToken;
-    } catch (error) {
-      const isOAuthFailure = isTokenRefreshOAuthFailure(error);
-      const hint = isOAuthFailure ? "Run 'uip login' to re-authenticate — the stored refresh token is invalid or expired." : "Token refresh failed. Check your network connection, then retry or run 'uip login' to re-authenticate.";
-      const errorMessage = isOAuthFailure ? normalizeTokenRefreshFailure() : normalizeTokenRefreshUnavailableFailure();
-      return {
-        loginStatus: "Refresh Failed",
-        hint,
-        tokenRefresh: {
-          attempted: true,
-          success: false,
-          errorMessage
-        }
-      };
+      const globalCreds = await loadEnvFile({ envPath: globalPath });
+      if (!globalCreds.UIPATH_ACCESS_TOKEN)
+        return;
+      const globalExp = getTokenExpiration(globalCreds.UIPATH_ACCESS_TOKEN);
+      if (globalExp && globalExp <= new Date)
+        return;
+      return `Local credentials file at ${absolutePath} has expired credentials. Valid credentials exist in ${globalPath}. Remove the local file or run 'uip login' to re-authenticate.`;
+    } catch {
+      return;
     }
-    const refreshedExp = getTokenExpiration(refreshedAccess);
-    if (!refreshedExp || refreshedExp <= new Date) {
+  };
+  if (expiration && expiration <= outerThreshold && refreshToken) {
+    let release;
+    try {
+      release = await getFs().acquireLock(absolutePath);
+    } catch (error) {
+      const msg = errorMessage(error);
+      const globalHint = await tryGlobalCredsHint();
+      if (globalHint) {
+        return {
+          loginStatus: "Expired",
+          accessToken,
+          refreshToken,
+          baseUrl: credentials.UIPATH_URL,
+          organizationName: credentials.UIPATH_ORGANIZATION_NAME,
+          organizationId: credentials.UIPATH_ORGANIZATION_ID,
+          tenantName: credentials.UIPATH_TENANT_NAME,
+          tenantId: credentials.UIPATH_TENANT_ID,
+          expiration,
+          source: "file" /* File */,
+          hint: globalHint,
+          tokenRefresh: {
+            attempted: false,
+            success: false,
+            errorMessage: `lock acquisition failed: ${msg}`
+          }
+        };
+      }
       return {
         loginStatus: "Refresh Failed",
-        hint: "The identity server returned an unusable token. Run 'uip login' to re-authenticate.",
+        hint: "Could not acquire the auth-file lock — too many concurrent `uip` processes, or a permission issue on the auth directory. Retry, or run 'uip login' to re-authenticate.",
         tokenRefresh: {
-          attempted: true,
+          attempted: false,
           success: false,
-          errorMessage: "refreshed token has no valid expiration claim"
+          errorMessage: `lock acquisition failed: ${msg}`
         }
       };
     }
-    accessToken = refreshedAccess;
-    refreshToken = refreshedRefresh;
-    expiration = refreshedExp;
+    let lockedFailure;
     try {
-      await saveEnvFile({
-        envPath: absolutePath,
-        data: {
-          UIPATH_ACCESS_TOKEN: accessToken,
-          UIPATH_REFRESH_TOKEN: refreshToken
-        },
-        merge: true
+      const outcome = await runRefreshLocked({
+        absolutePath,
+        refreshToken,
+        customAuthority: credentials.UIPATH_URL,
+        ensureTokenValidityMinutes,
+        loadEnvFile,
+        saveEnvFile,
+        refreshFn: refreshTokenFn,
+        resolveConfig
       });
-      tokenRefresh = {
-        attempted: true,
-        success: true
-      };
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      persistenceWarning = `Access token refreshed in memory but could not be written to ${absolutePath}: ${msg}. The next CLI invocation will fail until the file can be updated — run 'uip login' to re-authenticate.`;
-      tokenRefresh = {
-        attempted: true,
-        success: true,
-        errorMessage: `persistence failed: ${msg}`
-      };
+      if (outcome.kind === "fail") {
+        lockedFailure = outcome.status;
+      } else {
+        accessToken = outcome.accessToken;
+        refreshToken = outcome.refreshToken;
+        expiration = outcome.expiration;
+        tokenRefresh = outcome.tokenRefresh;
+        if (outcome.persistenceWarning) {
+          persistenceWarning = outcome.persistenceWarning;
+        }
+      }
+    } finally {
+      try {
+        await release();
+      } catch {
+        lockReleaseFailed = true;
+      }
+    }
+    if (lockedFailure) {
+      const globalHint = await tryGlobalCredsHint();
+      const base = globalHint ? {
+        ...lockedFailure,
+        loginStatus: "Expired",
+        hint: globalHint
+      } : lockedFailure;
+      return lockReleaseFailed ? { ...base, lockReleaseFailed: true } : base;
     }
   }
   const result = {
@@ -20823,23 +21057,13 @@ var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
     expiration,
     source: "file" /* File */,
     ...persistenceWarning ? { hint: persistenceWarning, persistenceFailed: true } : {},
+    ...lockReleaseFailed ? { lockReleaseFailed: true } : {},
     ...tokenRefresh ? { tokenRefresh } : {}
   };
   if (result.loginStatus === "Expired") {
-    const fs7 = getFs();
-    const globalPath = fs7.path.join(fs7.env.homedir(), envFilePath);
-    if (absolutePath !== globalPath && await fs7.exists(globalPath)) {
-      try {
-        const globalCreds = await loadEnvFile({
-          envPath: globalPath
-        });
-        if (globalCreds.UIPATH_ACCESS_TOKEN) {
-          const globalExp = getTokenExpiration(globalCreds.UIPATH_ACCESS_TOKEN);
-          if (!globalExp || globalExp > new Date) {
-            result.hint = `Local credentials file at ${absolutePath} has expired credentials. Valid credentials exist in ${globalPath}. Remove the local file or run 'uip login' to re-authenticate.`;
-          }
-        }
-      } catch {}
+    const globalHint = await tryGlobalCredsHint();
+    if (globalHint) {
+      result.hint = globalHint;
     }
   }
   return result;
@@ -20856,7 +21080,8 @@ var getLoginStatusAsync = async (options = {}) => {
 // src/authContext.ts
 var getAuthContext = async (options = {}) => {
   const status = await getLoginStatusAsync({
-    ensureTokenValidityMinutes: options.ensureTokenValidityMinutes
+    ensureTokenValidityMinutes: options.ensureTokenValidityMinutes,
+    envFilePath: options.envFilePath
   });
   if (status.loginStatus !== "Logged in" || !status.baseUrl || !status.accessToken) {
     throw new Error(status.hint ? `Not logged in. ${status.hint}` : "Not logged in. Run 'uip login' first.");
@@ -20883,6 +21108,34 @@ var getAuthContext = async (options = {}) => {
     tenantName
   };
 };
+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 };
+};
 // src/clientCredentials.ts
 var clientCredentialsLogin = async ({
   clientId,
@@ -20899,9 +21152,11 @@ var clientCredentialsLogin = async ({
   const params = {
     grant_type: "client_credentials",
     client_id: config.clientId,
-    client_secret: config.clientSecret ?? "",
-    scope: config.scopes.join(" ")
+    client_secret: config.clientSecret ?? ""
   };
+  if (config.scopes.length > 0) {
+    params.scope = config.scopes.join(" ");
+  }
   const tokenResponse = await fetch(config.tokenEndpoint, {
     method: "POST",
     headers: {
@@ -21017,7 +21272,8 @@ var interactiveLoginWithDeps = async (options, deps) => {
     tenant,
     organization,
     interactive,
-    onEvent
+    onEvent,
+    timeoutMs
   } = options;
   const emit = (event) => {
     if (!onEvent)
@@ -21045,7 +21301,8 @@ var interactiveLoginWithDeps = async (options, deps) => {
       clientId,
       clientSecret,
       scope,
-      organization
+      organization,
+      timeoutMs
     });
     return {
       UIPATH_ACCESS_TOKEN: authTokens.accessToken,
@@ -21109,11 +21366,25 @@ var interactiveLoginWithDeps = async (options, deps) => {
       searchDir = parentDir;
     }
   }
-  await saveEnvFile({
-    envPath: savePath,
-    data: credentials,
-    merge: true
-  });
+  let saveRelease;
+  try {
+    if (typeof fs7.acquireLock === "function") {
+      saveRelease = await fs7.acquireLock(savePath);
+    }
+  } catch {
+    saveRelease = undefined;
+  }
+  try {
+    await saveEnvFile({
+      envPath: savePath,
+      data: credentials,
+      merge: true
+    });
+  } finally {
+    if (saveRelease) {
+      await saveRelease().catch(() => {});
+    }
+  }
   const reportedPath = fs7.path.isAbsolute(savePath) ? savePath : fs7.path.join(fs7.env.homedir(), savePath);
   emit({
     type: "saved",
@@ -21135,7 +21406,21 @@ async function logoutWithDeps(options, deps = {}) {
   const fs7 = getFs();
   const { absolutePath } = await resolveEnvFilePath(options.file);
   if (absolutePath && await fs7.exists(absolutePath)) {
-    await fs7.rm(absolutePath);
+    let release;
+    try {
+      if (typeof fs7.acquireLock === "function") {
+        release = await fs7.acquireLock(absolutePath);
+      }
+    } catch {
+      release = undefined;
+    }
+    try {
+      await fs7.rm(absolutePath);
+    } finally {
+      if (release) {
+        await release().catch(() => {});
+      }
+    }
     return {
       success: true,
       message: `Logged out successfully. Removed ${absolutePath}`,
@@ -21153,13 +21438,15 @@ async function logout(options) {
 }
 
 // src/index.ts
+init_server();
 var authenticate = async ({
   baseUrl,
   clientId,
   clientSecret,
   redirectUri,
   scope,
-  organization
+  organization,
+  timeoutMs
 }) => {
   const config = await resolveConfigAsync({
     customAuthority: baseUrl,
@@ -21209,7 +21496,7 @@ var authenticate = async ({
     const { NodeAuthStrategy: NodeAuthStrategy2 } = await Promise.resolve().then(() => (init_node_strategy(), exports_node_strategy));
     strategy = new NodeAuthStrategy2;
   }
-  const code = await strategy.execute(authUrl, effectiveRedirectUriUrl, state);
+  const code = await strategy.execute(authUrl, effectiveRedirectUriUrl, state, { timeoutMs });
   return await exchangeCodeForTokens({
     code,
     codeVerifier: code_verifier,
@@ -21240,6 +21527,7 @@ export {
   interactiveLogin,
   getLoginStatusWithDeps,
   getLoginStatusAsync,
+  getAuthEnv,
   getAuthContext,
   fetchTenantsAndOrganizations,
   clientCredentialsLogin,
@@ -21252,5 +21540,6 @@ export {
   ENV_AUTH_ENABLE_VAR,
   ENFORCE_ROBOT_AUTH_VAR,
   DEFAULT_ENV_FILENAME,
-  DEFAULT_AUTH_FILENAME
+  DEFAULT_AUTH_FILENAME,
+  AUTH_TIMEOUT_ERROR_CODE
 };