From 56b9481a9114c1c2b4cbcd9231c171d365ae83d0 Mon Sep 17 00:00:00 2001 From: Brian O'Kelley Date: Wed, 30 Sep 2026 21:53:57 +0000 Subject: [PATCH 1/2] fix(auth): recover and clear stale session cookies on page loads Server-rendered pages refreshed WorkOS sessions without sharing the rotation through session_refreshes, so other copies of the cookie (the AdCP bridge copy, in-flight API requests) could no longer refresh. The page then rendered logged out while keeping the dead cookie, and every optional-auth API call from it answered 401. - Resolve page sessions in auth middleware: reuse the session cache, store refreshes, and adopt a session another request rotated. - Clear the cookie only when WorkOS terminally rejects the refresh; provider outages and unknown failures keep it. - On adcontextprotocol.org, bridge once more after clearing so the page picks up the current AgenticAdvertising.org session. - Give optionalAuth the same shared-refresh retry requireAuth has. Co-Authored-By: Claude Opus 5.5 (1M context) --- server/src/http.ts | 103 +++++------- server/src/middleware/auth.ts | 157 +++++++++++++++--- .../unit/cross-domain-session-bridge.test.ts | 40 +++++ server/tests/unit/page-session.test.ts | 150 +++++++++++++++++ 4 files changed, 365 insertions(+), 85 deletions(-) create mode 100644 server/tests/unit/page-session.test.ts diff --git a/server/src/http.ts b/server/src/http.ts index 3e1e9e039e5..41714405151 100644 --- a/server/src/http.ts +++ b/server/src/http.ts @@ -78,7 +78,7 @@ import { resolveUserNameWithFallbacks, sanitizeName } from "./utils/resolve-user import { scrubCommunityAuthorizedAgents } from "./utils/community-adagents.js"; import { formatPerspectiveUrlAsMarkdownDestination, normalizePerspectiveExternalUrl } from "./utils/perspective-url.js"; import { decodeHtmlEntities } from "./utils/html-entities.js"; -import { requireAuth, requireAdmin, requireGlobalAdmin, optionalAuth, invalidateSessionCache, switchSessionOrganization, isDevModeEnabled, getDevUser, getAvailableDevUsers, getDevSessionCookieName, encodeDevSessionCookie, DEV_USERS, type DevUserConfig } from "./middleware/auth.js"; +import { requireAuth, requireAdmin, requireGlobalAdmin, optionalAuth, invalidateSessionCache, resolvePageSession, type PageSession, type PageSessionUser, switchSessionOrganization, isDevModeEnabled, getDevUser, getAvailableDevUsers, getDevSessionCookieName, encodeDevSessionCookie, DEV_USERS, type DevUserConfig } from "./middleware/auth.js"; import { invitationRateLimiter, brandCreationRateLimiter, notificationRateLimiter, emailPrefsRateLimiter, adminContentWriteRateLimiter, newsletterSubscribeRateLimiter, newsletterConfirmRateLimiter, agentCardValidationRateLimiter } from "./middleware/rate-limit.js"; import { findOrCreateUserByEmail } from "./auth/workos-client.js"; import { sendNewsletterConfirmation } from "./notifications/email.js"; @@ -1151,75 +1151,29 @@ function getCsrfScriptVersion(): string { } /** - * Get user info from request for HTML config injection. - * Checks dev mode first, then WorkOS session. - * If session is refreshed, updates the cookie in the response. + * Resolve the page session for HTML config injection. + * Checks dev mode first, then WorkOS session. Refreshed sessions update the + * cookie; a cookie WorkOS definitively rejects is cleared. */ -async function getUserFromRequest( - req: express.Request, - res?: express.Response -): Promise<{ id?: string; email: string; firstName?: string | null; lastName?: string | null } | null> { +async function getPageSession(req: express.Request, res: express.Response): Promise { // Check dev mode first if (isDevModeEnabled()) { const devUser = getDevUser(req); if (devUser) { - return devUser; + return { user: devUser, cleared: false }; } } - // Then check WorkOS session - const sessionCookie = req.cookies?.['wos-session']; - // codeql[js/user-controlled-bypass] - session cookie is verified cryptographically by WorkOS sealed session - if (sessionCookie && AUTH_ENABLED && workos) { - try { - const session = workos.userManagement.loadSealedSession({ - sessionData: sessionCookie, - cookiePassword: WORKOS_COOKIE_PASSWORD, - }); - - // Try to authenticate with the current session - let authResult = await session.authenticate(); - - // If authentication failed (e.g., expired token), try to refresh - if (!authResult.authenticated || !authResult.user) { - try { - const refreshResult = await session.refresh({ - cookiePassword: WORKOS_COOKIE_PASSWORD, - }); - - if (refreshResult.authenticated && refreshResult.sealedSession) { - // Update the cookie with the refreshed session - if (res) { - res.cookie('wos-session', refreshResult.sealedSession, { - httpOnly: true, - secure: process.env.NODE_ENV === 'production', - sameSite: 'lax', - path: '/', - maxAge: 7 * 24 * 60 * 60 * 1000, // 7 days - }); - } - - // Re-authenticate with the new session - const newSession = workos.userManagement.loadSealedSession({ - sessionData: refreshResult.sealedSession, - cookiePassword: WORKOS_COOKIE_PASSWORD, - }); - authResult = await newSession.authenticate(); - } - } catch { - // Refresh failed - continue without user - } - } - - if (authResult.authenticated && authResult.user) { - return authResult.user; - } - } catch { - // Session invalid or expired - continue without user - } - } + if (!AUTH_ENABLED) return { user: null, cleared: false }; + return resolvePageSession(req, res); +} - return null; +/** Get user info from request for HTML config injection. */ +async function getUserFromRequest( + req: express.Request, + res: express.Response +): Promise { + return (await getPageSession(req, res)).user; } function stripLegacyBrandContext(manifest: Record): Record { @@ -1544,7 +1498,9 @@ export class HTTPServer { html = await this.injectHomepageMemberCount(html); // Get user from session (if authenticated), passing res to update cookie if session is refreshed - const user = await getUserFromRequest(req, res); + const session = await getPageSession(req, res); + if (this.rebridgeIfSessionCleared(req, res, session)) return; + const user = session.user; await enrichUserWithMembership(user); await enrichUserWithAdmin(user); @@ -1696,13 +1652,28 @@ export class HTTPServer { if (!req.headers.cookie && !isTopLevelDocumentNavigation) return false; if (this.isAdcpDomain(req) && !req.cookies?.['wos-session'] && !req.cookies?.['bridge-checked']) { - const currentUrl = `https://${req.hostname}${req.originalUrl}`; - res.redirect(`https://agenticadvertising.org/auth/bridge?return_to=${encodeURIComponent(currentUrl)}`); + this.redirectThroughBridge(req, res); return true; } return false; } + // The AdCP cookie is a copy of the AAO session, and either copy can rotate + // the shared refresh token. When WorkOS rejects the AdCP copy, bridge once + // more to pick up the current AAO session. The return marker stops a loop + // when the AAO session is dead too. + private rebridgeIfSessionCleared(req: express.Request, res: express.Response, session: PageSession): boolean { + if (!session.cleared || !this.isAdcpDomain(req)) return false; + if (req.query?.[HTTPServer.BRIDGE_CHECK_PARAM] === '1') return false; + this.redirectThroughBridge(req, res); + return true; + } + + private redirectThroughBridge(req: express.Request, res: express.Response): void { + const currentUrl = `https://${req.hostname}${req.originalUrl}`; + res.redirect(`https://agenticadvertising.org/auth/bridge?return_to=${encodeURIComponent(currentUrl)}`); + } + private async injectHomepageMemberCount(html: string, memberDb = new MemberDatabase()): Promise { if (!html.includes('{{PUBLIC_MEMBER_COUNT_PLUS}}')) { return html; @@ -1733,7 +1704,9 @@ export class HTTPServer { if (this.bridgeIfNeeded(req, res)) return; // Get user from session (if authenticated), passing res to update cookie if session is refreshed - const user = await getUserFromRequest(req, res); + const session = await getPageSession(req, res); + if (this.rebridgeIfSessionCleared(req, res, session)) return; + const user = session.user; await enrichUserWithMembership(user); await enrichUserWithAdmin(user); diff --git a/server/src/middleware/auth.ts b/server/src/middleware/auth.ts index 310870090a3..2535a166985 100644 --- a/server/src/middleware/auth.ts +++ b/server/src/middleware/auth.ts @@ -1197,11 +1197,7 @@ async function requireAuthWithSnapshot( // hasn't written its refreshed session to the DB yet. if (refreshFailed) { try { - let sharedSession = await getRefreshedSession(cacheKey); - if (!sharedSession) { - await new Promise(resolve => setTimeout(resolve, 200)); - sharedSession = await getRefreshedSession(cacheKey); - } + const sharedSession = await findSharedRefreshedSession(cacheKey); if (sharedSession) { logger.info({ path: req.path }, 'Found shared refreshed session from another machine'); @@ -1267,13 +1263,7 @@ async function requireAuthWithSnapshot( // Remove any stale positive cache entry and mark session as dead // so subsequent requests skip the expensive WorkOS refresh + DB fallback - sessionCache.delete(cacheKey); - // LRU eviction: delete oldest entry when at capacity - if (deadSessionCache.size >= DEAD_SESSION_MAX_SIZE) { - const oldest = deadSessionCache.keys().next().value; - if (oldest) deadSessionCache.delete(oldest); - } - deadSessionCache.set(cacheKey, Date.now()); + markSessionDead(cacheKey); if (isHtmlRequest) { return res.redirect(`/auth/login?return_to=${encodeURIComponent(req.originalUrl)}`); } @@ -1982,6 +1972,139 @@ function extractSealedSession(req: Request): string | undefined { return typeof sessionCookie === 'string' && sessionCookie ? sessionCookie : undefined; } +const SHARED_REFRESH_RETRY_MS = 200; + +/** + * Look up a session another request already rotated. That request may not + * have stored its result yet, so wait once before giving up. + */ +async function findSharedRefreshedSession(cacheKey: string): Promise { + const shared = await getRefreshedSession(cacheKey); + if (shared) return shared; + await new Promise(resolve => setTimeout(resolve, SHARED_REFRESH_RETRY_MS)); + return getRefreshedSession(cacheKey); +} + +function markSessionDead(cacheKey: string): void { + sessionCache.delete(cacheKey); + // LRU eviction: delete oldest entry when at capacity + if (deadSessionCache.size >= DEAD_SESSION_MAX_SIZE) { + const oldest = deadSessionCache.keys().next().value; + if (oldest) deadSessionCache.delete(oldest); + } + deadSessionCache.set(cacheKey, Date.now()); +} + +function clearSessionCookie(res: Response): void { + res.clearCookie('wos-session', { + httpOnly: true, + secure: process.env.NODE_ENV === 'production' && !ALLOW_INSECURE_COOKIES, + sameSite: 'lax', + path: '/', + }); +} + +class PageSessionUnavailableError extends Error { + constructor() { + super('Session refresh temporarily unavailable'); + this.name = 'PageSessionUnavailableError'; + } +} + +export interface PageSessionUser { + id: string; + email: string; + firstName?: string | null; + lastName?: string | null; +} + +export interface PageSession { + user: PageSessionUser | null; + /** WorkOS definitively rejected the cookie, and the response now clears it. */ + cleared: boolean; +} + +async function pageSessionUser(sealedSession: string): Promise { + const result = await workos.userManagement.loadSealedSession({ + sessionData: sealedSession, + cookiePassword: WORKOS_COOKIE_PASSWORD, + }).authenticate(); + return result.authenticated && result.user ? result.user : null; +} + +/** Null only for a terminal WorkOS refresh failure; anything else throws. */ +async function refreshPageSession(sealedSession: string): Promise { + const result = await workos.userManagement.loadSealedSession({ + sessionData: sealedSession, + cookiePassword: WORKOS_COOKIE_PASSWORD, + }).refresh({ cookiePassword: WORKOS_COOKIE_PASSWORD }); + if (result.authenticated && result.sealedSession) return result.sealedSession; + if (!result.authenticated && 'retryable' in result && result.retryable === false) return null; + throw new PageSessionUnavailableError(); +} + +async function authenticatePageSession( + sessionCookie: string, cacheKey: string, res: Response, +): Promise { + const user = await pageSessionUser(sessionCookie); + if (user) return user; + + let refreshed = await refreshPageSession(sessionCookie); + if (!refreshed) { + // The refresh token is single-use; another request (or the other domain's + // copy of this cookie) may already have rotated it. + const shared = await findSharedRefreshedSession(cacheKey); + if (!shared) return null; + const sharedUser = await pageSessionUser(shared); + if (sharedUser) { + setSessionCookie(res, shared); + return sharedUser; + } + refreshed = await refreshPageSession(shared); + if (!refreshed) return null; + } + + setSessionCookie(res, refreshed); + // Await so concurrent requests holding the old cookie can find the rotation. + await storeRefreshedSession(cacheKey, refreshed); + return pageSessionUser(refreshed); +} + +/** + * Resolve the browser session for a server-rendered page. Pages never reject: + * an unusable session renders logged out. Refreshes are shared like the API + * middleware's so other copies of the cookie can recover. A cookie WorkOS + * definitively rejects is cleared; otherwise optional-auth API calls from the + * page would answer 401 for as long as the browser keeps it. Provider outages + * and unknown failures keep the cookie. + */ +export async function resolvePageSession(req: Request, res: Response): Promise { + const sessionCookie = req.cookies?.['wos-session']; + // codeql[js/user-controlled-bypass] - session cookie is verified cryptographically by WorkOS sealed session + if (typeof sessionCookie !== 'string' || !sessionCookie) return { user: null, cleared: false }; + + const cacheKey = hashSessionCookie(sessionCookie); + const cached = sessionCache.get(cacheKey); + if (cached && cached.expiresAt > Date.now()) { + if (cached.newSealedSession) setSessionCookie(res, cached.newSealedSession); + // Callers enrich the page user in place; the cached user is frozen. + return { user: { ...cached.user }, cleared: false }; + } + + try { + const user = await authenticatePageSession(sessionCookie, cacheKey, res); + if (user) return { user, cleared: false }; + } catch (error) { + logger.debug({ err: error }, 'Page session unavailable'); + return { user: null, cleared: false }; + } + + logger.debug('Clearing session cookie rejected by WorkOS'); + markSessionDead(cacheKey); + clearSessionCookie(res); + return { user: null, cleared: true }; +} + /** * Optional auth permits anonymous requests only when no credential is supplied. * Invalid presented credentials return 401; verification or authorization @@ -2142,7 +2265,7 @@ export async function optionalAuth(req: Request, res: Response, next: NextFuncti // If refresh failed, check DB for a shared refresh from another machine if (refreshFailed) { try { - const sharedSession = await getRefreshedSession(cacheKey); + const sharedSession = await findSharedRefreshedSession(cacheKey); if (sharedSession) { logger.debug('Found shared refreshed session (optional auth)'); const sharedSessionObj = workos.userManagement.loadSealedSession({ @@ -2190,13 +2313,7 @@ export async function optionalAuth(req: Request, res: Response, next: NextFuncti if (!result.authenticated || !('user' in result) || !result.user) { // All refresh attempts failed — mark session as dead to avoid // expensive retries on every subsequent request - // LRU eviction: delete oldest entry when at capacity - if (deadSessionCache.size >= DEAD_SESSION_MAX_SIZE) { - const oldest = deadSessionCache.keys().next().value; - if (oldest) deadSessionCache.delete(oldest); - } - deadSessionCache.set(cacheKey, Date.now()); - sessionCache.delete(cacheKey); + markSessionDead(cacheKey); return res.status(401).json({ error: 'Invalid session', login_url: '/auth/login' }); } diff --git a/server/tests/unit/cross-domain-session-bridge.test.ts b/server/tests/unit/cross-domain-session-bridge.test.ts index 2b191a50d1a..015fff43ba6 100644 --- a/server/tests/unit/cross-domain-session-bridge.test.ts +++ b/server/tests/unit/cross-domain-session-bridge.test.ts @@ -223,4 +223,44 @@ describe('cross-domain session bridge', () => { expect(bridged).toBe(false); expect(redirect).not.toHaveBeenCalled(); }); + + describe('after the page clears a session WorkOS rejected', () => { + type RebridgeInvoker = { + rebridgeIfSessionCleared(req: express.Request, res: express.Response, session: { user: null; cleared: boolean }): boolean; + }; + + function invokeRebridge({ cleared = true, hostname = 'adcontextprotocol.org', query = {} }: { + cleared?: boolean; hostname?: string; query?: express.Request['query']; + } = {}) { + const server = Object.create(HTTPServer.prototype) as RebridgeInvoker; + const redirect = vi.fn(); + const req = { hostname, originalUrl: '/registry', query } as unknown as express.Request; + const bridged = server.rebridgeIfSessionCleared(req, { redirect } as unknown as express.Response, { user: null, cleared }); + return { bridged, redirect }; + } + + it('bridges once more to pick up the current AAO session', () => { + const { bridged, redirect } = invokeRebridge(); + + expect(bridged).toBe(true); + expect(redirect).toHaveBeenCalledWith( + `https://agenticadvertising.org/auth/bridge?return_to=${encodeURIComponent('https://adcontextprotocol.org/registry')}`, + ); + }); + + it('does not loop when the bridged AAO session is rejected too', () => { + const { bridged, redirect } = invokeRebridge({ query: { _bridge_checked: '1' } }); + expect(bridged).toBe(false); + expect(redirect).not.toHaveBeenCalled(); + }); + + it.each([ + ['a session that was not cleared', { cleared: false }], + ['the AAO hostname', { hostname: 'agenticadvertising.org' }], + ])('does not bridge for %s', (_label, options) => { + const { bridged, redirect } = invokeRebridge(options); + expect(bridged).toBe(false); + expect(redirect).not.toHaveBeenCalled(); + }); + }); }); diff --git a/server/tests/unit/page-session.test.ts b/server/tests/unit/page-session.test.ts new file mode 100644 index 00000000000..fbe68010a1b --- /dev/null +++ b/server/tests/unit/page-session.test.ts @@ -0,0 +1,150 @@ +/** Server-rendered pages share session refreshes and clear cookies WorkOS rejects. */ +import { createHash } from 'node:crypto'; +import express from 'express'; +import supertest from 'supertest'; +import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'; + +const mocks = vi.hoisted(() => ({ + sessions: new Map; refresh: ReturnType }>(), + getRefreshedSession: vi.fn(), storeRefreshedSession: vi.fn(), +})); +vi.hoisted(() => { + process.env.DEV_USER_EMAIL = ''; + process.env.DEV_USER_ID = ''; + process.env.WORKOS_API_KEY ??= 'sk_test'; + process.env.WORKOS_CLIENT_ID ??= 'client_test'; + process.env.WORKOS_COOKIE_PASSWORD ??= 'placeholder-cookie-password-32-bytes-min'; +}); +vi.mock('@workos-inc/node', () => ({ + WorkOS: vi.fn(function WorkOS() { + return { + userManagement: { + loadSealedSession: ({ sessionData }: { sessionData: string }) => { + const session = mocks.sessions.get(sessionData); + if (!session) throw new Error(`unexpected session ${sessionData}`); + return session; + }, + }, + apiKeys: { createValidation: vi.fn() }, + }; + }), +})); +vi.mock('../../src/db/session-refresh-db.js', () => ({ + getRefreshedSession: mocks.getRefreshedSession, + storeRefreshedSession: mocks.storeRefreshedSession, + cleanExpiredRefreshes: vi.fn().mockResolvedValue(0), +})); +import { resolvePageSession, stopAuthTimers } from '../../src/middleware/auth.js'; + +const hash = (value: string) => createHash('sha256').update(value).digest('hex'); +const USER = { id: 'user_01', email: 'ada@acme.example', firstName: 'Ada', lastName: null }; + +function session(name: string, { valid = false, refresh }: { valid?: boolean; refresh?: unknown } = {}) { + const entry = { + authenticate: vi.fn().mockResolvedValue(valid + ? { authenticated: true, user: USER } + : { authenticated: false, reason: 'invalid_jwt' }), + refresh: refresh instanceof Error + ? vi.fn().mockRejectedValue(refresh) + : vi.fn().mockResolvedValue(refresh ?? { authenticated: false, reason: 'invalid_grant', retryable: false }), + }; + mocks.sessions.set(name, entry); + return entry; +} + +function page(cookie?: string) { + const server = express(); + server.use((req, _res, next) => { + req.cookies = cookie === undefined ? {} : { 'wos-session': cookie }; + next(); + }); + server.get('/page', async (req, res) => { + const result = await resolvePageSession(req, res); + res.json({ user: result.user?.id ?? null, cleared: result.cleared }); + }); + return supertest(server).get('/page'); +} + +const sessionCookieHeader = (headers: Record) => + ((headers['set-cookie'] as string[] | undefined) ?? []).filter(c => c.startsWith('wos-session=')); + +beforeEach(() => { + vi.clearAllMocks(); + mocks.sessions.clear(); + mocks.getRefreshedSession.mockResolvedValue(undefined); + mocks.storeRefreshedSession.mockResolvedValue(undefined); +}); +afterAll(() => stopAuthTimers()); + +describe('resolvePageSession', () => { + it('renders anonymously without touching WorkOS when no cookie is sent', async () => { + const response = await page(); + expect(response.body).toEqual({ user: null, cleared: false }); + expect(response.headers['set-cookie']).toBeUndefined(); + }); + + it('returns the user for a valid session without rewriting the cookie', async () => { + session('valid-session', { valid: true }); + const response = await page('valid-session'); + expect(response.body).toEqual({ user: 'user_01', cleared: false }); + expect(sessionCookieHeader(response.headers)).toEqual([]); + }); + + it('shares a refresh so other copies of the cookie can recover the rotated token', async () => { + session('expired-session', { refresh: { authenticated: true, sealedSession: 'rotated-session' } }); + session('rotated-session', { valid: true }); + + const response = await page('expired-session'); + + expect(response.body).toEqual({ user: 'user_01', cleared: false }); + expect(sessionCookieHeader(response.headers)[0]).toMatch(/^wos-session=rotated-session;.*HttpOnly/); + expect(mocks.storeRefreshedSession).toHaveBeenCalledWith(hash('expired-session'), 'rotated-session'); + }); + + it('adopts a session another request rotated, waiting once for it to be stored', async () => { + session('bridged-copy'); + session('rotated-elsewhere', { valid: true }); + mocks.getRefreshedSession.mockResolvedValueOnce(undefined).mockResolvedValueOnce('rotated-elsewhere'); + + const response = await page('bridged-copy'); + + expect(response.body).toEqual({ user: 'user_01', cleared: false }); + expect(mocks.getRefreshedSession).toHaveBeenCalledTimes(2); + expect(mocks.getRefreshedSession).toHaveBeenCalledWith(hash('bridged-copy')); + expect(sessionCookieHeader(response.headers)[0]).toMatch(/^wos-session=rotated-elsewhere;/); + }); + + it.each([ + ['invalid_grant', { authenticated: false, reason: 'invalid_grant', retryable: false }], + ['invalid_session_cookie', { authenticated: false, reason: 'invalid_session_cookie', retryable: false }], + ])('clears a cookie WorkOS rejects with %s', async (_reason, refresh) => { + session('dead-session', { refresh }); + + const response = await page('dead-session'); + + expect(response.body).toEqual({ user: null, cleared: true }); + const [cleared] = sessionCookieHeader(response.headers); + expect(cleared).toMatch(/^wos-session=;/); + expect(cleared).toMatch(/Expires=Thu, 01 Jan 1970/); + expect(cleared).toMatch(/HttpOnly/); + }); + + it('keeps the cookie through a retryable WorkOS failure', async () => { + session('expired-session', { refresh: { authenticated: false, reason: 'server_error', retryable: true } }); + + const response = await page('expired-session'); + + expect(response.body).toEqual({ user: null, cleared: false }); + expect(sessionCookieHeader(response.headers)).toEqual([]); + expect(mocks.getRefreshedSession).not.toHaveBeenCalled(); + }); + + it('keeps the cookie when refresh fails in an unrecognized way', async () => { + session('expired-session', { refresh: new Error('socket hang up') }); + + const response = await page('expired-session'); + + expect(response.body).toEqual({ user: null, cleared: false }); + expect(sessionCookieHeader(response.headers)).toEqual([]); + }); +}); From aa1df782219766eaa832abe5f047469367da0222 Mon Sep 17 00:00:00 2001 From: Brian O'Kelley Date: Wed, 30 Sep 2026 22:08:42 +0000 Subject: [PATCH 2/2] fix(auth): never clear a page cookie on a lost refresh race or lookup outage WorkOS answers a refresh token another request already used with the same terminal invalid_grant as a dead session, and getRefreshedSession reported database failures as "nothing stored". Either could clear a valid cookie on a page load. Wait longer for a concurrent rotation to be stored, and keep the cookie when the lookup itself fails. Co-Authored-By: Claude Opus 5.5 (1M context) --- server/src/db/session-refresh-db.ts | 4 ++++ server/src/middleware/auth.ts | 31 +++++++++++++++++--------- server/tests/unit/page-session.test.ts | 14 +++++++++++- 3 files changed, 38 insertions(+), 11 deletions(-) diff --git a/server/src/db/session-refresh-db.ts b/server/src/db/session-refresh-db.ts index b0379d6c9e7..1f55e1437bd 100644 --- a/server/src/db/session-refresh-db.ts +++ b/server/src/db/session-refresh-db.ts @@ -40,9 +40,12 @@ export async function storeRefreshedSession( /** * Look up a refreshed session by the hash of the old cookie. * Returns the new sealed session if found and not expired, undefined otherwise. + * Lookup failures also return undefined unless `throwOnError` is set, for + * callers that must not mistake an outage for "nothing stored". */ export async function getRefreshedSession( oldCookieHash: string, + { throwOnError = false }: { throwOnError?: boolean } = {}, ): Promise { if (!isDatabaseInitialized()) return undefined; try { @@ -56,6 +59,7 @@ export async function getRefreshedSession( } } catch (err) { logger.warn({ err }, 'Failed to look up refreshed session'); + if (throwOnError) throw err; } return undefined; } diff --git a/server/src/middleware/auth.ts b/server/src/middleware/auth.ts index 2535a166985..959879a2eed 100644 --- a/server/src/middleware/auth.ts +++ b/server/src/middleware/auth.ts @@ -1972,17 +1972,22 @@ function extractSealedSession(req: Request): string | undefined { return typeof sessionCookie === 'string' && sessionCookie ? sessionCookie : undefined; } -const SHARED_REFRESH_RETRY_MS = 200; - /** * Look up a session another request already rotated. That request may not - * have stored its result yet, so wait once before giving up. + * have stored its result yet, so retry after each delay before giving up. */ -async function findSharedRefreshedSession(cacheKey: string): Promise { - const shared = await getRefreshedSession(cacheKey); - if (shared) return shared; - await new Promise(resolve => setTimeout(resolve, SHARED_REFRESH_RETRY_MS)); - return getRefreshedSession(cacheKey); +async function findSharedRefreshedSession( + cacheKey: string, + { retryDelaysMs = [200], throwOnError = false }: { retryDelaysMs?: number[]; throwOnError?: boolean } = {}, +): Promise { + const lookup = () => throwOnError ? getRefreshedSession(cacheKey, { throwOnError }) : getRefreshedSession(cacheKey); + let shared = await lookup(); + for (const delay of retryDelaysMs) { + if (shared) break; + await new Promise(resolve => setTimeout(resolve, delay)); + shared = await lookup(); + } + return shared; } function markSessionDead(cacheKey: string): void { @@ -2052,8 +2057,14 @@ async function authenticatePageSession( let refreshed = await refreshPageSession(sessionCookie); if (!refreshed) { // The refresh token is single-use; another request (or the other domain's - // copy of this cookie) may already have rotated it. - const shared = await findSharedRefreshedSession(cacheKey); + // copy of this cookie) may already have rotated it. WorkOS answers a lost + // race with the same invalid_grant as a dead session, and a null here + // clears the cookie, so wait longer than the API middleware and treat a + // failed lookup as unavailable rather than as "nothing stored". + const shared = await findSharedRefreshedSession(cacheKey, { + retryDelaysMs: [200, 800], + throwOnError: true, + }); if (!shared) return null; const sharedUser = await pageSessionUser(shared); if (sharedUser) { diff --git a/server/tests/unit/page-session.test.ts b/server/tests/unit/page-session.test.ts index fbe68010a1b..b93823f04c8 100644 --- a/server/tests/unit/page-session.test.ts +++ b/server/tests/unit/page-session.test.ts @@ -110,7 +110,7 @@ describe('resolvePageSession', () => { expect(response.body).toEqual({ user: 'user_01', cleared: false }); expect(mocks.getRefreshedSession).toHaveBeenCalledTimes(2); - expect(mocks.getRefreshedSession).toHaveBeenCalledWith(hash('bridged-copy')); + expect(mocks.getRefreshedSession).toHaveBeenCalledWith(hash('bridged-copy'), { throwOnError: true }); expect(sessionCookieHeader(response.headers)[0]).toMatch(/^wos-session=rotated-elsewhere;/); }); @@ -127,6 +127,18 @@ describe('resolvePageSession', () => { expect(cleared).toMatch(/^wos-session=;/); expect(cleared).toMatch(/Expires=Thu, 01 Jan 1970/); expect(cleared).toMatch(/HttpOnly/); + // A lost refresh race also answers invalid_grant, so every retry runs first. + expect(mocks.getRefreshedSession).toHaveBeenCalledTimes(3); + }); + + it('keeps the cookie when the shared refresh lookup fails', async () => { + session('expired-session'); + mocks.getRefreshedSession.mockRejectedValue(new Error('connection terminated')); + + const response = await page('expired-session'); + + expect(response.body).toEqual({ user: null, cleared: false }); + expect(sessionCookieHeader(response.headers)).toEqual([]); }); it('keeps the cookie through a retryable WorkOS failure', async () => {