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 { Types } from 'mongoose';
import { TWO_FACTOR_ENROLLMENT_REQUIRED_CODE } from 'librechat-data-provider';
import type { NextFunction, Response } from 'express';
import type { ApiKeyAuthRequest } from './middleware';
import { createRequireApiKeyAuth } from './middleware';
function createResponse(): {
res: Response;
status: jest.Mock;
json: jest.Mock;
} {
const status = jest.fn();
const json = jest.fn();
const res = { status, json } as unknown as Response;
status.mockReturnValue(res);
return { res, status, json };
}
function createRequest(): ApiKeyAuthRequest {
return {
headers: { authorization: 'Bearer lc-key' },
} as ApiKeyAuthRequest;
}
describe('remote Agent API key authentication', () => {
it('rejects a valid key while account deletion is fenced', async () => {
const userId = new Types.ObjectId();
const middleware = createRequireApiKeyAuth({
validateAgentApiKey: jest.fn().mockResolvedValue({
userId,
keyId: new Types.ObjectId(),
}),
findUser: jest.fn().mockResolvedValue({ _id: userId }),
isPrincipalActive: jest.fn().mockResolvedValue(false),
});
const { res, status, json } = createResponse();
const next = jest.fn() as NextFunction;
await middleware(createRequest(), res, next);
expect(status).toHaveBeenCalledWith(409);
expect(json).toHaveBeenCalledWith({
error: {
message: 'Account deletion is in progress',
type: 'invalid_request_error',
code: 'account_deletion_in_progress',
},
});
expect(next).not.toHaveBeenCalled();
});
it('admits an active principal', async () => {
const userId = new Types.ObjectId();
const middleware = createRequireApiKeyAuth({
validateAgentApiKey: jest.fn().mockResolvedValue({
userId,
keyId: new Types.ObjectId(),
}),
findUser: jest.fn().mockResolvedValue({ _id: userId }),
isPrincipalActive: jest.fn().mockResolvedValue(true),
});
const req = createRequest();
const { res } = createResponse();
const next = jest.fn() as NextFunction;
await middleware(req, res, next);
expect(req.user?.id).toBe(userId.toString());
expect(next).toHaveBeenCalledWith();
});
describe('under required two-factor enforcement', () => {
const original = process.env.ENFORCE_TWO_FACTOR_AUTHENTICATION;
beforeEach(() => {
process.env.ENFORCE_TWO_FACTOR_AUTHENTICATION = 'true';
});
afterEach(() => {
if (original === undefined) {
delete process.env.ENFORCE_TWO_FACTOR_AUTHENTICATION;
} else {
process.env.ENFORCE_TWO_FACTOR_AUTHENTICATION = original;
}
});
const authenticate = async (owner: Record<string, unknown>) => {
const userId = new Types.ObjectId();
const middleware = createRequireApiKeyAuth({
validateAgentApiKey: jest.fn().mockResolvedValue({ userId, keyId: new Types.ObjectId() }),
findUser: jest.fn().mockResolvedValue({ _id: userId, ...owner }),
isPrincipalActive: jest.fn().mockResolvedValue(true),
});
const req = createRequest();
const response = createResponse();
const next = jest.fn() as NextFunction;
await middleware(req, response.res, next);
return { req, next, ...response };
};
it('refuses a key whose local owner has not enrolled', async () => {
const { req, next, status, json } = await authenticate({ provider: 'local' });
expect(status).toHaveBeenCalledWith(403);
expect(json).toHaveBeenCalledWith({
error: expect.objectContaining({ code: TWO_FACTOR_ENROLLMENT_REQUIRED_CODE }),
});
expect(req.user).toBeUndefined();
expect(next).not.toHaveBeenCalled();
});
it('admits a key whose owner has enrolled', async () => {
const { next } = await authenticate({ provider: 'local', twoFactorEnabled: true });
expect(next).toHaveBeenCalledWith();
});
it('admits a key whose owner signs in through a federated provider', async () => {
const { next } = await authenticate({ provider: 'openid' });
expect(next).toHaveBeenCalledWith();
});
});
it('starts the user and deletion-fence reads together', async () => {
const userId = new Types.ObjectId();
let resolveUser!: (user: { _id: Types.ObjectId }) => void;
const user = new Promise<{ _id: Types.ObjectId }>((resolve) => {
resolveUser = resolve;
});
const findUser = jest.fn().mockReturnValue(user);
const isPrincipalActive = jest.fn().mockResolvedValue(true);
const middleware = createRequireApiKeyAuth({
validateAgentApiKey: jest.fn().mockResolvedValue({
userId,
keyId: new Types.ObjectId(),
}),
findUser,
isPrincipalActive,
});
const { res } = createResponse();
const next = jest.fn() as NextFunction;
const authentication = middleware(createRequest(), res, next);
await new Promise<void>((resolve) => setImmediate(resolve));
expect(findUser).toHaveBeenCalledTimes(1);
expect(isPrincipalActive).toHaveBeenCalledWith(userId.toString());
expect(next).not.toHaveBeenCalled();
resolveUser({ _id: userId });
await authentication;
expect(next).toHaveBeenCalledWith();
});
it('answers a failed key lookup with a server error, not an invalid key', async () => {
const middleware = createRequireApiKeyAuth({
validateAgentApiKey: jest.fn().mockRejectedValue(new Error('connection reset')),
findUser: jest.fn(),
isPrincipalActive: jest.fn(),
});
const { res, status, json } = createResponse();
const next = jest.fn() as NextFunction;
await middleware(createRequest(), res, next);
expect(status).toHaveBeenCalledWith(500);
expect(json).toHaveBeenCalledWith(
expect.objectContaining({ error: expect.objectContaining({ code: 'internal_error' }) }),
);
expect(next).not.toHaveBeenCalled();
});
});