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 express from 'express';
import request from 'supertest';
import mongoose from 'mongoose';
import { MongoMemoryServer } from 'mongodb-memory-server';
import { generateKeyPairSync, randomBytes } from 'node:crypto';
import { createMethods, createModels, createBrowserSetupBackend } from '@librechat/data-schemas';
import {
browserSetupRequestHash,
signBrowserSetupProof,
isBrowserEnrollmentApproval,
isBrowserEnrollmentStatusRequest,
isBrowserEnrollmentRedemption,
signBrowserEnrollmentRedemption,
} from '@librechat/code/browser-enrollment';
import type {
BrowserSetupProof,
BrowserEnrollmentRequest,
BrowserEnrollmentApproval,
} from '@librechat/code/browser-enrollment';
import type { AppConfig } from '@librechat/data-schemas';
import { createCodeEnvironmentRegistry } from '../environments';
import { createSameOriginGuard } from '~/middleware/origin';
import { createCodeSetupRouter } from './router';
const identity = generateKeyPairSync('ed25519');
const publicKey = identity.publicKey.export({ type: 'spki', format: 'pem' }).toString();
const privateKey = identity.privateKey.export({ type: 'pkcs8', format: 'pem' }).toString();
const other = generateKeyPairSync('ed25519');
const otherPrivateKey = other.privateKey.export({ type: 'pkcs8', format: 'pem' }).toString();
const instance = 'https://chat.example.test/base';
function config(): AppConfig {
return {
endpoints: {
agents: {
statefulCodeSessions: {
principalWorkers: {
enabled: true,
maxPerUser: 1,
browserSetup: {
enabled: true,
instance,
maxPending: 2,
maxPerIp: 2,
requestsPerMinute: 1200,
requestsPerIpMinute: 120,
proofWindowMs: 60_000,
maxProofsPerAttempt: 1024,
reconcileIntervalMs: 10_000,
retentionMs: 86_400_000,
},
},
environments: [
{
id: 'code-api',
name: 'Code API',
type: 'attached',
owner: 'deployment',
baseURL: 'https://code.example.test/v1',
pairing: { tokenEnv: 'CODE_SETUP_TEST_ADMIN', allowPrincipalWorkers: true },
},
],
},
},
},
} as AppConfig;
}
function setupRequest(): BrowserEnrollmentRequest {
return {
version: 1,
instance,
attemptId: randomBytes(32).toString('base64url'),
createdAt: new Date().toISOString(),
publicKey,
machineName: 'Browser worker',
workspace: { type: 'private' },
allowWorkspaceWrites: false,
allowWorkspaceCommands: false,
};
}
function body(
input: BrowserEnrollmentRequest,
operation: BrowserSetupProof['operation'] = 'setup.start',
changes: Partial<BrowserSetupProof> = {},
signingKey = privateKey,
) {
const proof: BrowserSetupProof = {
operation,
instance: input.instance,
attemptId: input.attemptId,
requestHash: browserSetupRequestHash(input),
timestamp: new Date().toISOString(),
nonce: randomBytes(32).toString('base64url'),
...changes,
};
return { request: input, proof, signature: signBrowserSetupProof(signingKey, proof) };
}
describe('browser setup HTTP protocol boundary', () => {
let mongo: MongoMemoryServer;
let owner: string;
let base: AppConfig;
let support = true;
let refreshCount = 0;
const lifetimes: AbortController[] = [];
let approval: BrowserEnrollmentApproval | undefined;
let completed = false;
let credentialExpiresAt: string;
const previous = {
jwt: process.env.CODEAPI_JWT_ENABLED,
key: process.env.CODEAPI_JWT_PRIVATE_KEY,
token: process.env.CODE_SETUP_TEST_ADMIN,
};
beforeAll(async () => {
process.env.CODEAPI_JWT_ENABLED = 'true';
process.env.CODEAPI_JWT_PRIVATE_KEY = privateKey;
process.env.CODE_SETUP_TEST_ADMIN = 'server-only-administrator';
mongo = await MongoMemoryServer.create({ instance: { args: ['--nounixsocket'] } });
await mongoose.connect(mongo.getUri());
createModels(mongoose);
await Promise.all(Object.values(mongoose.models).map((model) => model.init()));
});
beforeEach(async () => {
await mongoose.connection.dropDatabase();
await createMethods(mongoose).seedDefaultRoles();
const user = await mongoose.models.User.create({
name: 'Signed-in owner',
email: '[email protected]',
provider: 'local',
emailVerified: true,
termsAccepted: true,
role: 'USER',
});
refreshCount = 0;
owner = user._id.toString();
base = config();
support = true;
approval = undefined;
completed = false;
credentialExpiresAt = new Date(Date.now() + 900_000).toISOString();
jest.spyOn(globalThis, 'fetch').mockImplementation(async (url, init) => {
if (
init?.redirect !== 'error' ||
new Headers(init?.headers).get('Authorization') !== 'Bearer server-only-administrator'
) {
throw new Error('Invalid administrator transport');
}
if (String(url).endsWith('/capabilities'))
return Response.json(
support ? { browserEnrollmentVersion: 1, serverId: 'https://code.example.test' } : {},
{ status: support ? 200 : 404 },
);
const payload: unknown = JSON.parse(String(init?.body));
if (String(url).endsWith('/status')) {
if (!isBrowserEnrollmentStatusRequest(payload))
throw new Error('Invalid upstream status request');
return approval
? Response.json({
protocolVersion: 1,
workerId: approval.workerId,
status: completed ? 'completed' : 'pending',
})
: Response.json({}, { status: 409 });
}
if (String(url).endsWith('/redeem')) {
if (!isBrowserEnrollmentRedemption(payload)) throw new Error('Invalid upstream redemption');
completed = true;
return Response.json({
protocolVersion: 1,
workerId: approval!.workerId,
credential: 'key-bound-credential-that-is-long-enough',
expiresAt: credentialExpiresAt,
});
}
if (!isBrowserEnrollmentApproval(payload)) throw new Error('invalid upstream approval');
approval = payload;
return Response.json(payload);
});
});
afterEach(() => {
lifetimes.splice(0).forEach((controller) => controller.abort());
jest.restoreAllMocks();
});
afterAll(async () => {
for (const [name, value] of Object.entries({
CODEAPI_JWT_ENABLED: previous.jwt,
CODEAPI_JWT_PRIVATE_KEY: previous.key,
CODE_SETUP_TEST_ADMIN: previous.token,
})) {
if (value == null) delete process.env[name];
else process.env[name] = value;
}
await mongoose.disconnect();
await mongo.stop();
});
function app(options: { registrationUnavailable?: boolean } = {}) {
const lifetime = new AbortController();
lifetimes.push(lifetime);
const backend = createBrowserSetupBackend(mongoose);
if (options.registrationUnavailable)
backend.ensureRegistration = async () => {
throw new Error('Index enforcement unavailable');
};
const app = express();
app.set('trust proxy', 1);
app.use(express.json());
app.use(
'/api/code-environments/setup',
createCodeSetupRouter({
backend,
signal: lifetime.signal,
getAppConfig: async (options) => {
if (options.refresh) refreshCount++;
return base;
},
registry: () => createCodeEnvironmentRegistry(mongoose),
requireJwtAuth: (req, res, next) => {
if (req.headers.authorization !== 'Bearer browser-session') {
res.status(401).json({ code: 'AUTH_REQUIRED' });
return;
}
Object.assign(req, { user: { id: owner } });
next();
},
checkBan: (_req, _res, next) => next(),
requireSameOrigin: createSameOriginGuard({ trustedOrigins: [instance] }),
banStore: { get: async () => undefined },
}),
);
return app;
}
test('real CLI-shaped start and signed completion pass through explicit browser approval only', async () => {
const first = app();
const second = app();
const input = setupRequest();
const capabilities = await request(first).get('/api/code-environments/setup/capabilities');
expect(capabilities.status).toBe(200);
expect(capabilities.body).toEqual({ browserEnrollmentVersion: 1 });
const initial = await request(first)
.post('/api/code-environments/setup/start')
.send(body(input));
expect(initial.status).toBe(200);
expect(initial.body.status).toBe('pending');
expect(initial.body.verificationUrl).toBe(`${instance}/code/setup/${input.attemptId}`);
const path = `/api/code-environments/setup/${input.attemptId}`;
expect((await request(first).get(path)).status).toBe(401);
const inspect = await request(first).get(path).set('Authorization', 'Bearer browser-session');
expect(inspect.status).toBe(200);
expect(inspect.body.status).toBe('pending');
expect(approval).toBeUndefined();
const crossOrigin = await request(first)
.post(`${path}/approve`)
.set('Authorization', 'Bearer browser-session')
.set('Origin', 'https://attacker.example')
.send({ controlPlaneId: 'code-api' });
expect(crossOrigin.status).toBe(403);
expect(approval).toBeUndefined();
const approved = await request(first)
.post(`${path}/approve`)
.set('Authorization', 'Bearer browser-session')
.set('Origin', 'https://chat.example.test')
.send({ controlPlaneId: 'code-api' });
expect(approved.status).toBe(200);
expect(approved.body.status).toBe('approved');
expect(JSON.stringify(approved.body)).not.toMatch(
/server-only-administrator|credential|binding|codeApiUrl/,
);
const complete = {
...body(input, 'setup.complete'),
redemptionSignature: signBrowserEnrollmentRedemption(privateKey, approval!),
};
const response = await request(second)
.post('/api/code-environments/setup/complete')
.send(complete);
expect(response.status).toBe(200);
expect(response.body.status).toBe('completed');
expect(response.body.credential.workerId).toBe(approval!.workerId);
expect(
(
await request(first)
.post('/api/code-environments/setup/complete')
.send({
...body(input, 'setup.complete'),
redemptionSignature: complete.redemptionSignature,
})
).body.credential,
).toEqual(response.body.credential);
});
test.each([
'operation',
'audience',
'attempt',
'hash',
'signature',
'stale',
'future',
'nonce',
] as const)('rejects a %s mismatch without durable allocation', async (kind) => {
const server = app();
const input = setupRequest();
let value = body(input);
if (kind === 'operation') value = body(input, 'setup.poll');
if (kind === 'audience') value = body({ ...input, instance: 'https://other.example.test' });
if (kind === 'attempt')
value = body(input, 'setup.start', { attemptId: randomBytes(32).toString('base64url') });
if (kind === 'hash') value = body(input, 'setup.start', { requestHash: 'f'.repeat(64) });
if (kind === 'signature') value = body(input, 'setup.start', {}, otherPrivateKey);
if (kind === 'stale')
value = body(input, 'setup.start', {
timestamp: new Date(Date.now() - 61_000).toISOString(),
});
if (kind === 'future')
value = body(input, 'setup.start', {
timestamp: new Date(Date.now() + 61_000).toISOString(),
});
if (kind === 'nonce') value.proof.nonce = 'malformed';
const response = await request(server).post('/api/code-environments/setup/start').send(value);
expect([400, 401]).toContain(response.status);
expect(await mongoose.connection.collection('browser_setup_sessions').countDocuments()).toBe(0);
});
test('replay is shared across replicas, identical starts resume, and immutable changes conflict', async () => {
const first = app();
const second = app();
const input = setupRequest();
const signed = body(input);
const response = await request(first).post('/api/code-environments/setup/start').send(signed);
expect(response.status).toBe(200);
expect(
(await request(second).post('/api/code-environments/setup/start').send(signed)).status,
).toBe(409);
const resumed = await request(second)
.post('/api/code-environments/setup/start')
.send(body(input));
expect(resumed.body).toEqual(response.body);
expect(
(
await request(second)
.post('/api/code-environments/setup/start')
.send(body({ ...input, machineName: 'Changed' }))
).status,
).toBe(409);
expect(await mongoose.connection.collection('browser_setup_sessions').countDocuments()).toBe(1);
});
test('capability fails closed for policy withdrawal, absent credentials, and unsupported Code API', async () => {
const server = app();
support = false;
expect((await request(server).get('/api/code-environments/setup/capabilities')).status).toBe(
503,
);
support = true;
delete process.env.CODE_SETUP_TEST_ADMIN;
expect((await request(server).get('/api/code-environments/setup/capabilities')).status).toBe(
503,
);
process.env.CODE_SETUP_TEST_ADMIN = 'server-only-administrator';
base.endpoints!.agents!.statefulCodeSessions!.principalWorkers!.enabled = false;
expect((await request(server).get('/api/code-environments/setup/capabilities')).status).toBe(
503,
);
});
test('rate-limited and invalid machine requests never trigger a forced configuration reload', async () => {
const server = app();
const settings = base.endpoints!.agents!.statefulCodeSessions!.principalWorkers!.browserSetup!;
settings.requestsPerMinute = 2;
settings.requestsPerIpMinute = 2;
expect(
(await request(server).post('/api/code-environments/setup/start').send({ invalid: true }))
.status,
).toBe(400);
expect(refreshCount).toBe(0);
expect((await request(server).get('/api/code-environments/setup/capabilities')).status).toBe(
200,
);
const admitted = refreshCount;
expect((await request(server).get('/api/code-environments/setup/capabilities')).status).toBe(
429,
);
expect(refreshCount).toBe(admitted);
});
test('capabilities fail closed when the required unique registration indexes cannot be enforced', async () => {
const response = await request(app({ registrationUnavailable: true })).get(
'/api/code-environments/setup/capabilities',
);
expect(response.status).toBe(503);
expect(response.body.browserEnrollmentVersion).toBeUndefined();
expect(globalThis.fetch).not.toHaveBeenCalled();
});
test('bounded anonymous allocation cannot grow by changing attempt IDs or forwarded IPs', async () => {
const server = app();
for (let i = 0; i < 2; i++)
expect(
(
await request(server)
.post('/api/code-environments/setup/start')
.set('X-Forwarded-For', `198.51.100.${i + 1}`)
.send(body(setupRequest()))
).status,
).toBe(200);
expect(
(
await request(server)
.post('/api/code-environments/setup/start')
.set('X-Forwarded-For', '198.51.100.200')
.send(body(setupRequest()))
).status,
).toBe(429);
expect(await mongoose.connection.collection('browser_setup_sessions').countDocuments()).toBe(2);
});
});