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 type { AppConfig } from '@librechat/data-schemas';
import type { Response } from 'express';
import type { ServerRequest } from '~/types/http';
import { createAdminCodeEnvironmentHandlers } from './code';
interface MockResponse extends Response {
statusCode: number;
body?: Record<string, unknown>;
}
function mockResponse(): MockResponse {
const response = {
statusCode: 200,
body: undefined as Record<string, unknown> | undefined,
status(code: number) {
response.statusCode = code;
return response;
},
json(body: Record<string, unknown>) {
response.body = body;
return response;
},
};
return response as unknown as MockResponse;
}
function request(): ServerRequest {
return {
params: { environmentId: 'attached-vm' },
user: { id: 'admin-1', role: 'ADMIN', tenantId: 'tenant-1' },
} as unknown as ServerRequest;
}
function config(): AppConfig {
return {
endpoints: {
agents: {
statefulCodeSessions: {
allowedEnvironments: ['conversation'],
environments: [
{
id: 'attached-vm',
name: 'Attached VM',
type: 'attached',
baseURL: 'https://bridge.example.com/v1/',
default: true,
owner: 'deployment',
pairing: {
workerId: 'vm-1',
tokenEnv: 'CODE_BRIDGE_ADMIN_TOKEN',
},
},
],
},
},
},
} as unknown as AppConfig;
}
describe('createAdminCodeEnvironmentHandlers', () => {
it('creates a one-time pairing code without exposing the administrator token', async () => {
const fetchImpl = jest.fn().mockResolvedValue(
Response.json({
protocolVersion: 1,
workerId: 'vm-1',
code: 'one-time-code-value-that-is-long',
expiresAt: '2099-08-30T12:00:00.000Z',
}),
);
const handlers = createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(config()),
readSecret: jest.fn().mockReturnValue('administrator-bootstrap-token'),
fetchImpl,
});
const response = mockResponse();
await handlers.createPairing(request(), response);
expect(fetchImpl).toHaveBeenCalledWith(
'https://bridge.example.com/v1/bridge/pairings',
expect.objectContaining({
method: 'POST',
headers: {
Authorization: 'Bearer administrator-bootstrap-token',
'Content-Type': 'application/json',
},
body: JSON.stringify({
workerId: 'vm-1',
binding: {
tenantId: 'tenant-1',
principal: { type: 'deployment', id: 'attached-vm' },
},
}),
}),
);
expect(response.statusCode).toBe(200);
expect(response.body).toEqual({
environmentId: 'attached-vm',
workerId: 'vm-1',
code: 'one-time-code-value-that-is-long',
expiresAt: '2099-08-30T12:00:00.000Z',
});
expect(JSON.stringify(response.body)).not.toContain('administrator-bootstrap-token');
});
it('fails closed before outbound traffic when tenant context is unavailable', async () => {
const fetchImpl = jest.fn();
const handlers = createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(config()),
resolveTenantId: jest.fn(() => {
throw new Error('missing tenant context');
}),
readSecret: jest.fn().mockReturnValue('administrator-bootstrap-token'),
fetchImpl,
});
const response = mockResponse();
await handlers.createPairing(request(), response);
expect(response.statusCode).toBe(503);
expect(response.body).toEqual({ error: 'Code environment tenant context is unavailable' });
expect(fetchImpl).not.toHaveBeenCalled();
});
it('uses only YAML config when resolving pairing secrets and destinations', async () => {
const writableOverride = config();
const overriddenEnvironment =
writableOverride.endpoints?.agents?.statefulCodeSessions?.environments?.[0];
if (overriddenEnvironment == null) {
throw new Error('Expected the test code environment');
}
overriddenEnvironment.baseURL = 'https://attacker.example.com/v1';
overriddenEnvironment.pairing = {
workerId: 'vm-1',
allowPrincipalWorkers: false,
tokenEnv: 'DATABASE_URL',
};
const getAppConfig = jest.fn(async (options: { baseOnly?: boolean }) =>
options.baseOnly === true ? config() : writableOverride,
);
const readSecret = jest.fn((name: string) =>
name === 'CODE_BRIDGE_ADMIN_TOKEN' ? 'deployment-token' : 'sensitive-database-secret',
);
const fetchImpl = jest.fn().mockResolvedValue(
Response.json({
protocolVersion: 1,
workerId: 'vm-1',
code: 'one-time-code-value-that-is-long',
expiresAt: '2099-08-30T12:00:00.000Z',
}),
);
const handlers = createAdminCodeEnvironmentHandlers({
getAppConfig,
readSecret,
fetchImpl,
});
await handlers.createPairing(request(), mockResponse());
expect(getAppConfig).toHaveBeenCalledWith({ baseOnly: true });
expect(readSecret).toHaveBeenCalledWith('CODE_BRIDGE_ADMIN_TOKEN');
expect(readSecret).not.toHaveBeenCalledWith('DATABASE_URL');
expect(fetchImpl).toHaveBeenCalledWith(
'https://bridge.example.com/v1/bridge/pairings',
expect.any(Object),
);
});
it('fails closed before outbound traffic when the administrator token is unavailable', async () => {
const fetchImpl = jest.fn();
const handlers = createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(config()),
readSecret: jest.fn().mockReturnValue(undefined),
fetchImpl,
});
const response = mockResponse();
await handlers.createPairing(request(), response);
expect(response.statusCode).toBe(503);
expect(response.body).toEqual({ error: 'Code environment pairing is not configured' });
expect(fetchImpl).not.toHaveBeenCalled();
});
it('treats inherited process environment properties as missing secrets', async () => {
const deploymentConfig = config();
const environment = deploymentConfig.endpoints?.agents?.statefulCodeSessions?.environments?.[0];
if (environment?.pairing == null) throw new Error('Expected the test pairing configuration');
environment.pairing.tokenEnv = 'constructor';
const fetchImpl = jest.fn();
const handlers = createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(deploymentConfig),
fetchImpl,
});
const response = mockResponse();
await handlers.createPairing(request(), response);
expect(response.statusCode).toBe(503);
expect(response.body).toEqual({ error: 'Code environment pairing is not configured' });
expect(fetchImpl).not.toHaveBeenCalled();
});
it('normalizes the bridge base URL before appending control paths', async () => {
const deploymentConfig = config();
const environment = deploymentConfig.endpoints?.agents?.statefulCodeSessions?.environments?.[0];
if (environment == null) throw new Error('Expected the test code environment');
environment.baseURL = ' https://bridge.example.com/v1/ ';
const fetchImpl = jest.fn().mockResolvedValue(
Response.json({
protocolVersion: 1,
workerId: 'vm-1',
code: 'one-time-code-value-that-is-long',
expiresAt: '2099-08-30T12:00:00.000Z',
}),
);
const handlers = createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(deploymentConfig),
readSecret: jest.fn().mockReturnValue('administrator-bootstrap-token'),
fetchImpl,
});
await handlers.createPairing(request(), mockResponse());
expect(fetchImpl).toHaveBeenCalledWith(
'https://bridge.example.com/v1/bridge/pairings',
expect.any(Object),
);
});
it('rejects insecure non-loopback pairing before reading or sending credentials', async () => {
const deploymentConfig = config();
const environment = deploymentConfig.endpoints?.agents?.statefulCodeSessions?.environments?.[0];
if (environment == null) throw new Error('Expected the test code environment');
environment.baseURL = 'http://bridge.example.com/v1';
const readSecret = jest.fn().mockReturnValue('administrator-bootstrap-token');
const fetchImpl = jest.fn();
const handlers = createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(deploymentConfig),
readSecret,
fetchImpl,
});
const response = mockResponse();
await handlers.createPairing(request(), response);
expect(response.statusCode).toBe(409);
expect(response.body).toEqual({
error: 'Code environment pairing requires secure transport',
});
expect(readSecret).not.toHaveBeenCalled();
expect(fetchImpl).not.toHaveBeenCalled();
});
it('rejects an expired one-time pairing code', async () => {
const fetchImpl = jest.fn().mockResolvedValue(
Response.json({
protocolVersion: 1,
workerId: 'vm-1',
code: 'expired-one-time-code-value',
expiresAt: '2000-01-01T00:00:00.000Z',
}),
);
const handlers = createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(config()),
readSecret: jest.fn().mockReturnValue('administrator-bootstrap-token'),
fetchImpl,
});
const response = mockResponse();
await handlers.createPairing(request(), response);
expect(response.statusCode).toBe(502);
expect(response.body).toEqual({ error: 'Code API returned an invalid pairing response' });
});
it('rejects a pairing code outside the 32-character base64url wire format', async () => {
const fetchImpl = jest.fn().mockResolvedValue(
Response.json({
protocolVersion: 1,
workerId: 'vm-1',
code: 'invalid code value with whitespace',
expiresAt: '2099-08-30T12:00:00.000Z',
}),
);
const handlers = createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(config()),
readSecret: jest.fn().mockReturnValue('administrator-bootstrap-token'),
fetchImpl,
});
const response = mockResponse();
await handlers.createPairing(request(), response);
expect(response.statusCode).toBe(502);
expect(response.body).toEqual({ error: 'Code API returned an invalid pairing response' });
});
it('revokes the environment worker without returning bridge credentials', async () => {
const fetchImpl = jest
.fn()
.mockResolvedValue(Response.json({ protocolVersion: 1, revoked: true }));
const handlers = createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(config()),
readSecret: jest.fn().mockReturnValue('administrator-bootstrap-token'),
fetchImpl,
});
const response = mockResponse();
await handlers.revokeWorker(request(), response);
expect(fetchImpl).toHaveBeenCalledWith(
'https://bridge.example.com/v1/bridge/workers/vm-1/revoke',
expect.objectContaining({ method: 'POST', redirect: 'error' }),
);
expect(response.statusCode).toBe(200);
expect(response.body).toEqual({
environmentId: 'attached-vm',
workerId: 'vm-1',
revoked: true,
});
expect(JSON.stringify(response.body)).not.toContain('administrator-bootstrap-token');
});
it('rejects an invalid revocation acknowledgement', async () => {
const fetchImpl = jest
.fn()
.mockResolvedValue(Response.json({ protocolVersion: 1, revoked: false }));
const handlers = createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(config()),
readSecret: jest.fn().mockReturnValue('administrator-bootstrap-token'),
fetchImpl,
});
const response = mockResponse();
await handlers.revokeWorker(request(), response);
expect(response.statusCode).toBe(502);
expect(response.body).toEqual({ error: 'Code API returned an invalid revocation response' });
});
describe('audit entries', () => {
function build(fetchImpl: jest.Mock, recordAuditEntry: jest.Mock) {
return createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(config()),
readSecret: jest.fn().mockReturnValue('administrator-bootstrap-token'),
fetchImpl,
recordAuditEntry,
});
}
it('records code_worker.paired without the pairing code', async () => {
const recordAuditEntry = jest.fn().mockResolvedValue(undefined);
const fetchImpl = jest.fn().mockResolvedValue(
Response.json({
protocolVersion: 1,
workerId: 'vm-1',
code: 'one-time-code-value-that-is-long',
expiresAt: '2099-08-30T12:00:00.000Z',
}),
);
await build(fetchImpl, recordAuditEntry).createPairing(request(), mockResponse());
expect(recordAuditEntry.mock.calls.map(([entry]) => entry.outcome ?? 'success')).toEqual([
'pending',
'success',
]);
const input = recordAuditEntry.mock.calls[1][0];
expect(input).toEqual(
expect.objectContaining({
action: 'code_worker.paired',
target: { type: 'code_worker', id: 'vm-1', name: 'attached-vm' },
}),
);
expect(input.tenantId).toBeUndefined();
expect(input.metadata.boundTenantId).toEqual(expect.any(String));
expect(JSON.stringify(recordAuditEntry.mock.calls)).not.toContain(
'one-time-code-value-that-is-long',
);
expect(JSON.stringify(recordAuditEntry.mock.calls)).not.toContain(
'administrator-bootstrap-token',
);
});
it('records code_worker.revoked as pending, then success or a failure entry when it is not confirmed', async () => {
const recordAuditEntry = jest.fn().mockResolvedValue(undefined);
const ok = jest.fn().mockResolvedValue(Response.json({ protocolVersion: 1, revoked: true }));
const bad = jest
.fn()
.mockResolvedValue(Response.json({ protocolVersion: 1, revoked: false }));
await build(ok, recordAuditEntry).revokeWorker(request(), mockResponse());
expect(recordAuditEntry).toHaveBeenCalledTimes(2);
expect(recordAuditEntry).toHaveBeenNthCalledWith(
1,
expect.objectContaining({
action: 'code_worker.revoked',
outcome: 'pending',
target: { type: 'code_worker', id: 'vm-1', name: 'attached-vm' },
}),
);
expect(recordAuditEntry).toHaveBeenLastCalledWith(
expect.objectContaining({ action: 'code_worker.revoked', outcome: 'success' }),
);
recordAuditEntry.mockClear();
await build(bad, recordAuditEntry).revokeWorker(request(), mockResponse());
expect(recordAuditEntry).toHaveBeenCalledTimes(2);
expect(recordAuditEntry).toHaveBeenLastCalledWith(
expect.objectContaining({
outcome: 'failure',
metadata: { environmentId: 'attached-vm', code: 'invalid_response' },
}),
);
});
it('records the pairing before the bridge call and a failure entry when no code is minted', async () => {
const order: string[] = [];
const recordAuditEntry = jest.fn().mockImplementation(async (input) => {
order.push(`audit:${input.outcome ?? 'success'}`);
});
const fetchImpl = jest.fn().mockImplementation(async () => {
order.push('bridge');
return new Response('nope', { status: 500 });
});
await build(fetchImpl, recordAuditEntry).createPairing(request(), mockResponse());
expect(order).toEqual(['audit:pending', 'bridge', 'audit:failure']);
expect(recordAuditEntry).toHaveBeenLastCalledWith(
expect.objectContaining({ metadata: expect.objectContaining({ code: 'bridge_rejected' }) }),
);
});
it('sends the revocation without waiting for a slow pending audit write', async () => {
const order: string[] = [];
let release: () => void = () => undefined;
const recordAuditEntry = jest.fn().mockImplementation(async (input) => {
if (input.outcome === 'pending') {
await new Promise<void>((resolve) => (release = resolve));
}
order.push(`audit:${input.outcome ?? 'success'}`);
});
const fetchImpl = jest.fn().mockImplementation(async () => {
order.push('bridge');
release();
return Response.json({ protocolVersion: 1, revoked: true });
});
await build(fetchImpl, recordAuditEntry).revokeWorker(request(), mockResponse());
expect(order).toEqual(['bridge', 'audit:pending', 'audit:success']);
});
it('delivers the pairing code before the terminal audit write settles', async () => {
let release: () => void = () => undefined;
let deliveredAtTerminalWrite: unknown;
const response = mockResponse();
const recordAuditEntry = jest.fn().mockImplementation(async (input) => {
if (input.outcome === undefined || input.outcome === 'success') {
deliveredAtTerminalWrite = response.body;
await new Promise<void>((resolve) => (release = resolve));
}
});
const fetchImpl = jest.fn().mockResolvedValue(
Response.json({
protocolVersion: 1,
workerId: 'vm-1',
code: 'one-time-code-value-that-is-long',
expiresAt: '2099-08-30T12:00:00.000Z',
}),
);
const pending = build(fetchImpl, recordAuditEntry).createPairing(request(), response);
await new Promise((resolve) => setImmediate(resolve));
release();
await pending;
expect(deliveredAtTerminalWrite).toEqual(expect.objectContaining({ workerId: 'vm-1' }));
});
it('does not pair a worker when the pending audit write fails under fail-closed', async () => {
const fetchImpl = jest.fn();
const response = mockResponse();
await createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(config()),
readSecret: jest.fn().mockReturnValue('administrator-bootstrap-token'),
fetchImpl,
recordAuditEntry: jest.fn().mockRejectedValue(new Error('audit down')),
auditFailClosed: true,
})
.createPairing(request(), response)
.catch(() => undefined);
expect(fetchImpl).not.toHaveBeenCalled();
});
it('never blocks a revocation on an audit outage, even when fail-closed', async () => {
const ok = jest.fn().mockResolvedValue(Response.json({ protocolVersion: 1, revoked: true }));
const response = mockResponse();
await createAdminCodeEnvironmentHandlers({
getAppConfig: jest.fn().mockResolvedValue(config()),
readSecret: jest.fn().mockReturnValue('administrator-bootstrap-token'),
fetchImpl: ok,
recordAuditEntry: jest.fn().mockRejectedValue(new Error('audit down')),
auditFailClosed: true,
}).revokeWorker(request(), response);
expect(response.statusCode).toBe(200);
});
it('does not fail the pairing when the audit write fails (fail-open)', async () => {
const recordAuditEntry = jest.fn().mockRejectedValue(new Error('audit down'));
const fetchImpl = jest.fn().mockResolvedValue(
Response.json({
protocolVersion: 1,
workerId: 'vm-1',
code: 'one-time-code-value-that-is-long',
expiresAt: '2099-08-30T12:00:00.000Z',
}),
);
const response = mockResponse();
await build(fetchImpl, recordAuditEntry).createPairing(request(), response);
expect(response.statusCode).toBe(200);
});
});
});