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
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import { Keyv } from 'keyv';
jest.mock(
'@librechat/data-schemas',
() => ({
logger: {
info: jest.fn(),
warn: jest.fn(),
error: jest.fn(),
},
}),
{ virtual: true },
);
import { stripCodeChallenge, storeAndStripChallenge, preserveAdminOAuthState } from './exchange';
import type { PkceStrippableRequest, PkceSupportMetadata } from './exchange';
function makeReq(overrides: Partial<PkceStrippableRequest> = {}): PkceStrippableRequest {
return { query: {}, originalUrl: '', url: '', ...overrides };
}
describe('stripCodeChallenge', () => {
const challenge = 'a'.repeat(64);
const callbackUrl = 'https://admin.example.com/auth/openid/callback';
const encodedCallbackUrl = 'https%3A%2F%2Fadmin.example.com%2Fauth%2Fopenid%2Fcallback';
it('removes code_challenge from req.query and both URL strings (sole param)', () => {
const req = makeReq({
query: { code_challenge: challenge },
originalUrl: `/api/admin/oauth/openid?code_challenge=${challenge}`,
url: `/oauth/openid?code_challenge=${challenge}`,
});
stripCodeChallenge(req);
expect(req.query.code_challenge).toBeUndefined();
expect(req.originalUrl).toBe('/api/admin/oauth/openid');
expect(req.url).toBe('/oauth/openid');
});
it('removes admin-panel-only params before the request reaches Passport', () => {
const originalUrl =
`/api/admin/oauth/openid?code_challenge=${challenge}` +
`&redirect_uri=${encodedCallbackUrl}&redirectTo=%2Fsettings&foo=bar`;
const url =
`/oauth/openid?code_challenge=${challenge}` +
`&redirect_uri=${encodedCallbackUrl}&redirectTo=%2Fsettings&foo=bar`;
const req = makeReq({
query: {
code_challenge: challenge,
redirect_uri: callbackUrl,
redirectTo: '/settings',
foo: 'bar',
},
originalUrl,
url,
});
stripCodeChallenge(req);
expect(req.query.code_challenge).toBeUndefined();
expect(req.query.redirect_uri).toBeUndefined();
expect(req.query.redirectTo).toBeUndefined();
expect(req.query.foo).toBe('bar');
expect(req.originalUrl).toBe('/api/admin/oauth/openid?foo=bar');
expect(req.url).toBe('/oauth/openid?foo=bar');
});
it('removes redirect_uri when it is the only admin-panel-only param', () => {
const req = makeReq({
query: { redirect_uri: callbackUrl },
originalUrl: `/oauth/openid?redirect_uri=${encodedCallbackUrl}`,
url: `/oauth/openid?redirect_uri=${encodedCallbackUrl}`,
});
stripCodeChallenge(req);
expect(req.query.redirect_uri).toBeUndefined();
expect(req.originalUrl).toBe('/oauth/openid');
expect(req.url).toBe('/oauth/openid');
});
it('preserves other params when code_challenge is last', () => {
const req = makeReq({
query: { foo: 'bar', code_challenge: challenge },
originalUrl: `/oauth/openid?foo=bar&code_challenge=${challenge}`,
url: `/oauth/openid?foo=bar&code_challenge=${challenge}`,
});
stripCodeChallenge(req);
expect(req.query.code_challenge).toBeUndefined();
expect(req.query.foo).toBe('bar');
expect(req.originalUrl).toBe('/oauth/openid?foo=bar');
expect(req.url).toBe('/oauth/openid?foo=bar');
});
it('preserves other params when code_challenge is first of multiple', () => {
const req = makeReq({
query: { code_challenge: challenge, foo: 'bar' },
originalUrl: `/oauth/openid?code_challenge=${challenge}&foo=bar`,
url: `/oauth/openid?code_challenge=${challenge}&foo=bar`,
});
stripCodeChallenge(req);
expect(req.query.code_challenge).toBeUndefined();
expect(req.originalUrl).toBe('/oauth/openid?foo=bar');
expect(req.url).toBe('/oauth/openid?foo=bar');
});
it('preserves other params when code_challenge is in the middle', () => {
const req = makeReq({
query: { a: '1', code_challenge: challenge, b: '2' },
originalUrl: `/oauth/openid?a=1&code_challenge=${challenge}&b=2`,
url: `/oauth/openid?a=1&code_challenge=${challenge}&b=2`,
});
stripCodeChallenge(req);
expect(req.query.code_challenge).toBeUndefined();
expect(req.originalUrl).toBe('/oauth/openid?a=1&b=2');
expect(req.url).toBe('/oauth/openid?a=1&b=2');
});
it('handles empty code_challenge= value', () => {
const req = makeReq({
query: { code_challenge: '' },
originalUrl: '/oauth/openid?code_challenge=',
url: '/oauth/openid?code_challenge=',
});
stripCodeChallenge(req);
expect(req.query.code_challenge).toBeUndefined();
expect(req.originalUrl).toBe('/oauth/openid');
expect(req.url).toBe('/oauth/openid');
});
it('is a no-op when no code_challenge is present', () => {
const req = makeReq({
query: { foo: 'bar' },
originalUrl: '/oauth/openid?foo=bar',
url: '/oauth/openid?foo=bar',
});
stripCodeChallenge(req);
expect(req.query.foo).toBe('bar');
expect(req.originalUrl).toBe('/oauth/openid?foo=bar');
expect(req.url).toBe('/oauth/openid?foo=bar');
});
it('is a no-op on a bare path with no query string', () => {
const req = makeReq({
query: {},
originalUrl: '/oauth/openid',
url: '/oauth/openid',
});
stripCodeChallenge(req);
expect(req.originalUrl).toBe('/oauth/openid');
expect(req.url).toBe('/oauth/openid');
});
});
describe('storeAndStripChallenge', () => {
const challenge = 'a'.repeat(64);
const callbackUrl = 'https://admin.example.com/auth/openid/callback';
const encodedCallbackUrl = 'https%3A%2F%2Fadmin.example.com%2Fauth%2Fopenid%2Fcallback';
it('stores valid challenge in cache and strips from request', async () => {
const cache = new Keyv();
const setSpy = jest.spyOn(cache, 'set');
const url = `/oauth/openid?code_challenge=${challenge}&redirect_uri=${encodedCallbackUrl}`;
const req = makeReq({
query: {
code_challenge: challenge,
redirect_uri: callbackUrl,
},
originalUrl: url,
url,
});
const result = await storeAndStripChallenge(cache, req, 'test-state', 'openid');
expect(result).toBe(true);
expect(setSpy).toHaveBeenCalledWith(`pkce:test-state`, challenge, expect.any(Number));
expect(req.query.code_challenge).toBeUndefined();
expect(req.query.redirect_uri).toBeUndefined();
expect(req.originalUrl).toBe('/oauth/openid');
expect(req.url).toBe('/oauth/openid');
});
it('strips and returns true when no code_challenge is present', async () => {
const cache = new Keyv();
const setSpy = jest.spyOn(cache, 'set');
const req = makeReq({
query: {},
originalUrl: '/oauth/openid',
url: '/oauth/openid',
});
const result = await storeAndStripChallenge(cache, req, 'test-state', 'openid');
expect(result).toBe(true);
expect(setSpy).not.toHaveBeenCalled();
expect(req.originalUrl).toBe('/oauth/openid');
expect(req.url).toBe('/oauth/openid');
});
it('strips and returns true when code_challenge is invalid (not 64 hex)', async () => {
const cache = new Keyv();
const setSpy = jest.spyOn(cache, 'set');
const url = `/oauth/openid?code_challenge=too-short&redirect_uri=${encodedCallbackUrl}`;
const req = makeReq({
query: {
code_challenge: 'too-short',
redirect_uri: callbackUrl,
},
originalUrl: url,
url,
});
const result = await storeAndStripChallenge(cache, req, 'test-state', 'openid');
expect(result).toBe(true);
expect(setSpy).not.toHaveBeenCalled();
expect(req.query.code_challenge).toBeUndefined();
expect(req.query.redirect_uri).toBeUndefined();
expect(req.originalUrl).toBe('/oauth/openid');
expect(req.url).toBe('/oauth/openid');
});
it('returns false and does not strip on cache failure', async () => {
const cache = new Keyv();
jest.spyOn(cache, 'set').mockRejectedValueOnce(new Error('cache down'));
const url = `/oauth/openid?code_challenge=${challenge}&redirect_uri=${encodedCallbackUrl}`;
const req = makeReq({
query: {
code_challenge: challenge,
redirect_uri: callbackUrl,
},
originalUrl: url,
url,
});
const result = await storeAndStripChallenge(cache, req, 'test-state', 'openid');
expect(result).toBe(false);
expect(req.query.code_challenge).toBe(challenge);
expect(req.query.redirect_uri).toBe(callbackUrl);
expect(req.originalUrl).toBe(url);
expect(req.url).toBe(url);
});
it('reads code_challenge before stripping (ordering guarantee)', async () => {
const cache = new Keyv();
const setSpy = jest.spyOn(cache, 'set');
const req = makeReq({
query: { code_challenge: challenge },
originalUrl: `/oauth/openid?code_challenge=${challenge}`,
url: `/oauth/openid?code_challenge=${challenge}`,
});
await storeAndStripChallenge(cache, req, 'test-state', 'openid');
const storedValue = setSpy.mock.calls[0][1];
expect(storedValue).toBe(challenge);
});
});
describe('preserveAdminOAuthState', () => {
const state = 'b'.repeat(64);
/** Mirrors openid-client's `serverMetadata().supportsPKCE`, which defaults to S256. */
const metadataWith = (methods?: string[]): PkceSupportMetadata => ({
supportsPKCE: (method = 'S256') => methods?.includes(method) === true,
});
it('adds a nonce when the IdP does not advertise PKCE, so the admin state is kept', () => {
const params = new URLSearchParams({ scope: 'openid', state });
const result = preserveAdminOAuthState(params, metadataWith());
expect(result).toBe(params);
expect(params.get('state')).toBe(state);
expect(params.get('nonce')).toMatch(/^[A-Za-z0-9_-]{43}$/);
});
it('adds a nonce when the IdP advertises only the plain method', () => {
const params = new URLSearchParams({ state });
preserveAdminOAuthState(params, metadataWith(['plain']));
expect(params.has('nonce')).toBe(true);
});
it('generates a fresh nonce for each request', () => {
const first = preserveAdminOAuthState(new URLSearchParams({ state }), metadataWith());
const second = preserveAdminOAuthState(new URLSearchParams({ state }), metadataWith());
expect(first.get('nonce')).not.toBe(second.get('nonce'));
});
it('leaves the request alone when the IdP advertises S256', () => {
const params = new URLSearchParams({ scope: 'openid', state });
preserveAdminOAuthState(params, metadataWith(['plain', 'S256']));
expect(params.has('nonce')).toBe(false);
expect(params.get('state')).toBe(state);
});
it('keeps a nonce the request already carries', () => {
const params = new URLSearchParams({ state, nonce: 'configured-nonce' });
preserveAdminOAuthState(params, metadataWith());
expect(params.get('nonce')).toBe('configured-nonce');
});
it('adds nothing when the request has no state to keep', () => {
const params = new URLSearchParams({ scope: 'openid' });
preserveAdminOAuthState(params, metadataWith());
expect(params.has('nonce')).toBe(false);
});
});