Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🔓 fix: Prevent 30-Second OpenID Refresh Stalls After a Discarded Prerender (#17174)

Ravi Kumar La7e6cc89f6ff
diff --git a/api/server/controllers/AuthController.js b/api/server/controllers/AuthController.js
index 1238190f15..654d0f0e62 100644
--- a/api/server/controllers/AuthController.js
+++ b/api/server/controllers/AuthController.js
@@ -7,6 +7,7 @@ const {
createResetPasswordController,
createAuthIdentityContext,
createOpenIDRefreshOwnershipError,
+ createOpenIDResponseDelivery,
isOpenIDRefreshOwnershipError,
isOpenIDSessionMissingError,
isOpenIDSessionIdentityMatch,
@@ -46,12 +47,7 @@ const {
refreshOpenIDUser,
sendOpenIDAuthResponse,
} = require('~/server/services/OpenIDRefreshRecovery');
-const {
- assertOpenIDRefreshFlightDeliveryAvailable,
- assertOpenIDRefreshSessionGenerationAvailable,
- claimOpenIDRefreshFlightDelivery,
- releaseOpenIDRefreshFlightDelivery,
-} = require('~/server/services/OpenIDRefreshFlight');
+const OpenIDRefreshFlight = require('~/server/services/OpenIDRefreshFlight');
const AUTH_REFRESH_USER_PROJECTION = '-password -__v -totpSecret -backupCodes -federatedTokens';
/**
@@ -201,88 +197,10 @@ const getReusableOpenIDSessionToken = (openidTokens) => {
return null;
};
-const assertReusableOpenIDSessionGeneration = async (openidTokens) =>
- assertOpenIDRefreshSessionGenerationAvailable({
- key: openidTokens?.publicationFlightKey,
- ownerId: openidTokens?.publicationFlightOwnerId,
- });
-
-/**
- * Serializes response delivery for one durable OpenID publication generation. A logout that
- * reaches the same flight either tombstones it before this claim or waits for the response to
- * finish before returning. The send callback keeps the final authorization check adjacent to the
- * synchronous Express write while allowing callers to do slow preparation under the lease.
- */
-const withOpenIDResponseDelivery = async ({ res, openidTokens, context }, operation) => {
- let delivery;
- let responseSent = false;
- let releaseStarted = false;
- let listenersArmed = false;
- const releaseDelivery = async () => {
- if (!delivery || releaseStarted) {
- return;
- }
- releaseStarted = true;
- for (let attempt = 1; attempt <= 3; attempt++) {
- try {
- await releaseOpenIDRefreshFlightDelivery(delivery);
- return;
- } catch (error) {
- if (attempt === 3) {
- logger.warn(`[${context}] Failed to release OpenID response delivery`, {
- error: error instanceof Error ? error.message : error,
- });
- return;
- }
- await new Promise((resolve) => setTimeout(resolve, 25));
- }
- }
- };
-
- try {
- await assertReusableOpenIDSessionGeneration(openidTokens);
- if (openidTokens?.publicationFlightKey && openidTokens?.publicationFlightOwnerId) {
- const claimed = await claimOpenIDRefreshFlightDelivery({
- key: openidTokens.publicationFlightKey,
- ownerId: openidTokens.publicationFlightOwnerId,
- createdAt: openidTokens.publicationFlightCreatedAt,
- });
- if (!claimed.deliveryId) {
- throw new Error('OpenID response delivery claim returned no owner');
- }
- delivery = {
- key: openidTokens.publicationFlightKey,
- ownerId: openidTokens.publicationFlightOwnerId,
- deliveryId: claimed.deliveryId,
- };
- }
-
- const sendAuthorized = async (send) => {
- if (delivery) {
- await assertOpenIDRefreshFlightDeliveryAvailable(delivery);
- if (!listenersArmed && typeof res.once === 'function') {
- listenersArmed = true;
- res.once('finish', () => void releaseDelivery());
- res.once('close', () => void releaseDelivery());
- }
- } else {
- await assertReusableOpenIDSessionGeneration(openidTokens);
- }
- const response = send();
- responseSent = true;
- if (delivery && typeof res.once !== 'function') {
- await releaseDelivery();
- }
- return response;
- };
-
- return await operation(sendAuthorized);
- } finally {
- if (delivery && !responseSent) {
- await releaseDelivery();
- }
- }
-};
+const withOpenIDResponseDelivery = createOpenIDResponseDelivery({
+ flight: OpenIDRefreshFlight,
+ logger,
+});
const resetPasswordRequestController = async (req, res) => {
try {
diff --git a/api/server/controllers/AuthController.spec.js b/api/server/controllers/AuthController.spec.js
index 62b3307c6f..c64680993a 100644
--- a/api/server/controllers/AuthController.spec.js
+++ b/api/server/controllers/AuthController.spec.js
@@ -126,6 +126,7 @@ jest.mock('@librechat/api', () => ({
TOKEN_RETIREMENT_FIELDS: jest.requireActual('@librechat/api').TOKEN_RETIREMENT_FIELDS,
}));
+const http = require('node:http');
const { createHash } = require('node:crypto');
const openIdClient = require('openid-client');
const jwt = require('jsonwebtoken');
@@ -383,6 +384,80 @@ describe('graphTokenController', () => {
});
});
+ describe('with a Node HTTP response', () => {
+ let server;
+
+ /** Resolves with the server response once the request arrives, optionally after the client disconnects. */
+ const receiveResponse = ({ disconnect }) =>
+ new Promise((resolve) => {
+ const client = http.request({
+ host: '127.0.0.1',
+ port: server.address().port,
+ method: 'POST',
+ });
+ client.on('error', () => {});
+ server.once('request', (_incoming, response) => {
+ response.json = (body) => response.end(JSON.stringify(body));
+ if (!disconnect) {
+ resolve(response);
+ return;
+ }
+ response.once('close', () => resolve(response));
+ client.destroy();
+ });
+ client.end();
+ });
+
+ beforeEach(async () => {
+ req.user.federatedTokens.access_token = 'session-access-token';
+ req.session = {
+ openidTokens: {
+ accessToken: 'session-access-token',
+ appUserId: 'user-1',
+ tenantId: 'tenant-1',
+ publicationFlightKey: 'publication-key',
+ publicationFlightOwnerId: 'publication-owner',
+ publicationFlightCreatedAt: 1000,
+ },
+ };
+ server = http.createServer();
+ await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+ });
+
+ afterEach(async () => {
+ server.closeAllConnections();
+ await new Promise((resolve) => server.close(resolve));
+ });
+
+ it('releases the delivery lease when the client disconnected before delivery', async () => {
+ const response = await receiveResponse({ disconnect: true });
+
+ await graphTokenController(req, response);
+
+ expect(response.closed).toBe(true);
+ expect(releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledWith({
+ key: 'publication-key',
+ ownerId: 'publication-owner',
+ deliveryId: 'delivery-1',
+ });
+ });
+
+ it('holds the delivery lease until an open response finishes', async () => {
+ const response = await receiveResponse({ disconnect: false });
+ const finished = new Promise((resolve) => response.once('finish', resolve));
+
+ await graphTokenController(req, response);
+ await finished;
+
+ expect(releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledTimes(1);
+ expect(releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledWith({
+ key: 'publication-key',
+ ownerId: 'publication-owner',
+ deliveryId: 'delivery-1',
+ });
+ });
+ });
+
it('does not exchange a session-backed Graph token after logout tombstones its generation', async () => {
req.user.federatedTokens.access_token = 'session-access-token';
req.session = {
diff --git a/client/src/hooks/AuthContext.tsx b/client/src/hooks/AuthContext.tsx
index 5974ab1913..7271c2281b 100644
--- a/client/src/hooks/AuthContext.tsx
+++ b/client/src/hooks/AuthContext.tsx
@@ -71,6 +71,9 @@ const endSessionClientState = (): void => {
endPullRequestSession();
void clearTTSCache();
};
+/** `document.prerendering` is not yet part of TypeScript's DOM types. */
+const isPrerendering = (): boolean =>
+ (document as Document & { prerendering?: boolean }).prerendering === true;
/**
* Only recognized codes override the HTTP status used by the login error translation.
*/
@@ -89,6 +92,7 @@ const AuthContextProvider = ({
children: ReactNode;
}) => {
const isExternalRedirectRef = useRef(false);
+ const prerenderRefreshDeferredRef = useRef(false);
const [user, setUser] = useRecoilState(store.user);
const logoutRedirectRef = useRef<string | undefined>(undefined);
const [token, setToken] = useState<string | undefined>(undefined);
@@ -304,6 +308,15 @@ const AuthContextProvider = ({
if (isExternalRedirectRef.current) {
return;
}
+ /** A prerendered page can be discarded without ever being shown. Refreshing from it rotates
+ * the session for a page the user never sees, and the browser aborts the request mid-flight. */
+ if (isPrerendering()) {
+ if (!prerenderRefreshDeferredRef.current) {
+ prerenderRefreshDeferredRef.current = true;
+ document.addEventListener('prerenderingchange', () => silentRefresh(), { once: true });
+ }
+ return;
+ }
refreshToken.mutate(undefined, {
onSuccess: (data: t.TRefreshTokenResponse | undefined) => {
if (isExternalRedirectRef.current) {
diff --git a/client/src/hooks/__tests__/AuthContext.spec.tsx b/client/src/hooks/__tests__/AuthContext.spec.tsx
index 05a02bbd37..039fdd7271 100644
--- a/client/src/hooks/__tests__/AuthContext.spec.tsx
+++ b/client/src/hooks/__tests__/AuthContext.spec.tsx
@@ -821,6 +821,33 @@ describe('AuthContextProvider — optional authentication', () => {
});
});
+describe('AuthContextProvider — prerendered page', () => {
+ const setPrerendering = (value: boolean) =>
+ Object.defineProperty(document, 'prerendering', { configurable: true, value });
+
+ beforeEach(() => {
+ jest.clearAllMocks();
+ setPrerendering(true);
+ });
+
+ afterEach(() => {
+ delete (document as Document & { prerendering?: boolean }).prerendering;
+ });
+
+ it('defers the silent refresh until the prerendered page is shown', () => {
+ renderProviderLive();
+
+ expect(mockRefreshMutate).not.toHaveBeenCalled();
+
+ setPrerendering(false);
+ act(() => {
+ document.dispatchEvent(new Event('prerenderingchange'));
+ });
+
+ expect(mockRefreshMutate).toHaveBeenCalledTimes(1);
+ });
+});
+
describe('AuthContextProvider — silentRefresh subdirectory deployment', () => {
beforeEach(() => {
jest.clearAllMocks();
diff --git a/packages/api/src/auth/openid/delivery.spec.ts b/packages/api/src/auth/openid/delivery.spec.ts
new file mode 100644
index 0000000000..9831d45ef9
--- /dev/null
+++ b/packages/api/src/auth/openid/delivery.spec.ts
@@ -0,0 +1,102 @@
+import { EventEmitter } from 'node:events';
+import type { OpenIDDeliveryResponse } from './delivery';
+import { createOpenIDResponseDelivery } from './delivery';
+
+const tokens = {
+ publicationFlightKey: 'flight-key',
+ publicationFlightOwnerId: 'owner-1',
+ publicationFlightCreatedAt: 1,
+};
+const delivery = { key: 'flight-key', ownerId: 'owner-1', deliveryId: 'delivery-1' };
+
+function createFlight() {
+ return {
+ assertOpenIDRefreshSessionGenerationAvailable: jest.fn().mockResolvedValue(true),
+ claimOpenIDRefreshFlightDelivery: jest.fn().mockResolvedValue({ deliveryId: 'delivery-1' }),
+ assertOpenIDRefreshFlightDeliveryAvailable: jest.fn().mockResolvedValue(undefined),
+ releaseOpenIDRefreshFlightDelivery: jest.fn().mockResolvedValue(undefined),
+ };
+}
+
+function createResponse(closed = false): EventEmitter & OpenIDDeliveryResponse {
+ return Object.assign(new EventEmitter(), { closed });
+}
+
+function setup() {
+ const flight = createFlight();
+ const logger = { warn: jest.fn() };
+ const withDelivery = createOpenIDResponseDelivery({ flight, logger });
+ return { flight, logger, withDelivery };
+}
+
+describe('createOpenIDResponseDelivery', () => {
+ it('releases the lease after the send when the client already disconnected', async () => {
+ const { flight, withDelivery } = setup();
+ const res = createResponse(true);
+
+ const result = await withDelivery({ res, openidTokens: tokens, context: 'test' }, (send) =>
+ send(() => 'sent'),
+ );
+
+ expect(result).toBe('sent');
+ expect(flight.releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledTimes(1);
+ expect(flight.releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledWith(delivery);
+ expect(res.listenerCount('finish')).toBe(0);
+ expect(res.listenerCount('close')).toBe(0);
+ });
+
+ it('releases the lease once when an open response finishes and closes', async () => {
+ const { flight, withDelivery } = setup();
+ const res = createResponse();
+
+ await withDelivery({ res, openidTokens: tokens, context: 'test' }, (send) =>
+ send(() => 'sent'),
+ );
+ expect(flight.releaseOpenIDRefreshFlightDelivery).not.toHaveBeenCalled();
+
+ res.emit('finish');
+ res.emit('close');
+ await new Promise(setImmediate);
+
+ expect(flight.releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledTimes(1);
+ });
+
+ it('releases the lease when the operation fails before sending', async () => {
+ const { flight, withDelivery } = setup();
+
+ await expect(
+ withDelivery({ res: createResponse(), openidTokens: tokens, context: 'test' }, async () => {
+ throw new Error('preparation failed');
+ }),
+ ).rejects.toThrow('preparation failed');
+
+ expect(flight.releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledTimes(1);
+ });
+
+ it('checks the session generation again at send time without a publication flight', async () => {
+ const { flight, withDelivery } = setup();
+
+ await withDelivery({ res: createResponse(), openidTokens: null, context: 'test' }, (send) =>
+ send(() => 'sent'),
+ );
+
+ expect(flight.claimOpenIDRefreshFlightDelivery).not.toHaveBeenCalled();
+ expect(flight.assertOpenIDRefreshSessionGenerationAvailable).toHaveBeenCalledTimes(2);
+ expect(flight.releaseOpenIDRefreshFlightDelivery).not.toHaveBeenCalled();
+ });
+
+ it('warns after the last failed release attempt', async () => {
+ const { flight, logger, withDelivery } = setup();
+ flight.releaseOpenIDRefreshFlightDelivery.mockRejectedValue(new Error('store unavailable'));
+
+ await withDelivery(
+ { res: createResponse(true), openidTokens: tokens, context: 'test' },
+ (send) => send(() => 'sent'),
+ );
+
+ expect(flight.releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledTimes(3);
+ expect(logger.warn).toHaveBeenCalledWith('[test] Failed to release OpenID response delivery', {
+ error: 'store unavailable',
+ });
+ });
+});
diff --git a/packages/api/src/auth/openid/delivery.ts b/packages/api/src/auth/openid/delivery.ts
new file mode 100644
index 0000000000..4924831523
--- /dev/null
+++ b/packages/api/src/auth/openid/delivery.ts
@@ -0,0 +1,128 @@
+import type { OpenIDLogger, SessionOpenIDTokens } from './types';
+import type { OpenIDRefreshFlightService } from './flight';
+
+const RELEASE_ATTEMPTS = 3;
+const RELEASE_RETRY_DELAY_MS = 25;
+
+type DeliveryFlightService = Pick<
+ OpenIDRefreshFlightService,
+ | 'assertOpenIDRefreshSessionGenerationAvailable'
+ | 'claimOpenIDRefreshFlightDelivery'
+ | 'assertOpenIDRefreshFlightDeliveryAvailable'
+ | 'releaseOpenIDRefreshFlightDelivery'
+>;
+
+/** The parts of an Express response that delivery tracking reads. */
+export interface OpenIDDeliveryResponse {
+ closed?: boolean;
+ once?: (event: 'finish' | 'close', listener: () => void) => unknown;
+}
+
+type DeliveryTokens = Pick<
+ SessionOpenIDTokens,
+ 'publicationFlightKey' | 'publicationFlightOwnerId' | 'publicationFlightCreatedAt'
+>;
+
+export interface OpenIDResponseDeliveryInput {
+ res: OpenIDDeliveryResponse;
+ openidTokens?: DeliveryTokens | null;
+ context: string;
+}
+
+/** Runs the final authorization check, then the synchronous write, under the delivery lease. */
+export type SendAuthorized = <T>(send: () => T) => Promise<T>;
+
+export interface OpenIDResponseDeliveryDeps {
+ flight: DeliveryFlightService;
+ logger: Pick<OpenIDLogger, 'warn'>;
+}
+
+/**
+ * Serializes response delivery for one durable OpenID publication generation. A logout that
+ * reaches the same flight either tombstones it before this claim or waits for the response to
+ * finish before returning. The send callback keeps the final authorization check adjacent to the
+ * synchronous Express write while allowing callers to do slow preparation under the lease.
+ * A response whose client already disconnected never emits `finish` or `close` again, so its
+ * lease is released directly after the send instead of through response listeners.
+ */
+export function createOpenIDResponseDelivery({ flight, logger }: OpenIDResponseDeliveryDeps) {
+ const assertReusableSessionGeneration = (openidTokens?: DeliveryTokens | null) =>
+ flight.assertOpenIDRefreshSessionGenerationAvailable({
+ key: openidTokens?.publicationFlightKey,
+ ownerId: openidTokens?.publicationFlightOwnerId,
+ });
+
+ return async function withOpenIDResponseDelivery<T>(
+ { res, openidTokens, context }: OpenIDResponseDeliveryInput,
+ operation: (sendAuthorized: SendAuthorized) => Promise<T>,
+ ): Promise<T> {
+ let delivery: { key: string; ownerId: string; deliveryId: string } | undefined;
+ let responseSent = false;
+ let releaseStarted = false;
+ let listenersArmed = false;
+ const releaseDelivery = async () => {
+ if (!delivery || releaseStarted) {
+ return;
+ }
+ releaseStarted = true;
+ for (let attempt = 1; attempt <= RELEASE_ATTEMPTS; attempt++) {
+ try {
+ await flight.releaseOpenIDRefreshFlightDelivery(delivery);
+ return;
+ } catch (error) {
+ if (attempt === RELEASE_ATTEMPTS) {
+ logger.warn(`[${context}] Failed to release OpenID response delivery`, {
+ error: error instanceof Error ? error.message : error,
+ });
+ return;
+ }
+ await new Promise((resolve) => setTimeout(resolve, RELEASE_RETRY_DELAY_MS));
+ }
+ }
+ };
+
+ try {
+ await assertReusableSessionGeneration(openidTokens);
+ if (openidTokens?.publicationFlightKey && openidTokens?.publicationFlightOwnerId) {
+ const claimed = await flight.claimOpenIDRefreshFlightDelivery({
+ key: openidTokens.publicationFlightKey,
+ ownerId: openidTokens.publicationFlightOwnerId,
+ createdAt: openidTokens.publicationFlightCreatedAt,
+ });
+ if (!claimed.deliveryId) {
+ throw new Error('OpenID response delivery claim returned no owner');
+ }
+ delivery = {
+ key: openidTokens.publicationFlightKey,
+ ownerId: openidTokens.publicationFlightOwnerId,
+ deliveryId: claimed.deliveryId,
+ };
+ }
+
+ const sendAuthorized: SendAuthorized = async (send) => {
+ if (delivery) {
+ await flight.assertOpenIDRefreshFlightDeliveryAvailable(delivery);
+ if (!listenersArmed && typeof res.once === 'function' && !res.closed) {
+ listenersArmed = true;
+ res.once('finish', () => void releaseDelivery());
+ res.once('close', () => void releaseDelivery());
+ }
+ } else {
+ await assertReusableSessionGeneration(openidTokens);
+ }
+ const response = send();
+ responseSent = true;
+ if (delivery && !listenersArmed) {
+ await releaseDelivery();
+ }
+ return response;
+ };
+
+ return await operation(sendAuthorized);
+ } finally {
+ if (delivery && !responseSent) {
+ await releaseDelivery();
+ }
+ }
+ };
+}
diff --git a/packages/api/src/auth/openid/index.ts b/packages/api/src/auth/openid/index.ts
index f231be88d0..cd31077cb2 100644
--- a/packages/api/src/auth/openid/index.ts
+++ b/packages/api/src/auth/openid/index.ts
@@ -1,5 +1,6 @@
export * from './errors';
export * from './flight';
+export * from './delivery';
export * from './bridge';
export * from './recovery';
export * from './session';