fix(auth): prefer stored OAuth over env token by default (#646)

When SENTRY_AUTH_TOKEN is set by build tooling (e.g. the Sentry wizard)
but lacks the scopes needed for interactive CLI commands, the CLI now
prefers stored OAuth credentials by default.

OAuth-preferred default: when the user is logged in via OAuth, env
tokens are automatically skipped. This prevents wizard-generated build
tokens from silently overriding interactive credentials. Set
SENTRY_FORCE_ENV_TOKEN=1 to restore the old env-token-first priority.

Key changes:
- getEnvToken() returns undefined when stored OAuth credentials exist,
  cascading through all consumers (isEnvTokenActive, refreshToken, etc.)
- SENTRY_FORCE_ENV_TOKEN env var to force env token priority
- sentry auth login no longer blocks when an env token is present
- sentry auth status shows env token info (active vs bypassed)
- Enhanced 401/403 error messages when env token is the only auth source

Author: BYK

src/commands/auth/login.ts

@@ -9,6 +9,7 @@ import { buildCommand, numberParser } from "../../lib/command.js";
 import {
   clearAuth,
   getActiveEnvVarName,
+  hasStoredAuthCredentials,
   isAuthenticated,
   isEnvTokenActive,
   setAuthToken,
@@ -71,11 +72,15 @@ type LoginFlags = {
 async function handleExistingAuth(force: boolean): Promise<boolean> {
   if (isEnvTokenActive()) {
     const envVar = getActiveEnvVarName();
-    log.info(
-      `Authentication is provided via ${envVar} environment variable. ` +
-        `Unset ${envVar} to use OAuth-based login instead.`
+    log.warn(
+      `${envVar} is set in your environment (likely from build tooling).\n` +
+        "  OAuth credentials will be stored separately and used for CLI commands."
     );
-    return false;
+    // If no stored OAuth token exists, proceed directly to login
+    if (!hasStoredAuthCredentials()) {
+      return true;
+    }
+    // Fall through to the re-auth confirmation logic below
   }
 
   if (!force) {

src/commands/auth/status.ts

@@ -11,8 +11,11 @@ import {
   type AuthConfig,
   type AuthSource,
   ENV_SOURCE_PREFIX,
+  getActiveEnvVarName,
   getAuthConfig,
+  getRawEnvToken,
   isAuthenticated,
+  isEnvTokenActive,
 } from "../../lib/db/auth.js";
 import {
   getDefaultOrganization,
@@ -77,6 +80,13 @@ export type AuthStatusData = {
     /** Error message if verification failed */
     error?: string;
   };
+  /** Environment variable token info (present when SENTRY_AUTH_TOKEN or SENTRY_TOKEN is set) */
+  envToken?: {
+    /** Name of the env var (e.g., "SENTRY_AUTH_TOKEN") */
+    envVar: string;
+    /** Whether the env token is the effective auth source (vs bypassed for OAuth) */
+    active: boolean;
+  };
 };
 
 /**
@@ -186,6 +196,13 @@ export const statusCommand = buildCommand({
         : undefined;
     }
 
+    // Check for env token regardless of whether it's the active source
+    // (it may be set but bypassed because stored OAuth takes priority)
+    const rawEnv = getRawEnvToken();
+    const envTokenData: AuthStatusData["envToken"] = rawEnv
+      ? { envVar: getActiveEnvVarName(), active: isEnvTokenActive() }
+      : undefined;
+
     const data: AuthStatusData = {
       authenticated: true,
       source: auth?.source ?? "oauth",
@@ -194,6 +211,7 @@ export const statusCommand = buildCommand({
       token: collectTokenInfo(auth, flags["show-token"]),
       defaults: collectDefaults(),
       verification: await verifyCredentials(),
+      envToken: envTokenData,
     };
 
     yield new CommandOutput(data);

src/lib/api/infrastructure.ts

@@ -10,6 +10,7 @@
 import * as Sentry from "@sentry/node-core/light";
 import type { z } from "zod";
 
+import { getRawEnvToken } from "../db/auth.js";
 import { getEnv } from "../env.js";
 import { ApiError, AuthError, stringifyUnknown } from "../errors.js";
 import { resolveOrgRegion } from "../region.js";
@@ -57,6 +58,29 @@ export function throwApiError(
     error && typeof error === "object" && "detail" in error
       ? stringifyUnknown((error as { detail: unknown }).detail)
       : stringifyUnknown(error);
+
+  // When an env token is set and we get 401, the HTTP-layer fallback to
+  // stored OAuth already failed (no stored credentials). Convert to AuthError
+  // so the auto-login middleware in cli.ts can trigger interactive login.
+  if (status === 401 && getRawEnvToken()) {
+    throw new AuthError(
+      "not_authenticated",
+      `${context}: ${status} ${response.statusText ?? "Unknown"}.\n` +
+        "  SENTRY_AUTH_TOKEN is set but lacks permissions for this endpoint.\n" +
+        "  Run 'sentry auth login' to authenticate with OAuth."
+    );
+  }
+
+  // For 403 with env token, keep as ApiError but add guidance
+  if (status === 403 && getRawEnvToken()) {
+    throw new ApiError(
+      `${context}: ${status} ${response.statusText ?? "Unknown"}`,
+      status,
+      `${detail}\n\n  SENTRY_AUTH_TOKEN may lack permissions for this endpoint.\n` +
+        "  Run 'sentry auth login' to authenticate with OAuth."
+    );
+  }
+
   throw new ApiError(
     `${context}: ${status} ${response.statusText ?? "Unknown"}`,
     status,

src/lib/db/auth.ts

@@ -36,21 +36,64 @@ export type AuthConfig = {
   source: AuthSource;
 };
 
+/**
+ * Read the raw token string from environment variables, ignoring all filters.
+ *
+ * Unlike {@link getEnvToken}, this always returns the env token if set, even
+ * when stored OAuth credentials would normally take priority. Used by the HTTP
+ * layer to check "was an env token provided?" independent of whether it's being
+ * used, and by the per-endpoint permission cache.
+ */
+export function getRawEnvToken(): string | undefined {
+  const authToken = getEnv().SENTRY_AUTH_TOKEN?.trim();
+  if (authToken) {
+    return authToken;
+  }
+  const sentryToken = getEnv().SENTRY_TOKEN?.trim();
+  if (sentryToken) {
+    return sentryToken;
+  }
+  return;
+}
+
 /**
  * Read token from environment variables.
  * `SENTRY_AUTH_TOKEN` takes priority over `SENTRY_TOKEN` (matches legacy sentry-cli).
  * Empty or whitespace-only values are treated as unset.
+ *
+ * **Default behavior**: When the user is logged in (stored OAuth credentials
+ * exist in the database), env tokens are skipped so OAuth takes priority. This
+ * prevents wizard-generated build tokens from silently overriding interactive
+ * CLI credentials. Set `SENTRY_FORCE_ENV_TOKEN=1` to override this and force
+ * the env token to take priority (e.g., for CI pipelines that intentionally
+ * use an env token alongside stored credentials).
  */
 function getEnvToken(): { token: string; source: AuthSource } | undefined {
+  const raw = getRawEnvToken();
+  if (!raw) {
+    return;
+  }
+
+  // When OAuth credentials are stored and env token is not forced, prefer OAuth.
+  // This is the core fix for #646: wizard-generated tokens no longer silently
+  // override the user's interactive login.
+  const forceEnv = getEnv().SENTRY_FORCE_ENV_TOKEN?.trim();
+  if (!forceEnv) {
+    try {
+      if (hasStoredAuthCredentials()) {
+        return;
+      }
+    } catch {
+      // DB unavailable (e.g., read-only filesystem, test environment).
+      // Fall through to use the env token rather than breaking auth entirely.
+    }
+  }
+
   const authToken = getEnv().SENTRY_AUTH_TOKEN?.trim();
   if (authToken) {
     return { token: authToken, source: "env:SENTRY_AUTH_TOKEN" };
   }
-  const sentryToken = getEnv().SENTRY_TOKEN?.trim();
-  if (sentryToken) {
-    return { token: sentryToken, source: "env:SENTRY_TOKEN" };
-  }
-  return;
+  return { token: raw, source: "env:SENTRY_TOKEN" };
 }
 
 /**
@@ -62,17 +105,21 @@ export function isEnvTokenActive(): boolean {
 }
 
 /**
- * Get the name of the active env var providing authentication.
+ * Get the name of the env var providing a token, for error messages.
  * Returns the specific variable name (e.g. "SENTRY_AUTH_TOKEN" or "SENTRY_TOKEN").
  *
- * **Important**: Call only after checking {@link isEnvTokenActive} returns true.
- * Falls back to "SENTRY_AUTH_TOKEN" if no env source is active, which is a safe
- * default for error messages but may be misleading if used unconditionally.
+ * Uses {@link getRawEnvToken} (not {@link getEnvToken}) so the result is
+ * independent of whether stored OAuth takes priority.
+ * Falls back to "SENTRY_AUTH_TOKEN" if no env var is set.
  */
 export function getActiveEnvVarName(): string {
-  const env = getEnvToken();
-  if (env) {
-    return env.source.slice(ENV_SOURCE_PREFIX.length);
+  const authToken = getEnv().SENTRY_AUTH_TOKEN?.trim();
+  if (authToken) {
+    return "SENTRY_AUTH_TOKEN";
+  }
+  const sentryToken = getEnv().SENTRY_TOKEN?.trim();
+  if (sentryToken) {
+    return "SENTRY_TOKEN";
   }
   return "SENTRY_AUTH_TOKEN";
 }
@@ -179,6 +226,33 @@ export function isAuthenticated(): boolean {
   return !!token;
 }
 
+/**
+ * Check if usable OAuth credentials are stored in the database.
+ *
+ * Returns true when the `auth` table has either:
+ * - A non-expired token, or
+ * - An expired token with a refresh token (will be refreshed on next use)
+ *
+ * This is the gate for the "OAuth-preferred" default: when this returns true,
+ * {@link getEnvToken} skips the env token so OAuth takes priority. Also used
+ * by the login command to decide whether to prompt for re-authentication.
+ */
+export function hasStoredAuthCredentials(): boolean {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM auth WHERE id = 1").get() as
+    | AuthRow
+    | undefined;
+  if (!row?.token) {
+    return false;
+  }
+  // Non-expired token
+  if (!row.expires_at || Date.now() <= row.expires_at) {
+    return true;
+  }
+  // Expired but has refresh token — will be refreshed on next use
+  return !!row.refresh_token;
+}
+
 export type RefreshTokenOptions = {
   /** Bypass threshold check and always refresh */
   force?: boolean;
@@ -229,7 +303,7 @@ async function performTokenRefresh(
 export async function refreshToken(
   options: RefreshTokenOptions = {}
 ): Promise<RefreshTokenResult> {
-  // Env var tokens are assumed valid — no refresh, no expiry check
+  // Env var tokens are assumed valid — no refresh, no expiry check.
   const envToken = getEnvToken();
   if (envToken) {
     return { token: envToken.token, refreshed: false };

src/lib/formatters/human.ts

@@ -1826,6 +1826,10 @@ export function formatAuthStatus(data: AuthStatusData): string {
     lines.push(mdKvTable(authRows));
   }
 
+  if (data.envToken) {
+    lines.push(formatEnvTokenSection(data.envToken));
+  }
+
   if (data.defaults) {
     lines.push(formatDefaultsSection(data.defaults));
   }
@@ -1837,6 +1841,24 @@ export function formatAuthStatus(data: AuthStatusData): string {
   return renderMarkdown(lines.join("\n"));
 }
 
+/**
+ * Format the env token status section.
+ * Shows whether the env token is active or bypassed, and how many endpoints
+ * have been marked insufficient.
+ */
+function formatEnvTokenSection(
+  envToken: NonNullable<AuthStatusData["envToken"]>
+): string {
+  const status = envToken.active
+    ? "active"
+    : "set but not used (using OAuth credentials)";
+  const rows: [string, string][] = [
+    ["Env var", safeCodeSpan(envToken.envVar)],
+    ["Status", status],
+  ];
+  return `\n${mdKvTable(rows, "Environment Token")}`;
+}
+
 // Project Creation Formatting
 
 /** Input for the project-created success formatter */

test/commands/auth/login.test.ts

@@ -86,6 +86,7 @@ describe("loginCommand.func --token path", () => {
   let getCurrentUserSpy: ReturnType<typeof spyOn>;
   let setUserInfoSpy: ReturnType<typeof spyOn>;
   let runInteractiveLoginSpy: ReturnType<typeof spyOn>;
+  let hasStoredAuthCredentialsSpy: ReturnType<typeof spyOn>;
   let func: LoginFunc;
 
   beforeEach(async () => {
@@ -97,7 +98,9 @@ describe("loginCommand.func --token path", () => {
     getCurrentUserSpy = spyOn(apiClient, "getCurrentUser");
     setUserInfoSpy = spyOn(dbUser, "setUserInfo");
     runInteractiveLoginSpy = spyOn(interactiveLogin, "runInteractiveLogin");
+    hasStoredAuthCredentialsSpy = spyOn(dbAuth, "hasStoredAuthCredentials");
     isEnvTokenActiveSpy.mockReturnValue(false);
+    hasStoredAuthCredentialsSpy.mockReturnValue(false);
     func = (await loginCommand.loader()) as unknown as LoginFunc;
   });
 
@@ -110,6 +113,7 @@ describe("loginCommand.func --token path", () => {
     getCurrentUserSpy.mockRestore();
     setUserInfoSpy.mockRestore();
     runInteractiveLoginSpy.mockRestore();
+    hasStoredAuthCredentialsSpy.mockRestore();
   });
 
   test("already authenticated (non-TTY, no --force): prints re-auth message with --force hint", async () => {
@@ -122,33 +126,31 @@ describe("loginCommand.func --token path", () => {
     expect(getCurrentUserSpy).not.toHaveBeenCalled();
   });
 
-  test("already authenticated (env token SENTRY_AUTH_TOKEN): tells user to unset specific var", async () => {
+  test("already authenticated (env token SENTRY_AUTH_TOKEN): warns and proceeds to OAuth login", async () => {
     isAuthenticatedSpy.mockReturnValue(true);
     isEnvTokenActiveSpy.mockReturnValue(true);
-    // Need to also spy on getAuthConfig for the specific env var name
-    const getAuthConfigSpy = spyOn(dbAuth, "getAuthConfig");
-    getAuthConfigSpy.mockReturnValue({
-      token: "sntrys_env_123",
-      source: "env:SENTRY_AUTH_TOKEN",
-    });
+    hasStoredAuthCredentialsSpy.mockReturnValue(false);
+    runInteractiveLoginSpy.mockResolvedValue(null);
 
     const { context } = createContext();
     await func.call(context, { force: false, timeout: 900 });
 
-    expect(setAuthTokenSpy).not.toHaveBeenCalled();
-    getAuthConfigSpy.mockRestore();
+    // With no stored OAuth, login proceeds directly (no clearAuth needed)
+    expect(runInteractiveLoginSpy).toHaveBeenCalled();
   });
 
-  test("already authenticated (env token SENTRY_TOKEN): shows specific var name", async () => {
+  test("already authenticated (env token SENTRY_TOKEN): warns and proceeds to OAuth login", async () => {
     isAuthenticatedSpy.mockReturnValue(true);
     isEnvTokenActiveSpy.mockReturnValue(true);
+    hasStoredAuthCredentialsSpy.mockReturnValue(false);
     // Set env var directly — getActiveEnvVarName() reads env vars via getEnvToken()
     process.env.SENTRY_TOKEN = "sntrys_token_456";
+    runInteractiveLoginSpy.mockResolvedValue(null);
 
     const { context } = createContext();
     await func.call(context, { force: false, timeout: 900 });
 
-    expect(setAuthTokenSpy).not.toHaveBeenCalled();
+    expect(runInteractiveLoginSpy).toHaveBeenCalled();
     delete process.env.SENTRY_TOKEN;
   });
 
@@ -315,14 +317,16 @@ describe("loginCommand.func --token path", () => {
     expect(getStdout()).toContain("Authenticated");
   });
 
-  test("--force with env token: still blocks (env var case unchanged)", async () => {
+  test("--force with env token: proceeds to OAuth login (no longer blocks)", async () => {
     isAuthenticatedSpy.mockReturnValue(true);
     isEnvTokenActiveSpy.mockReturnValue(true);
+    hasStoredAuthCredentialsSpy.mockReturnValue(false);
+    runInteractiveLoginSpy.mockResolvedValue(null);
 
     const { context } = createContext();
     await func.call(context, { force: true, timeout: 900 });
 
-    expect(clearAuthSpy).not.toHaveBeenCalled();
-    expect(runInteractiveLoginSpy).not.toHaveBeenCalled();
+    // Env token no longer blocks — login proceeds
+    expect(runInteractiveLoginSpy).toHaveBeenCalled();
   });
 });