fix(auth): adds localStorage resilience and 401 retry

Author: wgordon17

src/app/components/dashboard/DashboardPage.tsx

@@ -19,7 +19,8 @@ import {
   fetchAllData,
   type DashboardData,
 } from "../../services/poll";
-import { clearAuth, user, onAuthCleared, DASHBOARD_STORAGE_KEY } from "../../stores/auth";
+import { expireToken, user, onAuthCleared, DASHBOARD_STORAGE_KEY } from "../../stores/auth";
+import { pushNotification } from "../../lib/errors";
 import { getClient, getGraphqlRateLimit } from "../../services/github";
 import { formatCount } from "../../lib/format";
 import { setsEqual } from "../../lib/collections";
@@ -191,7 +192,7 @@ async function pollFetch(): Promise<DashboardData> {
         try {
           localStorage.setItem(DASHBOARD_STORAGE_KEY, JSON.stringify(cachePayload));
         } catch {
-          // localStorage full or unavailable — non-fatal
+          pushNotification("localStorage:dashboard", "Dashboard cache write failed — storage may be full", "warning");
         }
       }, 0);
     } else {
@@ -208,9 +209,9 @@ async function pollFetch(): Promise<DashboardData> {
         : null;
 
     if (status === 401) {
-      // Hard redirect (not navigate()) forces a full page reload, which clears
-      // module-level state like _coordinator and dashboardData for the next user.
-      clearAuth();
+      // Token invalid — clear token only, preserve user config/view/dashboard.
+      // Hard redirect forces a full page reload, clearing module-level state.
+      expireToken();
       window.location.replace("/login");
     }
     setDashboardData("loading", false);

src/app/components/onboarding/OnboardingWizard.tsx

@@ -7,6 +7,7 @@ import {
   Match,
 } from "solid-js";
 import { config, updateConfig, CONFIG_STORAGE_KEY } from "../../stores/config";
+import { pushNotification } from "../../lib/errors";
 import { fetchOrgs, type OrgEntry, type RepoRef } from "../../services/api";
 import { getClient } from "../../services/github";
 import RepoSelector from "./RepoSelector";
@@ -67,7 +68,11 @@ export default function OnboardingWizard() {
       onboardingComplete: true,
     });
     // Flush synchronously — the debounced persistence effect won't fire before page unload
-    localStorage.setItem(CONFIG_STORAGE_KEY, JSON.stringify(config));
+    try {
+      localStorage.setItem(CONFIG_STORAGE_KEY, JSON.stringify(config));
+    } catch {
+      pushNotification("localStorage:config", "Config write failed — storage may be full", "warning");
+    }
     window.location.replace("/dashboard");
   }
 

src/app/stores/auth.ts

@@ -2,6 +2,7 @@ import { createSignal } from "solid-js";
 import { clearCache } from "./cache";
 import { CONFIG_STORAGE_KEY, resetConfig, updateConfig, config } from "./config";
 import { VIEW_STORAGE_KEY, resetViewState } from "./view";
+import { pushNotification } from "../lib/errors";
 
 export const AUTH_STORAGE_KEY = "github-tracker:auth-token";
 export const DASHBOARD_STORAGE_KEY = "github-tracker:dashboard";
@@ -40,9 +41,13 @@ export { user };
 // ── Actions ─────────────────────────────────────────────────────────────────
 
 export function setAuth(response: TokenExchangeResponse): void {
-  localStorage.setItem(AUTH_STORAGE_KEY, response.access_token);
+  try {
+    localStorage.setItem(AUTH_STORAGE_KEY, response.access_token);
+  } catch {
+    pushNotification("localStorage:auth", "Auth token write failed — storage may be full. Token exists in memory only this session.", "warning");
+  }
   _setToken(response.access_token);
-  console.info("[auth] access token set (localStorage)");
+  console.info("[auth] access token set");
 }
 
 export function setAuthFromPat(token: string, userData: GitHubUser): void {
@@ -89,37 +94,77 @@ export function clearAuth(): void {
   }
 }
 
+/** Clear only the auth token. Preserves all user data (config, view state, dashboard
+ *  cache) so the same user's preferences and cached data survive re-authentication.
+ *  Used when a token becomes invalid (expired PAT, revoked OAuth) — NOT for explicit
+ *  logout. Full data wipe (cross-user data isolation) is handled by clearAuth()
+ *  which is reserved for explicit user actions (Sign out, Reset all).
+ *
+ *  Callers MUST navigate away after calling this (e.g., window.location.replace or
+ *  router navigate to /login). The poll coordinator is not stopped here — page
+ *  navigation handles teardown. Use clearAuth() if not navigating. */
+export function expireToken(): void {
+  localStorage.removeItem(AUTH_STORAGE_KEY);
+  _setToken(null);
+  setUser(null);
+  console.info("[auth] token expired (user data preserved)");
+}
+
+const VALIDATE_HEADERS = {
+  Accept: "application/vnd.github+json",
+  "X-GitHub-Api-Version": "2022-11-28",
+} as const;
+
 export async function validateToken(): Promise<boolean> {
   const currentToken = _token();
   if (!currentToken) return false;
 
+  const headers = { ...VALIDATE_HEADERS, Authorization: `Bearer ${currentToken}` };
+
+  function handleSuccess(userData: GitHubUser): true {
+    setUser({ login: userData.login, avatar_url: userData.avatar_url, name: userData.name });
+    navigator.storage?.persist?.()?.catch(() => {});
+    return true;
+  }
+
   try {
-    const resp = await fetch("https://api.github.com/user", {
-      headers: {
-        Authorization: `Bearer ${currentToken}`,
-        Accept: "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28",
-      },
-    });
+    const resp = await fetch("https://api.github.com/user", { headers });
 
     if (resp.ok) {
-      const userData = (await resp.json()) as GitHubUser;
-      setUser({
-        login: userData.login,
-        avatar_url: userData.avatar_url,
-        name: userData.name,
-      });
-      return true;
+      return handleSuccess((await resp.json()) as GitHubUser);
     }
 
     if (resp.status === 401) {
-      const method = config.authMethod;
+      // GitHub API can return transient 401s due to database replication lag.
+      // Retry once after a delay before invalidating the token.
+      await new Promise((r) => setTimeout(r, 1000));
+      try {
+        const retry = await fetch("https://api.github.com/user", { headers });
+        if (retry.ok) {
+          return handleSuccess((await retry.json()) as GitHubUser);
+        }
+        if (retry.status !== 401) {
+          // Non-auth error on retry (e.g. 500) — preserve token, try next load
+          return false;
+        }
+      } catch {
+        // Network error on retry — preserve token, try next load
+        return false;
+      }
+
+      // Guard: if the token was replaced during the retry window (e.g., user
+      // re-authenticated via OAuth callback), don't invalidate the new token.
+      if (_token() !== currentToken) {
+        return false;
+      }
+
+      // Both attempts returned 401 — token is genuinely invalid
       console.info(
-        method === "pat"
-          ? "[auth] PAT invalid or expired — clearing auth"
-          : "[auth] access token invalid — clearing auth"
+        config.authMethod === "pat"
+          ? "[auth] PAT invalid or expired — clearing token"
+          : "[auth] access token invalid — clearing token"
       );
-      clearAuth();
+      expireToken();
       return false;
     }
 

src/app/stores/view.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { createStore, produce } from "solid-js/store";
 import { createEffect, onCleanup, untrack } from "solid-js";
+import { pushNotification } from "../lib/errors";
 
 export const VIEW_STORAGE_KEY = "github-tracker:view";
 
@@ -332,7 +333,7 @@ export function initViewPersistence(): void {
       try {
         localStorage.setItem(VIEW_STORAGE_KEY, json);
       } catch {
-        // QuotaExceededError — silently fail rather than kill the reactive graph
+        pushNotification("localStorage:view", "View state write failed — storage may be full", "warning");
       }
     }, 200);
     onCleanup(() => {

tests/components/DashboardPage.test.tsx

@@ -26,6 +26,7 @@ vi.mock("@solidjs/router", () => ({
 const authClearCallbacks: (() => void)[] = [];
 vi.mock("../../src/app/stores/auth", () => ({
   clearAuth: vi.fn(),
+  expireToken: vi.fn(),
   token: () => "fake-token",
   user: () => ({ login: "testuser", avatar_url: "", name: "Test User" }),
   isAuthenticated: () => true,
@@ -127,6 +128,7 @@ beforeEach(async () => {
   capturedFetchAll = null;
   capturedOnHotData = null;
   vi.mocked(authStore.clearAuth).mockClear();
+  vi.mocked(authStore.expireToken).mockClear();
   vi.mocked(pollService.fetchAllData).mockResolvedValue({
     issues: [],
     pullRequests: [],
@@ -296,25 +298,28 @@ describe("DashboardPage — auth error handling", () => {
     consoleErrorSpy.mockRestore();
   });
 
-  it("calls clearAuth and redirects to /login on 401 error (permanent token revoked)", async () => {
+  it("calls expireToken (not clearAuth) and redirects to /login on 401 error", async () => {
     const err401 = Object.assign(new Error("Unauthorized"), { status: 401 });
     vi.mocked(pollService.fetchAllData).mockRejectedValue(err401);
 
     render(() => <DashboardPage />);
     await waitFor(() => {
-      expect(authStore.clearAuth).toHaveBeenCalledOnce();
+      expect(authStore.expireToken).toHaveBeenCalledOnce();
       expect(mockLocationReplace).toHaveBeenCalledWith("/login");
     });
+    // clearAuth should NOT be called — user config/view preserved on token failure
+    expect(authStore.clearAuth).not.toHaveBeenCalled();
   });
 
-  it("does not call clearAuth for non-401 errors", async () => {
+  it("does not call expireToken or clearAuth for non-401 errors", async () => {
     const err500 = Object.assign(new Error("Server Error"), { status: 500 });
     vi.mocked(pollService.fetchAllData).mockRejectedValue(err500);
 
     render(() => <DashboardPage />);
     // Flush all pending microtasks so the rejected promise settles
     await Promise.resolve();
     await Promise.resolve();
+    expect(authStore.expireToken).not.toHaveBeenCalled();
     expect(authStore.clearAuth).not.toHaveBeenCalled();
     expect(mockLocationReplace).not.toHaveBeenCalledWith("/login");
   });