@vercel/oidc 3.1.0 → 3.2.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @vercel/oidc
 
+## 3.2.1
+
+### Patch Changes
+
+- Pin `typedoc-plugin-markdown` to `3.15.2` and `typedoc-plugin-mdn-links` to `3.0.3` to match the version used by `@vercel/edge`. The previous `4.1.2` version requires `typedoc@0.26.x` as a peer dependency but was paired with `typedoc@0.24.6`, which caused CI failures whenever pnpm hoisted the 4.x plugin (the plugin calls `app.internationalization.addTranslations`, which does not exist in typedoc 0.24). The choice of which plugin version got hoisted was non-deterministic, which is why the failure appeared as flaky `Build @vercel/<pkg>` steps in CI. ([#16072](https://github.com/vercel/vercel/pull/16072))
+
+## 3.2.0
+
+### Minor Changes
+
+- - Add optional `team` and `project` parameters to `getVercelOidcToken()` to allow explicit control over token refresh behavior instead of always reading from `.vercel/project.json` ([#14864](https://github.com/vercel/vercel/pull/14864))
+  - Add `expirationBufferMs` option to both `getVercelOidcToken()` and `getVercelToken()` to proactively refresh tokens before they expire (useful for avoiding auth errors mid-request)
+  - Export `getVercelToken()` function with `GetVercelTokenOptions` interface to allow refreshing CLI tokens with configurable expiration buffer
+
 ## 3.1.0
 
 ### Minor Changes

package/README.md

@@ -1,3 +1,41 @@
 # `@vercel/oidc`
 
 Runtime OIDC helper methods intended to be used with your Vercel Functions
+
+## Usage
+
+### Getting an OIDC Token
+
+```typescript
+import { getVercelOidcToken } from '@vercel/oidc';
+
+// Get token using project.json configuration
+const token = await getVercelOidcToken();
+
+// Get token with explicit project and team (supports both IDs and slugs)
+const token = await getVercelOidcToken({
+  project: 'my-project', // or 'prj_abc123'
+  team: 'my-team', // or 'team_xyz789'
+});
+
+// Get token with expiration buffer (refresh if expires within 5 minutes)
+const token = await getVercelOidcToken({
+  expirationBufferMs: 5 * 60 * 1000,
+});
+```
+
+## API
+
+### `getVercelOidcToken(options?)`
+
+Gets the current OIDC token from the request context or environment variable. Will refresh the token if expired in development.
+
+**Options:**
+
+- `project?: string` - Project ID (prj\_\*) or slug
+- `team?: string` - Team ID (team\_\*) or slug
+- `expirationBufferMs?: number` - Buffer time in ms before expiry to trigger refresh (default: 0)
+
+### `getVercelOidcTokenSync()`
+
+Synchronously gets the current OIDC token without refreshing. Use `getVercelOidcToken()` if you need automatic refresh in development.

package/dist/auth-config.d.ts

@@ -27,4 +27,4 @@ export declare function writeAuthConfig(config: AuthConfig): void;
  * Check if an access token is valid (not expired)
  * Copied from packages/cli/src/util/client.ts:72-81
  */
-export declare function isValidAccessToken(authConfig: AuthConfig): boolean;
+export declare function isValidAccessToken(authConfig: AuthConfig, expirationBufferMs?: number): boolean;

package/dist/auth-config.js

@@ -56,7 +56,7 @@ function readAuthConfig() {
       return null;
     }
     return JSON.parse(content);
-  } catch (error) {
+  } catch (_error) {
     return null;
   }
 }
@@ -68,13 +68,14 @@ function writeAuthConfig(config) {
   }
   fs.writeFileSync(authPath, JSON.stringify(config, null, 2), { mode: 384 });
 }
-function isValidAccessToken(authConfig) {
+function isValidAccessToken(authConfig, expirationBufferMs = 0) {
   if (!authConfig.token)
     return false;
   if (typeof authConfig.expiresAt !== "number")
     return true;
   const nowInSeconds = Math.floor(Date.now() / 1e3);
-  return authConfig.expiresAt >= nowInSeconds;
+  const bufferInSeconds = expirationBufferMs / 1e3;
+  return authConfig.expiresAt >= nowInSeconds + bufferInSeconds;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/auth-errors.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Error thrown when no authentication configuration is found.
+ * This typically means the user needs to log in.
+ */
+export declare class AccessTokenMissingError extends Error {
+    name: string;
+    constructor();
+}
+/**
+ * Error thrown when attempting to refresh the authentication token fails.
+ * This includes cases where no refresh token is available.
+ */
+export declare class RefreshAccessTokenFailedError extends Error {
+    name: string;
+    constructor(cause?: unknown);
+}

package/dist/auth-errors.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var auth_errors_exports = {};
+__export(auth_errors_exports, {
+  AccessTokenMissingError: () => AccessTokenMissingError,
+  RefreshAccessTokenFailedError: () => RefreshAccessTokenFailedError
+});
+module.exports = __toCommonJS(auth_errors_exports);
+class AccessTokenMissingError extends Error {
+  constructor() {
+    super(
+      "No authentication found. Please log in with the Vercel CLI (vercel login)."
+    );
+    this.name = "AccessTokenMissingError";
+  }
+}
+class RefreshAccessTokenFailedError extends Error {
+  constructor(cause) {
+    super("Failed to refresh authentication token.", { cause });
+    this.name = "RefreshAccessTokenFailedError";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessTokenMissingError,
+  RefreshAccessTokenFailedError
+});

package/dist/get-vercel-oidc-token.d.ts

@@ -1,3 +1,24 @@
+/**
+ * Options for getting the Vercel OIDC token.
+ */
+export interface GetVercelOidcTokenOptions {
+    /**
+     * Optional team ID (team_*) or slug to use for token refresh.
+     * When provided, this team will be used instead of reading from `.vercel/project.json`.
+     */
+    team?: string;
+    /**
+     * Optional project ID (prj_*) or slug to use for token refresh.
+     * When provided, this project will be used instead of reading from `.vercel/project.json`.
+     */
+    project?: string;
+    /**
+     * Optional time buffer in milliseconds before token expiry to consider it expired.
+     * When provided, the token will be refreshed if it expires within this buffer time.
+     * @default 0
+     */
+    expirationBufferMs?: number;
+}
 /**
  * Gets the current OIDC token from the request context or the environment variable.
  *
@@ -8,6 +29,7 @@
  *
  * Unlike the `getVercelOidcTokenSync` function, this function will refresh the token if it is expired in a development environment.
  *
+ * @param {GetVercelOidcTokenOptions} [options] - Optional configuration for token retrieval.
  * @returns {Promise<string>} A promise that resolves to the OIDC token.
  * @throws {Error} If the `x-vercel-oidc-token` header is missing from the request context and the environment variable `VERCEL_OIDC_TOKEN` is not set. If the token
  * is expired in a development environment, will also throw an error if the token cannot be refreshed: no CLI credentials are available, CLI credentials are expired, no project configuration is available
@@ -23,8 +45,19 @@
  *   console.error('Error:', error.message);
  * });
  * ```
+ *
+ * @example
+ *
+ * ```js
+ * // Using the OIDC token with explicit team and project (supports IDs and slugs)
+ * getVercelOidcToken({ team: 'my-team', project: 'my-project' }).then((token) => {
+ *   console.log('OIDC Token:', token);
+ * }).catch((error) => {
+ *   console.error('Error:', error.message);
+ * });
+ * ```
  */
-export declare function getVercelOidcToken(): Promise<string>;
+export declare function getVercelOidcToken(options?: GetVercelOidcTokenOptions): Promise<string>;
 /**
  * Gets the current OIDC token from the request context or the environment variable.
  *

package/dist/get-vercel-oidc-token.js

@@ -34,7 +34,7 @@ __export(get_vercel_oidc_token_exports, {
 module.exports = __toCommonJS(get_vercel_oidc_token_exports);
 var import_get_context = require("./get-context");
 var import_token_error = require("./token-error");
-async function getVercelOidcToken() {
+async function getVercelOidcToken(options) {
   let token = "";
   let err;
   try {
@@ -47,8 +47,8 @@ async function getVercelOidcToken() {
       await import("./token-util.js"),
       await import("./token.js")
     ]);
-    if (!token || isExpired(getTokenPayload(token))) {
-      await refreshToken();
+    if (!token || isExpired(getTokenPayload(token), options?.expirationBufferMs)) {
+      await refreshToken(options);
       token = getVercelOidcTokenSync();
     }
   } catch (error) {

package/dist/get-vercel-oidc-token.test.js

@@ -38,8 +38,8 @@ import_vitest.vi.mock("./get-context", () => ({
   let userDataDir;
   let cliDataDir;
   let tokenDataDir;
-  const projectId = "test-project-id";
-  const teamId = "test-team-id";
+  const projectId = "prj_test123";
+  const teamId = "team_test456";
   (0, import_vitest.beforeEach)(() => {
     import_vitest.vi.clearAllMocks();
     import_vitest.vi.restoreAllMocks();
@@ -63,14 +63,14 @@ import_vitest.vi.mock("./get-context", () => ({
       fs.rmSync(rootDir, { recursive: true, force: true });
     }
   });
-  (0, import_vitest.test)("should throw helpful error when CLI auth file is missing", async () => {
+  (0, import_vitest.test)("should throw AccessTokenMissingError when CLI auth file is missing", async () => {
     fs.writeFileSync(
       path.join(rootDir, ".vercel", "project.json"),
       JSON.stringify({ projectId, orgId: teamId })
     );
     process.env.VERCEL_OIDC_TOKEN = createExpiredToken();
     await (0, import_vitest.expect)((0, import_get_vercel_oidc_token.getVercelOidcToken)()).rejects.toThrow(
-      /Failed to refresh OIDC token: Log in to Vercel CLI and link your project with `vc link`/
+      /No authentication found/
     );
   });
   (0, import_vitest.test)("should throw helpful error when project.json is missing", async () => {
@@ -216,6 +216,124 @@ import_vitest.vi.mock("./get-context", () => ({
     const token = await (0, import_get_vercel_oidc_token.getVercelOidcToken)();
     (0, import_vitest.expect)(token).toBe(newToken);
   });
+  (0, import_vitest.test)("should use provided team and project for refresh instead of reading project.json", async () => {
+    const customProjectId = "prj_custom123";
+    const customTeamId = "team_custom456";
+    fs.writeFileSync(
+      path.join(cliDataDir, "auth.json"),
+      JSON.stringify({ token: "test-auth-token" })
+    );
+    const newToken = createValidToken("custom-token");
+    const getVercelOidcTokenSpy = import_vitest.vi.spyOn(tokenUtil, "getVercelOidcToken").mockResolvedValue({
+      token: newToken
+    });
+    import_vitest.vi.spyOn(tokenUtil, "getTokenPayload").mockReturnValueOnce({
+      sub: "test-sub",
+      name: "test-name",
+      exp: Date.now() / 1e3 - 1e3
+    }).mockReturnValue({
+      sub: "test-sub",
+      name: "test-name",
+      exp: Date.now() / 1e3 + 43200
+    });
+    process.env.VERCEL_OIDC_TOKEN = createExpiredToken();
+    const token = await (0, import_get_vercel_oidc_token.getVercelOidcToken)({
+      team: customTeamId,
+      project: customProjectId
+    });
+    (0, import_vitest.expect)(token).toBe(newToken);
+    (0, import_vitest.expect)(getVercelOidcTokenSpy).toHaveBeenCalledWith(
+      "test-auth-token",
+      customProjectId,
+      customTeamId
+    );
+  });
+  (0, import_vitest.test)("should use provided project and read team from project.json", async () => {
+    const customProjectId = "prj_custom234";
+    fs.writeFileSync(
+      path.join(cliDataDir, "auth.json"),
+      JSON.stringify({ token: "test-auth-token" })
+    );
+    fs.writeFileSync(
+      path.join(rootDir, ".vercel", "project.json"),
+      JSON.stringify({ projectId: "original-project-id", orgId: teamId })
+    );
+    const newToken = createValidToken("partial-custom-token");
+    const getVercelOidcTokenSpy = import_vitest.vi.spyOn(tokenUtil, "getVercelOidcToken").mockResolvedValue({
+      token: newToken
+    });
+    import_vitest.vi.spyOn(tokenUtil, "getTokenPayload").mockReturnValueOnce({
+      sub: "test-sub",
+      name: "test-name",
+      exp: Date.now() / 1e3 - 1e3
+    }).mockReturnValue({
+      sub: "test-sub",
+      name: "test-name",
+      exp: Date.now() / 1e3 + 43200
+    });
+    process.env.VERCEL_OIDC_TOKEN = createExpiredToken();
+    const token = await (0, import_get_vercel_oidc_token.getVercelOidcToken)({
+      project: customProjectId
+    });
+    (0, import_vitest.expect)(token).toBe(newToken);
+    (0, import_vitest.expect)(getVercelOidcTokenSpy).toHaveBeenCalledWith(
+      "test-auth-token",
+      customProjectId,
+      teamId
+    );
+  });
+  (0, import_vitest.test)("should use provided team and read project from project.json", async () => {
+    const customTeamId = "team_custom789";
+    fs.writeFileSync(
+      path.join(cliDataDir, "auth.json"),
+      JSON.stringify({ token: "test-auth-token" })
+    );
+    fs.writeFileSync(
+      path.join(rootDir, ".vercel", "project.json"),
+      JSON.stringify({ projectId, orgId: "original-team-id" })
+    );
+    const newToken = createValidToken("partial-custom-token-2");
+    const getVercelOidcTokenSpy = import_vitest.vi.spyOn(tokenUtil, "getVercelOidcToken").mockResolvedValue({
+      token: newToken
+    });
+    import_vitest.vi.spyOn(tokenUtil, "getTokenPayload").mockReturnValueOnce({
+      sub: "test-sub",
+      name: "test-name",
+      exp: Date.now() / 1e3 - 1e3
+    }).mockReturnValue({
+      sub: "test-sub",
+      name: "test-name",
+      exp: Date.now() / 1e3 + 43200
+    });
+    process.env.VERCEL_OIDC_TOKEN = createExpiredToken();
+    const token = await (0, import_get_vercel_oidc_token.getVercelOidcToken)({
+      team: customTeamId
+    });
+    (0, import_vitest.expect)(token).toBe(newToken);
+    (0, import_vitest.expect)(getVercelOidcTokenSpy).toHaveBeenCalledWith(
+      "test-auth-token",
+      projectId,
+      customTeamId
+    );
+  });
+  (0, import_vitest.test)("should not refresh when token is valid even with options provided", async () => {
+    const validToken = createValidToken();
+    process.env.VERCEL_OIDC_TOKEN = validToken;
+    const getVercelOidcTokenSpy = import_vitest.vi.spyOn(tokenUtil, "getVercelOidcToken").mockResolvedValue({
+      token: "should-not-be-called"
+    });
+    import_vitest.vi.spyOn(tokenUtil, "getTokenPayload").mockReturnValue({
+      sub: "test-sub",
+      name: "test-name",
+      exp: Date.now() / 1e3 + 43200
+    });
+    const token = await (0, import_get_vercel_oidc_token.getVercelOidcToken)({
+      team: "custom-team",
+      project: "custom-project"
+    });
+    (0, import_vitest.expect)(token).toBe(validToken);
+    (0, import_vitest.expect)(getVercelOidcTokenSpy).not.toHaveBeenCalled();
+  });
 });
 function createExpiredToken() {
   const header = Buffer.from(

package/dist/index-browser.d.ts

@@ -1,3 +1,5 @@
 export { getContext } from './get-context';
+export { AccessTokenMissingError, RefreshAccessTokenFailedError, } from './auth-errors';
 export declare function getVercelOidcToken(): Promise<string>;
 export declare function getVercelOidcTokenSync(): string;
+export declare function getVercelToken(): Promise<string>;

package/dist/index-browser.js

@@ -18,21 +18,31 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_browser_exports = {};
 __export(index_browser_exports, {
+  AccessTokenMissingError: () => import_auth_errors.AccessTokenMissingError,
+  RefreshAccessTokenFailedError: () => import_auth_errors.RefreshAccessTokenFailedError,
   getContext: () => import_get_context.getContext,
   getVercelOidcToken: () => getVercelOidcToken,
-  getVercelOidcTokenSync: () => getVercelOidcTokenSync
+  getVercelOidcTokenSync: () => getVercelOidcTokenSync,
+  getVercelToken: () => getVercelToken
 });
 module.exports = __toCommonJS(index_browser_exports);
 var import_get_context = require("./get-context");
+var import_auth_errors = require("./auth-errors");
 async function getVercelOidcToken() {
   return "";
 }
 function getVercelOidcTokenSync() {
   return "";
 }
+async function getVercelToken() {
+  throw new Error("getVercelToken is not supported in browser environments");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AccessTokenMissingError,
+  RefreshAccessTokenFailedError,
   getContext,
   getVercelOidcToken,
-  getVercelOidcTokenSync
+  getVercelOidcTokenSync,
+  getVercelToken
 });

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 export { getVercelOidcToken, getVercelOidcTokenSync, } from './get-vercel-oidc-token';
 export { getContext } from './get-context';
+export { AccessTokenMissingError, RefreshAccessTokenFailedError, } from './auth-errors';
+export { getVercelToken } from './token-util';

package/dist/index.js

@@ -18,16 +18,24 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
 __export(src_exports, {
+  AccessTokenMissingError: () => import_auth_errors.AccessTokenMissingError,
+  RefreshAccessTokenFailedError: () => import_auth_errors.RefreshAccessTokenFailedError,
   getContext: () => import_get_context.getContext,
   getVercelOidcToken: () => import_get_vercel_oidc_token.getVercelOidcToken,
-  getVercelOidcTokenSync: () => import_get_vercel_oidc_token.getVercelOidcTokenSync
+  getVercelOidcTokenSync: () => import_get_vercel_oidc_token.getVercelOidcTokenSync,
+  getVercelToken: () => import_token_util.getVercelToken
 });
 module.exports = __toCommonJS(src_exports);
 var import_get_vercel_oidc_token = require("./get-vercel-oidc-token");
 var import_get_context = require("./get-context");
+var import_auth_errors = require("./auth-errors");
+var import_token_util = require("./token-util");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AccessTokenMissingError,
+  RefreshAccessTokenFailedError,
   getContext,
   getVercelOidcToken,
-  getVercelOidcTokenSync
+  getVercelOidcTokenSync,
+  getVercelToken
 });

package/dist/token-io.js

@@ -46,7 +46,7 @@ function findRootDir() {
       }
       dir = import_path.default.dirname(dir);
     }
-  } catch (e) {
+  } catch (_e) {
     throw new import_token_error.VercelOidcTokenError(
       "Token refresh only supported in node server environments"
     );

package/dist/token-util.d.ts

@@ -1,5 +1,13 @@
 export declare function getVercelDataDir(): string | null;
-export declare function getVercelCliToken(): Promise<string | null>;
+export interface GetVercelTokenOptions {
+    /**
+     * Optional time buffer in milliseconds before token expiry to consider it expired.
+     * When provided, the token will be refreshed if it expires within this buffer time.
+     * @default 0
+     */
+    expirationBufferMs?: number;
+}
+export declare function getVercelToken(options?: GetVercelTokenOptions): Promise<string>;
 interface VercelTokenResponse {
     token: string;
 }
@@ -17,5 +25,5 @@ interface TokenPayload {
     exp: number;
 }
 export declare function getTokenPayload(token: string): TokenPayload;
-export declare function isExpired(token: TokenPayload): boolean;
+export declare function isExpired(token: TokenPayload, bufferMs?: number): boolean;
 export {};

package/dist/token-util.js

@@ -31,9 +31,9 @@ __export(token_util_exports, {
   assertVercelOidcTokenResponse: () => assertVercelOidcTokenResponse,
   findProjectInfo: () => findProjectInfo,
   getTokenPayload: () => getTokenPayload,
-  getVercelCliToken: () => getVercelCliToken,
   getVercelDataDir: () => getVercelDataDir,
   getVercelOidcToken: () => getVercelOidcToken,
+  getVercelToken: () => getVercelToken,
   isExpired: () => isExpired,
   loadToken: () => loadToken,
   saveToken: () => saveToken
@@ -45,6 +45,7 @@ var import_token_error = require("./token-error");
 var import_token_io = require("./token-io");
 var import_auth_config = require("./auth-config");
 var import_oauth = require("./oauth");
+var import_auth_errors = require("./auth-errors");
 function getVercelDataDir() {
   const vercelFolder = "com.vercel.cli";
   const dataDir = (0, import_token_io.getUserDataDir)();
@@ -53,17 +54,17 @@ function getVercelDataDir() {
   }
   return path.join(dataDir, vercelFolder);
 }
-async function getVercelCliToken() {
+async function getVercelToken(options) {
   const authConfig = (0, import_auth_config.readAuthConfig)();
-  if (!authConfig) {
-    return null;
+  if (!authConfig?.token) {
+    throw new import_auth_errors.AccessTokenMissingError();
   }
-  if ((0, import_auth_config.isValidAccessToken)(authConfig)) {
-    return authConfig.token || null;
+  if ((0, import_auth_config.isValidAccessToken)(authConfig, options?.expirationBufferMs)) {
+    return authConfig.token;
   }
   if (!authConfig.refreshToken) {
     (0, import_auth_config.writeAuthConfig)({});
-    return null;
+    throw new import_auth_errors.RefreshAccessTokenFailedError("No refresh token available");
   }
   try {
     const tokenResponse = await (0, import_oauth.refreshTokenRequest)({
@@ -72,7 +73,7 @@ async function getVercelCliToken() {
     const [tokensError, tokens] = await (0, import_oauth.processTokenResponse)(tokenResponse);
     if (tokensError || !tokens) {
       (0, import_auth_config.writeAuthConfig)({});
-      return null;
+      throw new import_auth_errors.RefreshAccessTokenFailedError(tokensError);
     }
     const updatedConfig = {
       token: tokens.access_token,
@@ -82,10 +83,13 @@ async function getVercelCliToken() {
       updatedConfig.refreshToken = tokens.refresh_token;
     }
     (0, import_auth_config.writeAuthConfig)(updatedConfig);
-    return updatedConfig.token ?? null;
+    return updatedConfig.token;
   } catch (error) {
     (0, import_auth_config.writeAuthConfig)({});
-    return null;
+    if (error instanceof import_auth_errors.AccessTokenMissingError || error instanceof import_auth_errors.RefreshAccessTokenFailedError) {
+      throw error;
+    }
+    throw new import_auth_errors.RefreshAccessTokenFailedError(error);
   }
 }
 async function getVercelOidcToken(authToken, projectId, teamId) {
@@ -181,17 +185,17 @@ function getTokenPayload(token) {
   );
   return JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
 }
-function isExpired(token) {
-  return token.exp * 1e3 < Date.now();
+function isExpired(token, bufferMs = 0) {
+  return token.exp * 1e3 < Date.now() + bufferMs;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   assertVercelOidcTokenResponse,
   findProjectInfo,
   getTokenPayload,
-  getVercelCliToken,
   getVercelDataDir,
   getVercelOidcToken,
+  getVercelToken,
   isExpired,
   loadToken,
   saveToken