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

🔑 feat: Refresh-Capable Google Admin OAuth Sessions (#13832)

Dustin Healy6d2f29266cec
diff --git a/api/server/controllers/auth/oauth.js b/api/server/controllers/auth/oauth.js
index cd6a88ac67..b50fc65a47 100644
--- a/api/server/controllers/auth/oauth.js
+++ b/api/server/controllers/auth/oauth.js
@@ -43,11 +43,15 @@ function createOAuthHandler(redirectUri = domains.client) {
const sessionExpiry = Number(process.env.SESSION_EXPIRY) || DEFAULT_SESSION_EXPIRY;
const token = await generateToken(req.user, sessionExpiry);
- /** Get refresh token from tokenset for OpenID users */
- const refreshToken =
- req.user.provider === 'openid' && isEnabled(process.env.OPENID_REUSE_TOKENS) === true
- ? req.user.tokenset?.refresh_token || req.user.federatedTokens?.refresh_token
- : undefined;
+ let refreshToken;
+ if (req.user.provider === 'openid') {
+ if (isEnabled(process.env.OPENID_REUSE_TOKENS) === true) {
+ refreshToken =
+ req.user.tokenset?.refresh_token || req.user.federatedTokens?.refresh_token;
+ }
+ } else if (req.user.provider === 'google') {
+ refreshToken = req.authInfo?.refreshToken;
+ }
const expiresAt = Date.now() + sessionExpiry;
const callbackUrl = new URL(redirectUri);
diff --git a/api/server/controllers/auth/oauth.spec.js b/api/server/controllers/auth/oauth.spec.js
index 4a20442d4f..d9984a8dd5 100644
--- a/api/server/controllers/auth/oauth.spec.js
+++ b/api/server/controllers/auth/oauth.spec.js
@@ -148,4 +148,69 @@ describe('createOAuthHandler', () => {
expect(mockSetAuthTokens).not.toHaveBeenCalled();
expect(next).not.toHaveBeenCalled();
});
+
+ it('forwards the refresh token from req.authInfo for non-openid admin providers', async () => {
+ const handler = createOAuthHandler('http://admin.example.com/auth/google/callback');
+ const req = buildReq({
+ user: { _id: 'user-9', email: '[email protected]', provider: 'google' },
+ authInfo: { refreshToken: 'google-refresh-token' },
+ });
+ const res = buildRes();
+ const next = jest.fn();
+
+ await handler(req, res, next);
+
+ expect(mockGenerateAdminExchangeCode).toHaveBeenCalledWith(
+ {},
+ req.user,
+ 'jwt-token',
+ 'google-refresh-token',
+ 'http://admin.example.com',
+ 'pkce-challenge',
+ expect.any(Number),
+ );
+ });
+
+ it('omits the refresh token when a non-openid admin login has no authInfo', async () => {
+ const handler = createOAuthHandler('http://admin.example.com/auth/google/callback');
+ const req = buildReq({
+ user: { _id: 'user-9', email: '[email protected]', provider: 'google' },
+ });
+ const res = buildRes();
+ const next = jest.fn();
+
+ await handler(req, res, next);
+
+ expect(mockGenerateAdminExchangeCode).toHaveBeenCalledWith(
+ {},
+ req.user,
+ 'jwt-token',
+ undefined,
+ 'http://admin.example.com',
+ 'pkce-challenge',
+ expect.any(Number),
+ );
+ });
+
+ it('does not forward refresh tokens for admin providers other than google or openid', async () => {
+ const handler = createOAuthHandler('http://admin.example.com/auth/discord/callback');
+ const req = buildReq({
+ user: { _id: 'user-9', email: '[email protected]', provider: 'discord' },
+ authInfo: { refreshToken: 'discord-refresh-token' },
+ });
+ const res = buildRes();
+ const next = jest.fn();
+
+ await handler(req, res, next);
+
+ expect(mockGenerateAdminExchangeCode).toHaveBeenCalledWith(
+ {},
+ req.user,
+ 'jwt-token',
+ undefined,
+ 'http://admin.example.com',
+ 'pkce-challenge',
+ expect.any(Number),
+ );
+ });
});
diff --git a/api/server/routes/admin/auth.js b/api/server/routes/admin/auth.js
index 29e9c8102f..fbc53c0907 100644
--- a/api/server/routes/admin/auth.js
+++ b/api/server/routes/admin/auth.js
@@ -8,6 +8,7 @@ const {
DEFAULT_SESSION_EXPIRY,
SystemCapabilities,
getTenantId,
+ tenantStorage,
} = require('@librechat/data-schemas');
const {
isEnabled,
@@ -18,8 +19,10 @@ const {
tenantContextMiddleware,
preAuthTenantMiddleware,
applyAdminRefresh,
+ applyGoogleAdminRefresh,
AdminRefreshError,
buildOpenIDRefreshParams,
+ isEmailDomainAllowed,
} = require('@librechat/api');
const { loginController } = require('~/server/controllers/auth/LoginController');
const { hasCapability, requireCapability } = require('~/server/middleware/roles/capabilities');
@@ -101,6 +104,55 @@ function resolveRequestOrigin(req) {
}
}
+async function isEmailAllowedForUser(user) {
+ if (!user?.email) return false;
+ try {
+ const userId = user.id ?? user._id?.toString();
+ const appConfig = user.tenantId
+ ? await tenantStorage.run({ tenantId: user.tenantId }, () =>
+ getAppConfig({ role: user.role ?? '', userId, tenantId: user.tenantId }),
+ )
+ : await getAppConfig({ role: user.role ?? '', userId });
+ return isEmailDomainAllowed(user.email, appConfig?.registration?.allowedDomains);
+ } catch (err) {
+ logger.warn(`[admin/oauth/refresh] domain allowlist check failed, denying: ${err?.message}`);
+ return false;
+ }
+}
+
+function buildAdminRefreshClosures(sessionExpiry) {
+ return {
+ canAccessAdmin: async (user) => {
+ try {
+ return await hasCapability(
+ {
+ id: user.id ?? user._id?.toString(),
+ role: user.role ?? '',
+ tenantId: user.tenantId,
+ },
+ SystemCapabilities.ACCESS_ADMIN,
+ );
+ } catch (err) {
+ logger.warn(`[admin/oauth/refresh] capability check failed, denying: ${err?.message}`);
+ return false;
+ }
+ },
+ isEmailAllowed: isEmailAllowedForUser,
+ mintToken: async (user) => ({
+ token: await generateToken(user, sessionExpiry),
+ expiresAt: Date.now() + sessionExpiry,
+ }),
+ };
+}
+
+function buildGoogleAdminRefreshDeps(sessionExpiry) {
+ return {
+ findUsers,
+ getUserById,
+ ...buildAdminRefreshClosures(sessionExpiry),
+ };
+}
+
router.post(
'/login/local',
middleware.logHeaders,
@@ -275,6 +327,8 @@ router.get(
scope: ['openid', 'profile', 'email'],
session: false,
state,
+ accessType: 'offline',
+ prompt: 'consent',
})(req, res, next);
},
);
@@ -548,30 +602,37 @@ router.post('/oauth/exchange', middleware.loginLimiter, async (req, res) => {
* `/api/admin/oauth/exchange`.
*
* POST /api/admin/oauth/refresh
- * Body: { refresh_token: string, user_id?: string }
+ * Body: { refresh_token: string, user_id?: string, provider?: 'openid' | 'google' }
* Response: { token: string, refreshToken?: string, user: object, expiresAt: number }
*
* Errors (all responses are `{ error: string, error_code: string }`):
* 400 MISSING_REFRESH_TOKEN — refresh_token absent or empty
+ * 400 INVALID_PROVIDER — provider value not one of 'openid' | 'google'
* 401 REFRESH_FAILED — IdP rejected the refresh grant
* 401 USER_NOT_FOUND — no LibreChat user matches the refreshed sub
- * 401 USER_ID_MISMATCH — supplied user_id resolves to a user with a different openidId
+ * 401 USER_ID_MISMATCH — supplied user_id resolves to a different provider id
* 401 ISSUER_MISMATCH — refreshed tokenset was issued by an unexpected issuer
* 401 TENANT_MISMATCH — resolved user belongs to a different tenant than the request
* 403 FORBIDDEN — resolved user no longer holds ACCESS_ADMIN
- * 403 TOKEN_REUSE_DISABLED — OPENID_REUSE_TOKENS is not enabled on the server
- * 502 IDP_INCOMPLETE — IdP returned a tokenset missing access_token
+ * 403 TOKEN_REUSE_DISABLED — OPENID_REUSE_TOKENS is not enabled (openid provider only)
+ * 502 IDP_INCOMPLETE — IdP returned a tokenset missing access_token / id_token
* 502 CLAIMS_INCOMPLETE — IdP tokenset has no readable claims or no sub
* 503 OPENID_NOT_CONFIGURED — OpenID is not configured on this server
+ * 503 GOOGLE_NOT_CONFIGURED — Google admin OAuth is not configured on this server
* 500 INTERNAL_ERROR — anything else (logged server-side)
*/
router.post(
'/oauth/refresh',
middleware.loginLimiter,
+ middleware.checkBan,
preAuthTenantMiddleware,
async (req, res) => {
try {
- const { refresh_token: refreshToken, user_id: userId } = req.body ?? {};
+ const {
+ refresh_token: refreshToken,
+ user_id: userId,
+ provider: rawProvider,
+ } = req.body ?? {};
if (typeof refreshToken !== 'string' || refreshToken.length === 0) {
return res.status(400).json({
error: 'Missing refresh_token',
@@ -579,6 +640,40 @@ router.post(
});
}
+ const provider =
+ typeof rawProvider === 'string' && rawProvider.length > 0 ? rawProvider : 'openid';
+ if (provider !== 'openid' && provider !== 'google') {
+ return res.status(400).json({
+ error: 'Unsupported provider',
+ error_code: 'INVALID_PROVIDER',
+ });
+ }
+
+ const sessionExpiry = Number(process.env.SESSION_EXPIRY) || DEFAULT_SESSION_EXPIRY;
+ const normalizedUserId = typeof userId === 'string' && userId.length > 0 ? userId : undefined;
+ const tenantId = getTenantId();
+
+ if (provider === 'google') {
+ try {
+ const result = await applyGoogleAdminRefresh(buildGoogleAdminRefreshDeps(sessionExpiry), {
+ refreshToken,
+ userId: normalizedUserId,
+ tenantId,
+ clientId: process.env.GOOGLE_CLIENT_ID,
+ clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+ });
+ req.user = { id: result.user._id };
+ await middleware.checkBan(req, res, () => {});
+ if (req.banned || res.headersSent) return;
+ return res.json(result);
+ } catch (err) {
+ if (err instanceof AdminRefreshError) {
+ return res.status(err.status).json({ error: err.message, error_code: err.code });
+ }
+ throw err;
+ }
+ }
+
if (!isEnabled(process.env.OPENID_REUSE_TOKENS)) {
return res.status(403).json({
error: 'OpenID token reuse is not enabled',
@@ -621,7 +716,6 @@ router.post(
});
}
- const sessionExpiry = Number(process.env.SESSION_EXPIRY) || DEFAULT_SESSION_EXPIRY;
const expectedIssuer = openIdConfig.serverMetadata?.()?.issuer;
try {
@@ -630,35 +724,18 @@ router.post(
{
findUsers,
getUserById,
- canAccessAdmin: async (user) => {
- try {
- return await hasCapability(
- {
- id: user.id ?? user._id?.toString(),
- role: user.role ?? '',
- tenantId: user.tenantId,
- },
- SystemCapabilities.ACCESS_ADMIN,
- );
- } catch (err) {
- logger.warn(
- `[admin/oauth/refresh] capability check failed, denying: ${err?.message}`,
- );
- return false;
- }
- },
- mintToken: async (user) => ({
- token: await generateToken(user, sessionExpiry),
- expiresAt: Date.now() + sessionExpiry,
- }),
+ ...buildAdminRefreshClosures(sessionExpiry),
},
{
- userId: typeof userId === 'string' && userId.length > 0 ? userId : undefined,
+ userId: normalizedUserId,
previousRefreshToken: refreshToken,
expectedIssuer,
- tenantId: getTenantId(),
+ tenantId,
},
);
+ req.user = { id: result.user._id };
+ await middleware.checkBan(req, res, () => {});
+ if (req.banned || res.headersSent) return;
return res.json(result);
} catch (err) {
if (err instanceof AdminRefreshError) {
diff --git a/api/server/routes/admin/auth.refresh.test.js b/api/server/routes/admin/auth.refresh.test.js
index 3e2ce1cff7..3539c2d285 100644
--- a/api/server/routes/admin/auth.refresh.test.js
+++ b/api/server/routes/admin/auth.refresh.test.js
@@ -23,6 +23,7 @@ jest.mock('@librechat/data-schemas', () => ({
DEFAULT_SESSION_EXPIRY: 60000,
SystemCapabilities: { ACCESS_ADMIN: 'ACCESS_ADMIN' },
getTenantId: jest.fn(() => undefined),
+ tenantStorage: { run: jest.fn((ctx, fn) => fn()) },
}));
jest.mock('@librechat/api', () => {
@@ -44,6 +45,7 @@ jest.mock('@librechat/api', () => {
tenantContextMiddleware: jest.fn((req, res, next) => next()),
preAuthTenantMiddleware: jest.fn((req, res, next) => next()),
applyAdminRefresh: jest.fn(),
+ applyGoogleAdminRefresh: jest.fn(),
AdminRefreshError,
buildOpenIDRefreshParams: jest.fn(() => {
const params = {};
@@ -110,6 +112,7 @@ const { logger } = require('@librechat/data-schemas');
const {
isEnabled,
applyAdminRefresh,
+ applyGoogleAdminRefresh,
storeAndStripChallenge,
buildOpenIDRefreshParams,
} = require('@librechat/api');
@@ -121,11 +124,328 @@ const ORIGINAL_OPENID_SCOPE = process.env.OPENID_SCOPE;
const ORIGINAL_OPENID_REFRESH_AUDIENCE = process.env.OPENID_REFRESH_AUDIENCE;
const ORIGINAL_SESSION_EXPIRY = process.env.SESSION_EXPIRY;
+describe('admin auth OpenID refresh route', () => {
+ const openIdConfig = {
+ serverMetadata: jest.fn(() => ({ issuer: 'https://issuer.example.com' })),
+ };
+ const tokenset = {
+ access_token: 'new-admin-access',
+ id_token: 'new-admin-id',
+ refresh_token: 'new-admin-refresh',
+ expires_in: 3600,
+ claims: jest.fn(() => ({ sub: 'admin-openid-id' })),
+ };
+
+ let app;
+
+ beforeEach(() => {
+ jest.clearAllMocks();
+ delete process.env.OPENID_SCOPE;
+ delete process.env.OPENID_REFRESH_AUDIENCE;
+ delete process.env.SESSION_EXPIRY;
+
+ app = express();
+ app.use(express.json());
+ app.use('/api/admin', adminAuthRouter);
+
+ isEnabled.mockReturnValue(true);
+ getOpenIdConfig.mockReturnValue(openIdConfig);
+ openIdClient.refreshTokenGrant.mockResolvedValue(tokenset);
+ applyAdminRefresh.mockResolvedValue({
+ token: 'admin-jwt',
+ refreshToken: 'new-admin-refresh',
+ user: { id: 'user-id', email: '[email protected]' },
+ expiresAt: 1234567890,
+ });
+ });
+
+ afterAll(() => {
+ if (ORIGINAL_OPENID_SCOPE === undefined) {
+ delete process.env.OPENID_SCOPE;
+ } else {
+ process.env.OPENID_SCOPE = ORIGINAL_OPENID_SCOPE;
+ }
+
+ if (ORIGINAL_OPENID_REFRESH_AUDIENCE === undefined) {
+ delete process.env.OPENID_REFRESH_AUDIENCE;
+ } else {
+ process.env.OPENID_REFRESH_AUDIENCE = ORIGINAL_OPENID_REFRESH_AUDIENCE;
+ }
+
+ if (ORIGINAL_SESSION_EXPIRY === undefined) {
+ delete process.env.SESSION_EXPIRY;
+ } else {
+ process.env.SESSION_EXPIRY = ORIGINAL_SESSION_EXPIRY;
+ }
+ });
+
+ it.each([
+ ['scope-only', { OPENID_SCOPE: 'openid profile email' }, { scope: 'openid profile email' }],
+ [
+ 'scope and audience',
+ {
+ OPENID_SCOPE: 'openid profile email',
+ OPENID_REFRESH_AUDIENCE: 'https://api.example.com',
+ },
+ { scope: 'openid profile email', audience: 'https://api.example.com' },
+ ],
+ [
+ 'audience-only',
+ { OPENID_REFRESH_AUDIENCE: 'https://api.example.com' },
+ { audience: 'https://api.example.com' },
+ ],
+ ['empty audience', { OPENID_REFRESH_AUDIENCE: '' }, {}],
+ ])('passes %s params to the OpenID refresh grant', async (_label, env, expectedParams) => {
+ Object.assign(process.env, env);
+
+ const response = await request(app)
+ .post('/api/admin/oauth/refresh')
+ .send({ refresh_token: 'incoming-refresh-token' });
+
+ expect(response.status).toBe(200);
+ expect(buildOpenIDRefreshParams).toHaveBeenCalledTimes(1);
+ expect(openIdClient.refreshTokenGrant).toHaveBeenCalledWith(
+ openIdConfig,
+ 'incoming-refresh-token',
+ expectedParams,
+ );
+ expect(applyAdminRefresh).toHaveBeenCalledWith(
+ tokenset,
+ expect.any(Object),
+ expect.objectContaining({ previousRefreshToken: 'incoming-refresh-token' }),
+ );
+ });
+
+ it('returns the existing refresh failure response when the IdP rejects the grant', async () => {
+ openIdClient.refreshTokenGrant.mockRejectedValue({
+ code: 'invalid_grant',
+ name: 'OAuthError',
+ });
+
+ const response = await request(app)
+ .post('/api/admin/oauth/refresh')
+ .send({ refresh_token: 'incoming-refresh-token' });
+
+ expect(response.status).toBe(401);
+ expect(response.body).toEqual({
+ error: 'Refresh failed',
+ error_code: 'REFRESH_FAILED',
+ });
+ expect(applyAdminRefresh).not.toHaveBeenCalled();
+ });
+
+ it('keeps admin refresh diagnostics free of token and audience values', async () => {
+ process.env.OPENID_SCOPE = 'openid profile email';
+ process.env.OPENID_REFRESH_AUDIENCE = 'https://api.example.com';
+
+ await request(app)
+ .post('/api/admin/oauth/refresh')
+ .send({ refresh_token: 'incoming-refresh-token' });
+
+ expect(logger.debug).toHaveBeenCalledWith('[admin/oauth/refresh] OpenID refresh params', {
+ has_scope: true,
+ has_refresh_audience: true,
+ });
+ expect(logger.debug).toHaveBeenCalledWith('[admin/oauth/refresh] OpenID refresh succeeded', {
+ has_access_token: true,
+ has_id_token: true,
+ has_refresh_token: true,
+ expires_in: 3600,
+ });
+ const debugOutput = JSON.stringify(logger.debug.mock.calls);
+ expect(debugOutput).not.toContain('incoming-refresh-token');
+ expect(debugOutput).not.toContain('new-admin-access');
+ expect(debugOutput).not.toContain('new-admin-id');
+ expect(debugOutput).not.toContain('new-admin-refresh');
+ expect(debugOutput).not.toContain('https://api.example.com');
+ });
+});
+
+describe('admin auth Google refresh route', () => {
+ let app;
+
+ beforeEach(() => {
+ jest.clearAllMocks();
+ delete process.env.SESSION_EXPIRY;
+
+ app = express();
+ app.use(express.json());
+ app.use('/api/admin', adminAuthRouter);
+
+ process.env.GOOGLE_CLIENT_ID = 'google-client-id';
+ process.env.GOOGLE_CLIENT_SECRET = 'google-client-secret';
+
+ applyGoogleAdminRefresh.mockResolvedValue({
+ token: 'admin-jwt',
+ refreshToken: 'rotated-refresh',
+ user: {
+ _id: 'user-id',
+ id: 'user-id',
+ email: '[email protected]',
+ name: 'Admin',
+ username: 'admin',
+ role: 'ADMIN',
+ provider: 'google',
+ },
+ expiresAt: 1234567890,
+ });
+ });
+
+ it('delegates to applyGoogleAdminRefresh with route-supplied deps and options', async () => {
+ const response = await request(app).post('/api/admin/oauth/refresh').send({
+ refresh_token: 'incoming-google-refresh',
+ user_id: '6a343eb8b5025a84b6ca2767',
+ provider: 'google',
+ });
+
+ expect(response.status).toBe(200);
+ expect(response.body).toEqual({
+ token: 'admin-jwt',
+ refreshToken: 'rotated-refresh',
+ user: expect.objectContaining({
+ _id: 'user-id',
+ id: 'user-id',
+ email: '[email protected]',
+ name: 'Admin',
+ username: 'admin',
+ role: 'ADMIN',
+ provider: 'google',
+ }),
+ expiresAt: 1234567890,
+ });
+ expect(applyGoogleAdminRefresh).toHaveBeenCalledWith(
+ expect.objectContaining({
+ findUsers: expect.any(Function),
+ getUserById: expect.any(Function),
+ canAccessAdmin: expect.any(Function),
+ mintToken: expect.any(Function),
+ }),
+ {
+ refreshToken: 'incoming-google-refresh',
+ userId: '6a343eb8b5025a84b6ca2767',
+ tenantId: undefined,
+ clientId: 'google-client-id',
+ clientSecret: 'google-client-secret',
+ },
+ );
+ });
+
+ it('forwards the tenant id from getTenantId() to the helper', async () => {
+ const { getTenantId } = require('@librechat/data-schemas');
+ getTenantId.mockReturnValueOnce('tenant-x');
+
+ const response = await request(app)
+ .post('/api/admin/oauth/refresh')
+ .send({ refresh_token: 'incoming-google-refresh', provider: 'google' });
+
+ expect(response.status).toBe(200);
+ expect(applyGoogleAdminRefresh).toHaveBeenCalledWith(
+ expect.any(Object),
+ expect.objectContaining({ tenantId: 'tenant-x' }),
+ );
+ });
+
+ it('canAccessAdmin closure calls hasCapability with the normalized user id', async () => {
+ const { hasCapability } = require('~/server/middleware/roles/capabilities');
+ let capturedDeps;
+ applyGoogleAdminRefresh.mockImplementationOnce(async (deps) => {
+ capturedDeps = deps;
+ return {
+ token: 'jwt',
+ refreshToken: 'r',
+ user: { id: 'u', _id: 'u', email: '[email protected]', name: '', username: '', role: 'ADMIN' },
+ expiresAt: 0,
+ };
+ });
+
+ await request(app)
+ .post('/api/admin/oauth/refresh')
+ .send({ refresh_token: 'google-refresh', provider: 'google' });
+
+ await capturedDeps.canAccessAdmin({ id: 'user-1', role: 'ADMIN', tenantId: 'tenant-a' });
+ expect(hasCapability).toHaveBeenCalledWith(
+ { id: 'user-1', role: 'ADMIN', tenantId: 'tenant-a' },
+ 'ACCESS_ADMIN',
+ );
+ });
+
+ it('does not require OPENID_REUSE_TOKENS for the google provider', async () => {
+ isEnabled.mockReturnValue(false);
+
+ const response = await request(app)
+ .post('/api/admin/oauth/refresh')
+ .send({ refresh_token: 'incoming-google-refresh', provider: 'google' });
+
+ expect(response.status).toBe(200);
+ });
+
+ it('maps AdminRefreshError thrown by the helper to the documented status and code', async () => {
+ const { AdminRefreshError } = require('@librechat/api');
+ applyGoogleAdminRefresh.mockRejectedValueOnce(
+ new AdminRefreshError('GOOGLE_NOT_CONFIGURED', 503, 'Google admin OAuth is not configured'),
+ );
+
+ const response = await request(app)
+ .post('/api/admin/oauth/refresh')
+ .send({ refresh_token: 'incoming-google-refresh', provider: 'google' });
+
+ expect(response.status).toBe(503);
+ expect(response.body).toEqual({
+ error: 'Google admin OAuth is not configured',
+ error_code: 'GOOGLE_NOT_CONFIGURED',
+ });
+ });
+
+ it('returns 500 INTERNAL_ERROR when the helper throws a non-AdminRefreshError', async () => {
+ applyGoogleAdminRefresh.mockRejectedValueOnce(new Error('boom'));
+
+ const response = await request(app)
+ .post('/api/admin/oauth/refresh')
+ .send({ refresh_token: 'incoming-google-refresh', provider: 'google' });
+
+ expect(response.status).toBe(500);
+ expect(response.body.error_code).toBe('INTERNAL_ERROR');
+ });
+
+ it('rejects unknown provider values with INVALID_PROVIDER before calling either helper', async () => {
+ const response = await request(app)
+ .post('/api/admin/oauth/refresh')
+ .send({ refresh_token: 'incoming-refresh', provider: 'github' });
+
+ expect(response.status).toBe(400);
+ expect(response.body.error_code).toBe('INVALID_PROVIDER');
+ expect(applyGoogleAdminRefresh).not.toHaveBeenCalled();
+ expect(applyAdminRefresh).not.toHaveBeenCalled();
+ });
+
+ it('re-runs checkBan with the resolved user identity and blocks a banned user', async () => {
+ const middleware = require('~/server/middleware');
+ let banCheckCalls = 0;
+ middleware.checkBan.mockImplementation((req, res, next) => {
+ banCheckCalls++;
+ if (banCheckCalls >= 2 && req.user) {
+ req.banned = true;
+ return res.status(403).json({ message: 'banned' });
+ }
+ return next();
+ });
+
+ const response = await request(app)
+ .post('/api/admin/oauth/refresh')
+ .send({ refresh_token: 'incoming-google-refresh', provider: 'google' });
+
+ expect(response.status).toBe(403);
+ expect(middleware.checkBan).toHaveBeenCalledTimes(2);
+ expect(middleware.checkBan.mock.calls[1][0].user).toEqual({ id: 'user-id' });
+ });
+});
+
describe('admin auth OpenID route availability', () => {
let app;
beforeEach(() => {
jest.clearAllMocks();
+ middleware.checkBan.mockImplementation((req, res, next) => next());
app = express();
app.use(express.json());
@@ -261,143 +581,6 @@ describe('admin auth social route availability', () => {
});
});
-describe('admin auth OpenID refresh route', () => {
- const openIdConfig = {
- serverMetadata: jest.fn(() => ({ issuer: 'https://issuer.example.com' })),
- };
- const tokenset = {
- access_token: 'new-admin-access',
- id_token: 'new-admin-id',
- refresh_token: 'new-admin-refresh',
- expires_in: 3600,
- claims: jest.fn(() => ({ sub: 'admin-openid-id' })),
- };
-
- let app;
-
- beforeEach(() => {
- jest.clearAllMocks();
- delete process.env.OPENID_SCOPE;
- delete process.env.OPENID_REFRESH_AUDIENCE;
- delete process.env.SESSION_EXPIRY;
-
- app = express();
- app.use(express.json());
- app.use('/api/admin', adminAuthRouter);
-
- isEnabled.mockReturnValue(true);
- getOpenIdConfig.mockReturnValue(openIdConfig);
- openIdClient.refreshTokenGrant.mockResolvedValue(tokenset);
- applyAdminRefresh.mockResolvedValue({
- token: 'admin-jwt',
- refreshToken: 'new-admin-refresh',
- user: { id: 'user-id', email: '[email protected]' },
- expiresAt: 1234567890,
- });
- });
-
- afterAll(() => {
- if (ORIGINAL_OPENID_SCOPE === undefined) {
- delete process.env.OPENID_SCOPE;
- } else {
- process.env.OPENID_SCOPE = ORIGINAL_OPENID_SCOPE;
- }
-
- if (ORIGINAL_OPENID_REFRESH_AUDIENCE === undefined) {
- delete process.env.OPENID_REFRESH_AUDIENCE;
- } else {
- process.env.OPENID_REFRESH_AUDIENCE = ORIGINAL_OPENID_REFRESH_AUDIENCE;
- }
-
- if (ORIGINAL_SESSION_EXPIRY === undefined) {
- delete process.env.SESSION_EXPIRY;
- } else {
- process.env.SESSION_EXPIRY = ORIGINAL_SESSION_EXPIRY;
- }
- });
-
- it.each([
- ['scope-only', { OPENID_SCOPE: 'openid profile email' }, { scope: 'openid profile email' }],
- [
- 'scope and audience',
- {
- OPENID_SCOPE: 'openid profile email',
- OPENID_REFRESH_AUDIENCE: 'https://api.example.com',
- },
- { scope: 'openid profile email', audience: 'https://api.example.com' },
- ],
- [
- 'audience-only',
- { OPENID_REFRESH_AUDIENCE: 'https://api.example.com' },
- { audience: 'https://api.example.com' },
- ],
- ['empty audience', { OPENID_REFRESH_AUDIENCE: '' }, {}],
- ])('passes %s params to the OpenID refresh grant', async (_label, env, expectedParams) => {
- Object.assign(process.env, env);
-
- const response = await request(app)
- .post('/api/admin/oauth/refresh')
- .send({ refresh_token: 'incoming-refresh-token' });
-
- expect(response.status).toBe(200);
- expect(buildOpenIDRefreshParams).toHaveBeenCalledTimes(1);
- expect(openIdClient.refreshTokenGrant).toHaveBeenCalledWith(
- openIdConfig,
- 'incoming-refresh-token',
- expectedParams,
- );
- expect(applyAdminRefresh).toHaveBeenCalledWith(
- tokenset,
- expect.any(Object),
- expect.objectContaining({ previousRefreshToken: 'incoming-refresh-token' }),
- );
- });
-
- it('returns the existing refresh failure response when the IdP rejects the grant', async () => {
- openIdClient.refreshTokenGrant.mockRejectedValue({
- code: 'invalid_grant',
- name: 'OAuthError',
- });
-
- const response = await request(app)
- .post('/api/admin/oauth/refresh')
- .send({ refresh_token: 'incoming-refresh-token' });
-
- expect(response.status).toBe(401);
- expect(response.body).toEqual({
- error: 'Refresh failed',
- error_code: 'REFRESH_FAILED',
- });
- expect(applyAdminRefresh).not.toHaveBeenCalled();
- });
-
- it('keeps admin refresh diagnostics free of token and audience values', async () => {
- process.env.OPENID_SCOPE = 'openid profile email';
- process.env.OPENID_REFRESH_AUDIENCE = 'https://api.example.com';
-
- await request(app)
- .post('/api/admin/oauth/refresh')
- .send({ refresh_token: 'incoming-refresh-token' });
-
- expect(logger.debug).toHaveBeenCalledWith('[admin/oauth/refresh] OpenID refresh params', {
- has_scope: true,
- has_refresh_audience: true,
- });
- expect(logger.debug).toHaveBeenCalledWith('[admin/oauth/refresh] OpenID refresh succeeded', {
- has_access_token: true,
- has_id_token: true,
- has_refresh_token: true,
- expires_in: 3600,
- });
- const debugOutput = JSON.stringify(logger.debug.mock.calls);
- expect(debugOutput).not.toContain('incoming-refresh-token');
- expect(debugOutput).not.toContain('new-admin-access');
- expect(debugOutput).not.toContain('new-admin-id');
- expect(debugOutput).not.toContain('new-admin-refresh');
- expect(debugOutput).not.toContain('https://api.example.com');
- });
-});
-
describe('admin local login route', () => {
let app;
diff --git a/api/strategies/appleStrategy.test.js b/api/strategies/appleStrategy.test.js
index d142d27eac..703a5ff0a4 100644
--- a/api/strategies/appleStrategy.test.js
+++ b/api/strategies/appleStrategy.test.js
@@ -32,6 +32,7 @@ jest.mock('@librechat/api', () => ({
}));
jest.mock('~/models', () => ({
findUser: jest.fn(),
+ updateUser: jest.fn(),
}));
jest.mock('~/server/services/Config', () => ({
getAppConfig: jest.fn().mockResolvedValue({
diff --git a/api/strategies/socialLogin.js b/api/strategies/socialLogin.js
index 580e4f3d7e..da751d0c1c 100644
--- a/api/strategies/socialLogin.js
+++ b/api/strategies/socialLogin.js
@@ -3,7 +3,7 @@ const { ErrorTypes } = require('librechat-data-provider');
const { isEnabled, isEmailDomainAllowed, resolveAppConfigForUser } = require('@librechat/api');
const { createSocialUser, handleExistingUser } = require('./process');
const { getAppConfig } = require('~/server/services/Config');
-const { findUser } = require('~/models');
+const { findUser, updateUser } = require('~/models');
const socialLogin =
(provider, getProfileDetails, options = {}) =>
@@ -55,9 +55,46 @@ const socialLogin =
return cb(error);
}
+ const passResult = (user) =>
+ refreshToken && provider === 'google' ? cb(null, user, { refreshToken }) : cb(null, user);
+
if (existingUser?.provider === provider) {
+ if (
+ options.existingUsersOnly &&
+ id &&
+ existingUser[providerKey] &&
+ existingUser[providerKey] !== id
+ ) {
+ logger.warn(
+ `[${provider}Login] Rejected admin email fallback for ${email}: stored ${providerKey} does not match`,
+ );
+ const error = new Error(ErrorTypes.AUTH_FAILED);
+ error.code = ErrorTypes.AUTH_FAILED;
+ return cb(error);
+ }
+ if (options.existingUsersOnly && id && !existingUser[providerKey]) {
+ if (existingUser.tenantId) {
+ logger.warn(
+ `[${provider}Login] Admin migrate blocked for tenanted user ${email}: no tenant scope in OAuth callback`,
+ );
+ const tenantError = new Error(ErrorTypes.AUTH_FAILED);
+ tenantError.code = ErrorTypes.AUTH_FAILED;
+ return cb(tenantError);
+ }
+ await updateUser(existingUser._id, { [providerKey]: id });
+ const verified = await findUser({ _id: existingUser._id, [providerKey]: id });
+ if (!verified) {
+ logger.warn(
+ `[${provider}Login] Admin migrate superseded by concurrent write, denying: ${email}`,
+ );
+ const concurrentError = new Error(ErrorTypes.AUTH_FAILED);
+ concurrentError.code = ErrorTypes.AUTH_FAILED;
+ return cb(concurrentError);
+ }
+ existingUser[providerKey] = id;
+ }
await handleExistingUser(existingUser, avatarUrl, appConfig, email);
- return cb(null, existingUser);
+ return passResult(existingUser);
} else if (existingUser) {
logger.info(
`[${provider}Login] User ${email} already exists with provider ${existingUser.provider}`,
@@ -97,7 +134,7 @@ const socialLogin =
emailVerified,
appConfig,
});
- return cb(null, newUser);
+ return passResult(newUser);
} catch (err) {
logger.error(`[${provider}Login]`, err);
return cb(err);
diff --git a/api/strategies/socialLogin.test.js b/api/strategies/socialLogin.test.js
index 4fde397d55..01b8c6f210 100644
--- a/api/strategies/socialLogin.test.js
+++ b/api/strategies/socialLogin.test.js
@@ -35,6 +35,7 @@ jest.mock('@librechat/api', () => ({
jest.mock('~/models', () => ({
findUser: jest.fn(),
+ updateUser: jest.fn(),
}));
jest.mock('~/server/services/Config', () => ({
@@ -176,6 +177,140 @@ describe('socialLogin', () => {
expect(callback).toHaveBeenCalledWith(null, existingUser);
});
+ it('does not migrate the provider id on the chat path (only admin path migrates)', async () => {
+ const { updateUser } = require('~/models');
+ const provider = 'google';
+ const googleId = 'google-user-chat';
+ const email = '[email protected]';
+
+ const existingUser = {
+ _id: 'chatUser',
+ email: email,
+ provider: 'google',
+ };
+
+ findUser.mockResolvedValueOnce(null).mockResolvedValueOnce(existingUser);
+
+ const mockProfile = {
+ id: googleId,
+ emails: [{ value: email, verified: true }],
+ photos: [{ value: 'https://example.com/avatar.png' }],
+ name: { givenName: 'Chat', familyName: 'User' },
+ };
+
+ const loginFn = socialLogin(provider, mockGetProfileDetails);
+ const callback = jest.fn();
+
+ await loginFn(null, null, null, mockProfile, callback);
+
+ expect(updateUser).not.toHaveBeenCalled();
+ expect(handleExistingUser).toHaveBeenCalled();
+ expect(callback).toHaveBeenCalledWith(null, existingUser);
+ });
+
+ it('migrates the missing provider id when finding by email fallback (admin path)', async () => {
+ const { updateUser } = require('~/models');
+ const provider = 'google';
+ const googleId = 'google-user-789';
+ const email = '[email protected]';
+
+ const existingUser = {
+ _id: 'admin789',
+ email: email,
+ provider: 'google',
+ };
+
+ findUser.mockResolvedValueOnce(null).mockResolvedValueOnce(existingUser);
+
+ const mockProfile = {
+ id: googleId,
+ emails: [{ value: email, verified: true }],
+ photos: [{ value: 'https://example.com/avatar.png' }],
+ name: { givenName: 'Admin', familyName: 'User' },
+ };
+
+ const loginFn = socialLogin(provider, mockGetProfileDetails, { existingUsersOnly: true });
+ const callback = jest.fn();
+
+ await loginFn(null, null, null, mockProfile, callback);
+
+ expect(updateUser).toHaveBeenCalledWith('admin789', { googleId });
+ expect(existingUser.googleId).toBe(googleId);
+ expect(handleExistingUser).toHaveBeenCalled();
+ expect(callback).toHaveBeenCalledWith(null, existingUser);
+ });
+
+ it('blocks migration via email fallback for a tenanted user (no tenant scope in OAuth callback)', async () => {
+ const { updateUser } = require('~/models');
+ const provider = 'google';
+ const googleId = 'google-user-cross';
+ const email = '[email protected]';
+
+ const tenantedUser = {
+ _id: 'tenant-b-user',
+ email: email,
+ provider: 'google',
+ tenantId: 'tenant-b',
+ };
+
+ findUser.mockResolvedValueOnce(null).mockResolvedValueOnce(tenantedUser);
+
+ const mockProfile = {
+ id: googleId,
+ emails: [{ value: email, verified: true }],
+ photos: [{ value: 'https://example.com/avatar.png' }],
+ name: { givenName: 'Admin', familyName: 'User' },
+ };
+
+ const loginFn = socialLogin(provider, mockGetProfileDetails, { existingUsersOnly: true });
+ const callback = jest.fn();
+
+ await loginFn(null, null, null, mockProfile, callback);
+
+ expect(updateUser).not.toHaveBeenCalled();
+ expect(callback).toHaveBeenCalledWith(
+ expect.objectContaining({ code: ErrorTypes.AUTH_FAILED }),
+ );
+ expect(logger.warn).toHaveBeenCalledWith(
+ expect.stringContaining('Admin migrate blocked for tenanted user'),
+ );
+ });
+
+ it('rejects the admin email fallback when stored provider id differs from the current sub', async () => {
+ const provider = 'google';
+ const googleId = 'google-user-new';
+ const email = '[email protected]';
+
+ const existingUser = {
+ _id: 'admin789',
+ email: email,
+ provider: 'google',
+ googleId: 'google-user-old',
+ };
+
+ findUser.mockResolvedValueOnce(null).mockResolvedValueOnce(existingUser);
+
+ const mockProfile = {
+ id: googleId,
+ emails: [{ value: email, verified: true }],
+ photos: [{ value: 'https://example.com/avatar.png' }],
+ name: { givenName: 'Admin', familyName: 'User' },
+ };
+
+ const loginFn = socialLogin(provider, mockGetProfileDetails, { existingUsersOnly: true });
+ const callback = jest.fn();
+
+ await loginFn(null, null, null, mockProfile, callback);
+
+ expect(logger.warn).toHaveBeenCalledWith(
+ `[${provider}Login] Rejected admin email fallback for ${email}: stored ${provider}Id does not match`,
+ );
+ expect(handleExistingUser).not.toHaveBeenCalled();
+ expect(callback).toHaveBeenCalledWith(
+ expect.objectContaining({ code: ErrorTypes.AUTH_FAILED }),
+ );
+ });
+
it('should create new user if not found by provider ID or email', async () => {
const provider = 'google';
const googleId = 'google-new-user';
@@ -358,5 +493,67 @@ describe('socialLogin', () => {
expect.objectContaining({ message: 'Email domain not allowed' }),
);
});
+
+ it('does not forward the refresh token as authInfo for non-google providers', async () => {
+ const provider = 'github';
+ const githubId = 'gh-user-123';
+ const email = '[email protected]';
+
+ const existingUser = {
+ _id: 'ghUser',
+ email,
+ provider: 'github',
+ githubId,
+ };
+
+ findUser.mockResolvedValue(existingUser);
+
+ const mockProfile = {
+ id: githubId,
+ emails: [{ value: email, verified: true }],
+ photos: [{ value: 'https://example.com/avatar.png' }],
+ name: { givenName: 'GitHub', familyName: 'User' },
+ };
+
+ const loginFn = socialLogin(provider, mockGetProfileDetails);
+ const callback = jest.fn();
+
+ await loginFn(null, 'github-refresh-token', null, mockProfile, callback);
+
+ expect(callback).toHaveBeenCalledWith(null, existingUser);
+ expect(callback).not.toHaveBeenCalledWith(null, existingUser, expect.anything());
+ });
+
+ it('passes the IdP refresh token through as authInfo when present', async () => {
+ const provider = 'google';
+ const googleId = 'google-with-refresh';
+ const email = '[email protected]';
+
+ const existingUser = {
+ _id: 'userRefresh',
+ email,
+ provider: 'google',
+ googleId,
+ role: 'ADMIN',
+ };
+
+ findUser.mockResolvedValue(existingUser);
+
+ const mockProfile = {
+ id: googleId,
+ emails: [{ value: email, verified: true }],
+ photos: [{ value: 'https://example.com/avatar.png' }],
+ name: { givenName: 'Admin', familyName: 'User' },
+ };
+
+ const loginFn = socialLogin(provider, mockGetProfileDetails);
+ const callback = jest.fn();
+
+ await loginFn(null, 'idp-refresh-token', null, mockProfile, callback);
+
+ expect(callback).toHaveBeenCalledWith(null, existingUser, {
+ refreshToken: 'idp-refresh-token',
+ });
+ });
});
});
diff --git a/packages/api/src/auth/exchange.ts b/packages/api/src/auth/exchange.ts
index 424ac20313..bf7fa163d6 100644
--- a/packages/api/src/auth/exchange.ts
+++ b/packages/api/src/auth/exchange.ts
@@ -50,6 +50,12 @@ export interface AdminExchangeData {
*/
export interface AdminExchangeResponse {
token: string;
+ /**
+ * When Google rotates the refresh token on use, this will differ from the
+ * token the client originally sent. Clients MUST persist this value; failing
+ * to do so causes future refresh calls to fail once Google's original grant
+ * expires or is revoked.
+ */
refreshToken?: string;
user: AdminExchangeUser;
expiresAt?: number;
diff --git a/packages/api/src/auth/googleRefresh.spec.ts b/packages/api/src/auth/googleRefresh.spec.ts
new file mode 100644
index 0000000000..2356e91b1f
--- /dev/null
+++ b/packages/api/src/auth/googleRefresh.spec.ts
@@ -0,0 +1,343 @@
+import { Types } from 'mongoose';
+
+import type { IUser } from '@librechat/data-schemas';
+import type { GoogleAdminRefreshDeps, GoogleAdminRefreshOptions } from './googleRefresh';
+
+import { applyGoogleAdminRefresh } from './googleRefresh';
+import { AdminRefreshError } from './refresh';
+
+jest.mock('@librechat/data-schemas', () => ({
+ ...jest.requireActual('@librechat/data-schemas'),
+ logger: {
+ debug: jest.fn(),
+ error: jest.fn(),
+ info: jest.fn(),
+ warn: jest.fn(),
+ },
+}));
+
+const SUB = 'google-admin-sub';
+
+function makeUser(overrides: Partial<IUser> = {}): IUser {
+ const _id = overrides._id ?? new Types.ObjectId();
+ return {
+ _id,
+ email: '[email protected]',
+ name: 'Admin User',
+ username: 'admin',
+ role: 'ADMIN',
+ provider: 'google',
+ googleId: SUB,
+ avatar: 'https://example.com/avatar.png',
+ ...overrides,
+ } as IUser;
+}
+
+function makeIdToken(claims: Record<string, unknown> = { sub: SUB }): string {
+ const header = Buffer.from(JSON.stringify({ alg: 'RS256' })).toString('base64url');
+ const payload = Buffer.from(JSON.stringify(claims)).toString('base64url');
+ return `${header}.${payload}.signature`;
+}
+
+function makeOkJson(body: unknown): Response {
+ return new Response(JSON.stringify(body), {
+ status: 200,
+ headers: { 'Content-Type': 'application/json' },
+ });
+}
+
+function makeStatus(status: number, body: unknown = {}): Response {
+ return new Response(JSON.stringify(body), {
+ status,
+ headers: { 'Content-Type': 'application/json' },
+ });
+}
+
+const baseOptions: GoogleAdminRefreshOptions = {
+ refreshToken: 'incoming-refresh',
+ clientId: 'google-client-id',
+ clientSecret: 'google-client-secret',
+};
+
+describe('applyGoogleAdminRefresh', () => {
+ let deps: jest.Mocked<GoogleAdminRefreshDeps>;
+ let fetchMock: jest.Mock;
+ let originalFetch: typeof fetch;
+
+ beforeEach(() => {
+ jest.clearAllMocks();
+ deps = {
+ findUsers: jest.fn(),
+ getUserById: jest.fn(),
+ canAccessAdmin: jest.fn(),
+ isEmailAllowed: jest.fn().mockResolvedValue(true),
+ mintToken: jest.fn(),
+ };
+ originalFetch = global.fetch;
+ fetchMock = jest.fn();
+ global.fetch = fetchMock as unknown as typeof fetch;
+ });
+
+ afterEach(() => {
+ global.fetch = originalFetch;
+ });
+
+ it('refreshes a Google admin session and returns the exchange-shaped response', async () => {
+ const user = makeUser();
+ fetchMock.mockResolvedValueOnce(
+ makeOkJson({ access_token: 'new-access', id_token: makeIdToken() }),
+ );
+ deps.findUsers.mockResolvedValue([user]);
+ deps.canAccessAdmin.mockResolvedValue(true);
+ deps.mintToken.mockResolvedValue({ token: 'minted-jwt', expiresAt: 1700000000000 });
+
+ const result = await applyGoogleAdminRefresh(deps, baseOptions);
+
+ expect(result).toEqual({
+ token: 'minted-jwt',
+ refreshToken: 'incoming-refresh',
+ user: expect.objectContaining({
+ id: String(user._id),
+ _id: String(user._id),
+ email: '[email protected]',
+ provider: 'google',
+ username: 'admin',
+ role: 'ADMIN',
+ }),
+ expiresAt: 1700000000000,
+ });
+ const [url, init] = fetchMock.mock.calls[0];
+ expect(url).toBe('https://oauth2.googleapis.com/token');
+ const body = (init as { body: URLSearchParams }).body.toString();
+ expect(body).toContain('client_id=google-client-id');
+ expect(body).toContain('grant_type=refresh_token');
+ expect(body).toContain('refresh_token=incoming-refresh');
+ });
+
+ it('throws GOOGLE_NOT_CONFIGURED when credentials are missing', async () => {
+ await expect(
+ applyGoogleAdminRefresh(deps, {
+ ...baseOptions,
+ clientId: undefined,
+ clientSecret: undefined,
+ }),
+ ).rejects.toMatchObject({ code: 'GOOGLE_NOT_CONFIGURED', status: 503 });
+ expect(fetchMock).not.toHaveBeenCalled();
+ });
+
+ it('throws REFRESH_FAILED when Google rejects the grant', async () => {
+ fetchMock.mockResolvedValueOnce(makeStatus(401));
+ await expect(applyGoogleAdminRefresh(deps, baseOptions)).rejects.toMatchObject({
+ code: 'REFRESH_FAILED',
+ status: 401,
+ });
+ });
+
+ it('throws IDP_INCOMPLETE when Google returns a non-JSON body', async () => {
+ fetchMock.mockResolvedValueOnce(
+ new Response('not json', { status: 200, headers: { 'Content-Type': 'text/plain' } }),
+ );
+ await expect(applyGoogleAdminRefresh(deps, baseOptions)).rejects.toMatchObject({
+ code: 'IDP_INCOMPLETE',
+ status: 502,
+ });
+ });
+
+ it('throws IDP_INCOMPLETE when the tokenset is missing access_token', async () => {
+ fetchMock.mockResolvedValueOnce(makeOkJson({ id_token: makeIdToken() }));
+ await expect(applyGoogleAdminRefresh(deps, baseOptions)).rejects.toMatchObject({
+ code: 'IDP_INCOMPLETE',
+ status: 502,
+ });
+ });
+
+ it('throws ISSUER_MISMATCH when the id_token aud does not match the configured clientId', async () => {
+ fetchMock.mockResolvedValueOnce(
+ makeOkJson({
+ access_token: 'new-access',
+ id_token: makeIdToken({ sub: SUB, aud: 'wrong-client' }),
+ }),
+ );
+
+ await expect(applyGoogleAdminRefresh(deps, baseOptions)).rejects.toMatchObject({
+ code: 'ISSUER_MISMATCH',
+ status: 401,
+ });
+ expect(deps.findUsers).not.toHaveBeenCalled();
+ });
+
+ it('falls back to the userinfo endpoint when id_token is absent', async () => {
+ const user = makeUser();
+ fetchMock
+ .mockResolvedValueOnce(makeOkJson({ access_token: 'new-access' }))
+ .mockResolvedValueOnce(makeOkJson({ sub: SUB }));
+ deps.findUsers.mockResolvedValue([user]);
+ deps.canAccessAdmin.mockResolvedValue(true);
+ deps.mintToken.mockResolvedValue({ token: 'minted-jwt', expiresAt: 1 });
+
+ const result = await applyGoogleAdminRefresh(deps, baseOptions);
+
+ expect(fetchMock.mock.calls[1][0]).toBe('https://openidconnect.googleapis.com/v1/userinfo');
+ expect(result.user.id).toBe(String(user._id));
+ });
+
+ it('throws CLAIMS_INCOMPLETE when neither id_token nor userinfo yields a sub', async () => {
+ fetchMock
+ .mockResolvedValueOnce(makeOkJson({ access_token: 'new-access' }))
+ .mockResolvedValueOnce(makeStatus(401));
+
+ await expect(applyGoogleAdminRefresh(deps, baseOptions)).rejects.toMatchObject({
+ code: 'CLAIMS_INCOMPLETE',
+ status: 502,
+ });
+ });
+
+ it('throws USER_ID_MISMATCH when user_id resolves to a different googleId', async () => {
+ fetchMock.mockResolvedValueOnce(
+ makeOkJson({ access_token: 'new-access', id_token: makeIdToken() }),
+ );
+ const direct = makeUser({ googleId: 'other-google-id' });
+ deps.getUserById.mockResolvedValue(direct);
+
+ await expect(
+ applyGoogleAdminRefresh(deps, { ...baseOptions, userId: String(direct._id) }),
+ ).rejects.toMatchObject({ code: 'USER_ID_MISMATCH', status: 401 });
+ });
+
+ it('ignores malformed user_id values that are not valid ObjectIds', async () => {
+ const user = makeUser();
+ fetchMock.mockResolvedValueOnce(
+ makeOkJson({ access_token: 'new-access', id_token: makeIdToken() }),
+ );
+ deps.findUsers.mockResolvedValue([user]);
+ deps.canAccessAdmin.mockResolvedValue(true);
+ deps.mintToken.mockResolvedValue({ token: 'minted-jwt', expiresAt: 1 });
+
+ const result = await applyGoogleAdminRefresh(deps, {
+ ...baseOptions,
+ userId: 'not-an-objectid',
+ });
+
+ expect(deps.getUserById).not.toHaveBeenCalled();
+ expect(result.token).toBe('minted-jwt');
+ });
+
+ it('throws TENANT_MISMATCH when the resolved direct user belongs to another tenant', async () => {
+ fetchMock.mockResolvedValueOnce(
+ makeOkJson({ access_token: 'new-access', id_token: makeIdToken() }),
+ );
+ const direct = makeUser({ tenantId: 'tenant-a' });
+ deps.getUserById.mockResolvedValue(direct);
+
+ await expect(
+ applyGoogleAdminRefresh(deps, {
+ ...baseOptions,
+ userId: String(direct._id),
+ tenantId: 'tenant-b',
+ }),
+ ).rejects.toMatchObject({ code: 'TENANT_MISMATCH', status: 401 });
+ });
+
+ it('throws USER_ID_MISMATCH when multiple users share the same googleId', async () => {
+ fetchMock.mockResolvedValueOnce(
+ makeOkJson({ access_token: 'new-access', id_token: makeIdToken() }),
+ );
+ deps.findUsers.mockResolvedValue([makeUser(), makeUser({ email: '[email protected]' })]);
+
+ await expect(applyGoogleAdminRefresh(deps, baseOptions)).rejects.toMatchObject({
+ code: 'USER_ID_MISMATCH',
+ status: 401,
+ });
+ });
+
+ it('throws PROVIDER_MISMATCH when the resolved user is not bound to the google provider (findUsers path)', async () => {
+ fetchMock.mockResolvedValueOnce(
+ makeOkJson({ access_token: 'new-access', id_token: makeIdToken() }),
+ );
+ deps.findUsers.mockResolvedValue([makeUser({ provider: 'openid' })]);
+
+ await expect(applyGoogleAdminRefresh(deps, baseOptions)).rejects.toMatchObject({
+ code: 'PROVIDER_MISMATCH',
+ status: 401,
+ });
+ expect(deps.canAccessAdmin).not.toHaveBeenCalled();
+ });
+
+ it('throws PROVIDER_MISMATCH when the direct-lookup user is not bound to the google provider', async () => {
+ fetchMock.mockResolvedValueOnce(
+ makeOkJson({ access_token: 'new-access', id_token: makeIdToken() }),
+ );
+ const direct = makeUser({ provider: 'openid' });
+ deps.getUserById.mockResolvedValue(direct);
+
+ await expect(
+ applyGoogleAdminRefresh(deps, { ...baseOptions, userId: String(direct._id) }),
+ ).rejects.toMatchObject({ code: 'PROVIDER_MISMATCH', status: 401 });
+ expect(deps.canAccessAdmin).not.toHaveBeenCalled();
+ });
+
+ it('throws USER_NOT_FOUND when no admin user matches the refreshed googleId', async () => {
+ fetchMock.mockResolvedValueOnce(
+ makeOkJson({ access_token: 'new-access', id_token: makeIdToken() }),
+ );
+ deps.findUsers.mockResolvedValue([]);
+
+ await expect(applyGoogleAdminRefresh(deps, baseOptions)).rejects.toMatchObject({
+ code: 'USER_NOT_FOUND',
+ status: 401,
+ });
+ });
+
+ it('throws FORBIDDEN when the resolved user no longer holds ACCESS_ADMIN', async () => {
+ const user = makeUser();
+ fetchMock.mockResolvedValueOnce(
+ makeOkJson({ access_token: 'new-access', id_token: makeIdToken() }),
+ );
+ deps.findUsers.mockResolvedValue([user]);
+ deps.canAccessAdmin.mockResolvedValue(false);
+
+ await expect(applyGoogleAdminRefresh(deps, baseOptions)).rejects.toMatchObject({
+ code: 'FORBIDDEN',
+ status: 403,
+ });
+ });
+
+ it('throws FORBIDDEN when isEmailAllowed rejects the refreshed identity', async () => {
+ const user = makeUser();
+ fetchMock.mockResolvedValueOnce(
+ makeOkJson({ access_token: 'new-access', id_token: makeIdToken() }),
+ );
+ deps.findUsers.mockResolvedValue([user]);
+ (deps.isEmailAllowed as jest.Mock).mockResolvedValue(false);
+
+ await expect(applyGoogleAdminRefresh(deps, baseOptions)).rejects.toMatchObject({
+ code: 'FORBIDDEN',
+ status: 403,
+ message: expect.stringContaining('domain'),
+ });
+ expect(deps.canAccessAdmin).not.toHaveBeenCalled();
+ });
+
+ it('returns the rotated refresh_token when Google supplies one', async () => {
+ const user = makeUser();
+ fetchMock.mockResolvedValueOnce(
+ makeOkJson({
+ access_token: 'new-access',
+ id_token: makeIdToken(),
+ refresh_token: 'rotated-refresh',
+ }),
+ );
+ deps.findUsers.mockResolvedValue([user]);
+ deps.canAccessAdmin.mockResolvedValue(true);
+ deps.mintToken.mockResolvedValue({ token: 'minted-jwt', expiresAt: 1 });
+
+ const result = await applyGoogleAdminRefresh(deps, baseOptions);
+
+ expect(result.refreshToken).toBe('rotated-refresh');
+ });
+
+ it('uses (AdminRefreshError instanceof) for route mapping', () => {
+ const err = new AdminRefreshError('GOOGLE_NOT_CONFIGURED', 503, 'msg');
+ expect(err).toBeInstanceOf(AdminRefreshError);
+ });
+});
diff --git a/packages/api/src/auth/googleRefresh.ts b/packages/api/src/auth/googleRefresh.ts
new file mode 100644
index 0000000000..dac9016858
--- /dev/null
+++ b/packages/api/src/auth/googleRefresh.ts
@@ -0,0 +1,299 @@
+import { Types } from 'mongoose';
+import { logger } from '@librechat/data-schemas';
+
+import type { IUser } from '@librechat/data-schemas';
+import type { FilterQuery } from 'mongoose';
+import type { AdminExchangeResponse } from '~/auth/exchange';
+
+import { serializeUserForExchange } from '~/auth/exchange';
+import { AdminRefreshError } from '~/auth/refresh';
+
+const GOOGLE_TOKEN_ENDPOINT = 'https://oauth2.googleapis.com/token';
+const GOOGLE_USERINFO_ENDPOINT = 'https://openidconnect.googleapis.com/v1/userinfo';
+const SAFE_USER_PROJECTION = '-password -__v -totpSecret -backupCodes';
+
+interface GoogleTokenset {
+ access_token?: string;
+ id_token?: string;
+ refresh_token?: string;
+}
+
+interface IdTokenClaims {
+ sub?: string;
+ aud?: string | string[];
+}
+
+export interface MintedGoogleAdminToken {
+ token: string;
+ expiresAt: number;
+}
+
+export interface GoogleAdminRefreshDeps {
+ findUsers: (
+ filter: FilterQuery<IUser>,
+ projection: string,
+ options: { sort: Record<string, 1 | -1>; limit: number },
+ ) => Promise<IUser[]>;
+ getUserById: (id: string, projection: string) => Promise<IUser | null>;
+ canAccessAdmin: (user: IUser) => Promise<boolean>;
+ /**
+ * Re-runs the deployment's `registration.allowedDomains` check against the
+ * resolved user's email. Returns true to allow refresh, false to reject.
+ * Mirrors the `isEmailDomainAllowed` call the initial OAuth login enforces
+ * so a domain removed from the allowlist after issuance can't refresh.
+ */
+ isEmailAllowed?: (user: IUser) => Promise<boolean>;
+ mintToken: (user: IUser) => Promise<MintedGoogleAdminToken>;
+}
+
+export interface GoogleAdminRefreshOptions {
+ refreshToken: string;
+ userId?: string;
+ tenantId?: string;
+ clientId?: string;
+ clientSecret?: string;
+}
+
+function decodeJwtPayload(token: string): IdTokenClaims | undefined {
+ const segments = token.split('.');
+ if (segments.length !== 3) return undefined;
+ try {
+ const payload = Buffer.from(segments[1], 'base64url').toString('utf8');
+ return JSON.parse(payload) as IdTokenClaims;
+ } catch {
+ return undefined;
+ }
+}
+
+async function resolveSubFromUserinfo(accessToken: string): Promise<string | undefined> {
+ try {
+ const response = await fetch(GOOGLE_USERINFO_ENDPOINT, {
+ headers: { Authorization: `Bearer ${accessToken}` },
+ });
+ if (!response.ok) {
+ logger.warn('[admin/oauth/refresh] userinfo fallback returned non-OK', {
+ status: response.status,
+ });
+ return undefined;
+ }
+ const body = (await response.json().catch(() => undefined)) as IdTokenClaims | undefined;
+ return typeof body?.sub === 'string' ? body.sub : undefined;
+ } catch (err) {
+ const error = err as { name?: string; message?: string };
+ logger.warn('[admin/oauth/refresh] userinfo fallback failed', {
+ name: error?.name,
+ message: error?.message,
+ });
+ return undefined;
+ }
+}
+
+interface GoogleAdminRefreshConfiguredOptions extends GoogleAdminRefreshOptions {
+ clientId: string;
+ clientSecret: string;
+}
+
+async function fetchGoogleTokenset(
+ options: GoogleAdminRefreshConfiguredOptions,
+): Promise<GoogleTokenset> {
+ let response: Response;
+ try {
+ response = await fetch(GOOGLE_TOKEN_ENDPOINT, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+ body: new URLSearchParams({
+ client_id: options.clientId,
+ client_secret: options.clientSecret,
+ refresh_token: options.refreshToken,
+ grant_type: 'refresh_token',
+ }),
+ });
+ } catch (err) {
+ const error = err as { name?: string; message?: string };
+ logger.warn('[admin/oauth/refresh] token endpoint request failed', {
+ name: error?.name,
+ message: error?.message,
+ });
+ throw new AdminRefreshError('REFRESH_FAILED', 401, 'Refresh failed');
+ }
+
+ if (!response.ok) {
+ logger.warn('[admin/oauth/refresh] Google rejected refresh grant', {
+ status: response.status,
+ });
+ throw new AdminRefreshError('REFRESH_FAILED', 401, 'Refresh failed');
+ }
+
+ try {
+ return (await response.json()) as GoogleTokenset;
+ } catch (err) {
+ const error = err as { name?: string; message?: string };
+ logger.warn('[admin/oauth/refresh] Google returned non-JSON body', {
+ name: error?.name,
+ message: error?.message,
+ });
+ throw new AdminRefreshError('IDP_INCOMPLETE', 502, 'Google returned a non-JSON token response');
+ }
+}
+
+async function resolveGoogleSub(tokenset: GoogleTokenset, clientId?: string): Promise<string> {
+ if (typeof tokenset.access_token !== 'string') {
+ throw new AdminRefreshError(
+ 'IDP_INCOMPLETE',
+ 502,
+ 'Google returned a tokenset missing access_token',
+ );
+ }
+
+ let sub: string | undefined;
+ if (typeof tokenset.id_token === 'string') {
+ const claims = decodeJwtPayload(tokenset.id_token);
+ if (clientId && claims?.aud !== undefined) {
+ const aud = claims.aud;
+ const audOk = Array.isArray(aud) ? aud.includes(clientId) : aud === clientId;
+ if (!audOk) {
+ throw new AdminRefreshError(
+ 'ISSUER_MISMATCH',
+ 401,
+ 'id_token aud does not match configured client',
+ );
+ }
+ }
+ if (typeof claims?.sub === 'string') {
+ sub = claims.sub;
+ }
+ }
+ if (!sub) {
+ sub = await resolveSubFromUserinfo(tokenset.access_token);
+ }
+ if (!sub) {
+ throw new AdminRefreshError(
+ 'CLAIMS_INCOMPLETE',
+ 502,
+ 'Could not resolve google sub from refresh response',
+ );
+ }
+ return sub;
+}
+
+async function resolveAdminUser(
+ googleId: string,
+ deps: GoogleAdminRefreshDeps,
+ options: GoogleAdminRefreshOptions,
+): Promise<IUser> {
+ if (options.userId && Types.ObjectId.isValid(options.userId)) {
+ const direct = await deps.getUserById(options.userId, SAFE_USER_PROJECTION);
+ if (direct) {
+ if (direct.googleId !== googleId) {
+ throw new AdminRefreshError(
+ 'USER_ID_MISMATCH',
+ 401,
+ 'Provided user_id does not match the refreshed identity',
+ );
+ }
+ if (options.tenantId && direct.tenantId !== options.tenantId) {
+ throw new AdminRefreshError(
+ 'TENANT_MISMATCH',
+ 401,
+ 'Provided user_id resolves outside the request tenant',
+ );
+ }
+ if (direct.provider !== 'google') {
+ throw new AdminRefreshError(
+ 'PROVIDER_MISMATCH',
+ 401,
+ 'User account is not bound to the Google provider',
+ );
+ }
+ return direct;
+ }
+ }
+
+ const filter = (
+ options.tenantId ? { googleId, tenantId: options.tenantId } : { googleId }
+ ) as FilterQuery<IUser>;
+ const matches = await deps.findUsers(filter, SAFE_USER_PROJECTION, {
+ sort: { updatedAt: -1 },
+ limit: 2,
+ });
+ if (matches.length > 1) {
+ logger.error('[admin/oauth/refresh] ambiguous googleId match', {
+ googleId,
+ tenantId: options.tenantId,
+ });
+ throw new AdminRefreshError('USER_ID_MISMATCH', 401, 'Ambiguous identity');
+ }
+ const [found] = matches;
+ if (!found) {
+ throw new AdminRefreshError('USER_NOT_FOUND', 401, 'No user found for the refreshed identity');
+ }
+ if (found.provider !== 'google') {
+ throw new AdminRefreshError(
+ 'PROVIDER_MISMATCH',
+ 401,
+ 'User account is not bound to the Google provider',
+ );
+ }
+ return found;
+}
+
+/**
+ * Refresh a Google admin OAuth session.
+ *
+ * Mirrors the OpenID admin refresh contract from `applyAdminRefresh` but
+ * speaks Google's OAuth 2.0 refresh-token grant. Calls Google's token
+ * endpoint, resolves the user's `sub` (preferring an `id_token` claim, with
+ * a userinfo-endpoint fallback per Google's documented behavior of returning
+ * id_token only conditionally on refresh), looks up the admin by `googleId`,
+ * enforces tenant + `ACCESS_ADMIN`, and mints a fresh LibreChat JWT in the
+ * same response shape as `/api/admin/oauth/exchange`.
+ */
+export async function applyGoogleAdminRefresh(
+ deps: GoogleAdminRefreshDeps,
+ options: GoogleAdminRefreshOptions,
+): Promise<AdminExchangeResponse> {
+ if (!options.clientId || !options.clientSecret) {
+ throw new AdminRefreshError(
+ 'GOOGLE_NOT_CONFIGURED',
+ 503,
+ 'Google admin OAuth is not configured',
+ );
+ }
+
+ const configured: GoogleAdminRefreshConfiguredOptions = {
+ ...options,
+ clientId: options.clientId,
+ clientSecret: options.clientSecret,
+ };
+
+ const tokenset = await fetchGoogleTokenset(configured);
+ const googleId = await resolveGoogleSub(tokenset, configured.clientId);
+ const user = await resolveAdminUser(googleId, deps, options);
+
+ if (deps.isEmailAllowed && !(await deps.isEmailAllowed(user))) {
+ throw new AdminRefreshError(
+ 'FORBIDDEN',
+ 403,
+ 'User email domain is not on the deployment allowlist',
+ );
+ }
+
+ if (!(await deps.canAccessAdmin(user))) {
+ throw new AdminRefreshError('FORBIDDEN', 403, 'User does not have admin access');
+ }
+
+ const minted = await deps.mintToken(user);
+
+ if (tokenset.refresh_token && tokenset.refresh_token !== options.refreshToken) {
+ logger.info(
+ '[admin/oauth/refresh] Google rotated the refresh token; client must persist the new value',
+ );
+ }
+
+ return {
+ token: minted.token,
+ refreshToken: tokenset.refresh_token ?? options.refreshToken,
+ user: serializeUserForExchange(user),
+ expiresAt: minted.expiresAt,
+ };
+}
diff --git a/packages/api/src/auth/index.ts b/packages/api/src/auth/index.ts
index 0b211cf3b2..1932986e3b 100644
--- a/packages/api/src/auth/index.ts
+++ b/packages/api/src/auth/index.ts
@@ -3,6 +3,7 @@ export * from './openid';
export * from './proxy';
export * from './exchange';
export * from './refresh';
+export * from './googleRefresh';
export * from './agent';
export * from './password';
export * from './invite';
diff --git a/packages/api/src/auth/refresh.ts b/packages/api/src/auth/refresh.ts
index 2ae5ca0f0a..ba35c15f4c 100644
--- a/packages/api/src/auth/refresh.ts
+++ b/packages/api/src/auth/refresh.ts
@@ -65,6 +65,13 @@ export interface AdminRefreshDeps {
* bearers should always inject this.
*/
canAccessAdmin?: (user: IUser) => Promise<boolean>;
+ /**
+ * Re-runs the deployment's `registration.allowedDomains` check against the
+ * resolved user's email. Returns true to allow refresh, false to reject.
+ * Mirrors the domain check the initial OAuth callback enforces so a domain
+ * removed from the allowlist after issuance can't refresh.
+ */
+ isEmailAllowed?: (user: IUser) => Promise<boolean>;
/**
* Optional post-success hook for forks that need to do additional work
* with the refreshed tokenset and resolved user (e.g. update a server-side
@@ -275,6 +282,14 @@ export async function applyAdminRefresh(
throw new AdminRefreshError('USER_NOT_FOUND', 401, 'No user found for the refreshed identity');
}
+ if (deps.isEmailAllowed && !(await deps.isEmailAllowed(user))) {
+ throw new AdminRefreshError(
+ 'FORBIDDEN',
+ 403,
+ 'User email domain is not on the deployment allowlist',
+ );
+ }
+
if (deps.canAccessAdmin && !(await deps.canAccessAdmin(user))) {
throw new AdminRefreshError('FORBIDDEN', 403, 'User does not have admin access');
}