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 { logger } from '@librechat/data-schemas';
import type * as t from '~/mcp/types';
import {
setMCPToolsChangedHandler,
setMCPToolsChangedRevisionHandler,
getMCPToolCatalogGeneration,
} from '~/mcp/toolsChanged';
import { STANDARD_MCP_CAPABILITY_PROFILE } from '~/mcp/capabilities';
import { ConnectionsRepository } from '~/mcp/ConnectionsRepository';
import { MCPConnectionFactory } from '~/mcp/MCPConnectionFactory';
import { MCPConnection } from '~/mcp/connection';
// Mock external dependencies
jest.mock('@librechat/data-schemas', () => ({
logger: {
debug: jest.fn(),
error: jest.fn(),
info: jest.fn(),
warn: jest.fn(),
},
}));
jest.mock('../MCPConnectionFactory', () => ({
MCPConnectionFactory: {
create: jest.fn(),
},
}));
jest.mock('../connection');
// Mock the registry
const mockShouldEnableSSRFProtection = jest.fn().mockReturnValue(false);
const mockGetAllowedDomains = jest.fn().mockReturnValue(null);
const mockGetAllowedAddresses = jest.fn().mockReturnValue(null);
const mockRegistryInstance = {
getServerConfig: jest.fn(),
getAllServerConfigs: jest.fn(),
shouldEnableSSRFProtection: mockShouldEnableSSRFProtection,
getAllowedDomains: mockGetAllowedDomains,
getAllowedAddresses: mockGetAllowedAddresses,
getMCPAppsPolicy: jest.fn().mockReturnValue({ enabled: true, legacyHtmlEnabled: true }),
resolveAllowlists: jest.fn(async () => ({
allowedDomains: mockGetAllowedDomains(),
allowedAddresses: mockGetAllowedAddresses(),
useSSRFProtection: mockShouldEnableSSRFProtection(),
mcpApps: { enabled: true, legacyHtmlEnabled: true },
})),
};
jest.mock('../registry/MCPServersRegistry', () => ({
MCPServersRegistry: {
getInstance: () => mockRegistryInstance,
},
}));
const mockLogger = logger as jest.Mocked<typeof logger>;
// Use mocked registry instance
const mockRegistry = mockRegistryInstance as jest.Mocked<typeof mockRegistryInstance>;
describe('ConnectionsRepository', () => {
let repository: ConnectionsRepository;
let mockServerConfigs: Record<string, t.ParsedServerConfig>;
let mockConnection: jest.Mocked<MCPConnection>;
beforeEach(() => {
setMCPToolsChangedHandler(null);
mockServerConfigs = {
server1: { url: 'http://localhost:3001', type: 'sse' },
server2: { command: 'test-command', args: ['--test'], type: 'stdio' },
server3: { url: 'ws://localhost:8080', type: 'websocket' },
};
// Setup mock registry
// eslint-disable-next-line @typescript-eslint/no-unused-vars
mockRegistry.getServerConfig = jest.fn((serverName: string, ownerId?: string) =>
Promise.resolve(mockServerConfigs[serverName] || undefined),
) as jest.Mock;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
mockRegistry.getAllServerConfigs = jest.fn((ownerId?: string) =>
Promise.resolve(mockServerConfigs),
) as jest.Mock;
mockConnection = {
client: {
getServerCapabilities: jest.fn().mockReturnValue({ tools: {} }),
},
isConnected: jest.fn().mockResolvedValue(true),
disconnect: jest.fn().mockResolvedValue(undefined),
dispose: jest.fn().mockResolvedValue(undefined),
fetchToolsSnapshot: jest.fn().mockResolvedValue({ tools: [], complete: true }),
reserveToolsPublicationRevision: jest.fn().mockResolvedValue({}),
refreshToolList: jest.fn().mockResolvedValue(undefined),
createdAt: Date.now(),
isStale: jest.fn().mockReturnValue(false),
/* A real connection is an EventEmitter and the repository subscribes to it. */
on: jest.fn(),
removeAllListeners: jest.fn(),
} as unknown as jest.Mocked<MCPConnection>;
(MCPConnectionFactory.create as jest.Mock).mockResolvedValue(mockConnection);
// Create repository with undefined ownerId (app-level)
repository = new ConnectionsRepository(undefined);
jest.clearAllMocks();
});
afterEach(() => {
setMCPToolsChangedHandler(null);
setMCPToolsChangedRevisionHandler(null);
jest.clearAllMocks();
});
describe('has', () => {
it('should return true for existing server', async () => {
expect(await repository.has('server1')).toBe(true);
});
it('should return false for non-existing server', async () => {
expect(await repository.has('nonexistent')).toBe(false);
});
});
describe('get', () => {
it('should return existing connected connection', async () => {
mockConnection.isConnected.mockResolvedValue(true);
repository['connections'].set('server1', mockConnection);
const result = await repository.get('server1');
expect(result).toBe(mockConnection);
expect(MCPConnectionFactory.create).not.toHaveBeenCalled();
});
it('should create new connection if none exists', async () => {
const result = await repository.get('server1');
expect(result).toBe(mockConnection);
expect(MCPConnectionFactory.create).toHaveBeenCalledWith(
{
serverName: 'server1',
serverConfig: mockServerConfigs.server1,
useSSRFProtection: false,
allowedDomains: null,
allowedAddresses: null,
dbSourced: false,
capabilityProfile: STANDARD_MCP_CAPABILITY_PROFILE,
},
undefined,
);
expect(repository['connections'].get('server1')).toBe(mockConnection);
expect(mockConnection.fetchToolsSnapshot).toHaveBeenCalledTimes(1);
expect(mockConnection.refreshToolList).not.toHaveBeenCalled();
});
it('creates an operator connection only for the expected current config', async () => {
const expectedConfig = mockServerConfigs.server1;
await expect(repository.get('server1', { expectedConfig })).resolves.toBe(mockConnection);
expect(MCPConnectionFactory.create).toHaveBeenCalledWith(
expect.objectContaining({ serverConfig: expectedConfig }),
undefined,
);
});
it('rejects a stale expected config without evicting the current pooled connection', async () => {
repository['connections'].set('server1', mockConnection);
const staleConfig = { ...mockServerConfigs.server1, url: 'http://localhost:3999' };
await expect(repository.get('server1', { expectedConfig: staleConfig })).rejects.toThrow(
'changed during connection checkout',
);
expect(repository.getPooledConnection('server1')).toBe(mockConnection);
expect(mockConnection.dispose).not.toHaveBeenCalled();
});
it('disposes a new connection when the current config changes before publication', async () => {
let releaseCreation!: () => void;
let markCreationStarted!: () => void;
const creationHeld = new Promise<void>((resolve) => {
releaseCreation = resolve;
});
const creationStarted = new Promise<void>((resolve) => {
markCreationStarted = resolve;
});
(MCPConnectionFactory.create as jest.Mock).mockImplementationOnce(async () => {
markCreationStarted();
await creationHeld;
return mockConnection;
});
const load = repository.get('server1', { expectedConfig: mockServerConfigs.server1 });
await creationStarted;
mockServerConfigs.server1 = { ...mockServerConfigs.server1, url: 'http://localhost:3999' };
releaseCreation();
await expect(load).rejects.toThrow('changed during connection checkout');
expect(mockConnection.dispose).toHaveBeenCalledTimes(1);
expect(repository.getPooledConnection('server1')).toBeUndefined();
});
it('refuses an app connection for a server declaring chat-only headers', async () => {
mockServerConfigs.server1 = {
...mockServerConfigs.server1,
requestHeaders: { 'X-Workspace': 'workspace-1' },
} as t.ParsedServerConfig;
const result = await repository.get('server1');
/** A shared session would carry these into its own `initialize` and
* `tools/list`, which every later catalog read reuses. */
expect(result).toBeNull();
expect(MCPConnectionFactory.create).not.toHaveBeenCalled();
});
it('still creates a user-owned connection for a server declaring chat-only headers', async () => {
mockServerConfigs.server1 = {
...mockServerConfigs.server1,
requestHeaders: { 'X-Workspace': 'workspace-1' },
} as t.ParsedServerConfig;
const userRepository = new ConnectionsRepository('user-1');
const result = await userRepository.get('server1');
expect(result).toBe(mockConnection);
expect(MCPConnectionFactory.create).toHaveBeenCalledTimes(1);
});
it('serializes concurrent creation so only one connection is retained', async () => {
const [first, second] = await Promise.all([
repository.get('server1'),
repository.get('server1'),
]);
expect(first).toBe(mockConnection);
expect(second).toBe(mockConnection);
expect(MCPConnectionFactory.create).toHaveBeenCalledTimes(1);
expect(mockConnection.on).toHaveBeenCalledTimes(1);
});
it('awaits initial app tool publication before returning a new connection', async () => {
let releasePublication: (() => void) | undefined;
const publication = new Promise<void>((resolve) => {
releasePublication = resolve;
});
const handler = jest.fn(() => publication);
setMCPToolsChangedHandler(handler);
let loaded = false;
const load = repository.get('server1').then((connection) => {
loaded = true;
return connection;
});
await new Promise((resolve) => setImmediate(resolve));
expect(handler).toHaveBeenCalledWith(
expect.objectContaining({
serverName: 'server1',
tools: [],
publicationGeneration: getMCPToolCatalogGeneration(mockServerConfigs.server1),
}),
);
expect(loaded).toBe(false);
releasePublication?.();
await expect(load).resolves.toBe(mockConnection);
});
/** An app-level write that carries no revision cannot be ordered and is dropped, so the
* ordering reserved for this snapshot has to reach the publication (#14857). */
it('publishes the initial app snapshot under the revision it was fetched with', async () => {
mockConnection.fetchToolsSnapshot.mockResolvedValue({
tools: [],
complete: true,
publicationRevision: '4',
});
const handler = jest.fn();
setMCPToolsChangedHandler(handler);
await repository.get('server1');
expect(handler).toHaveBeenCalledWith(
expect.objectContaining({ serverName: 'server1', publicationRevision: '4' }),
);
});
it('reserves ordering for a server that advertises no tools capability', async () => {
(mockConnection.client.getServerCapabilities as jest.Mock).mockReturnValue({});
mockConnection.reserveToolsPublicationRevision = jest
.fn()
.mockResolvedValue({ publicationRevision: '9' });
const handler = jest.fn();
setMCPToolsChangedHandler(handler);
await repository.get('server1');
expect(mockConnection.fetchToolsSnapshot).not.toHaveBeenCalled();
expect(handler).toHaveBeenCalledWith(
expect.objectContaining({ serverName: 'server1', tools: [], publicationRevision: '9' }),
);
});
/** An unordered publication is dropped in silence, so a server left with no way to order
* its empty catalog has to retry rather than leave the previous one advertised. */
it('retries an empty catalog it could not reserve ordering for', async () => {
(mockConnection.client.getServerCapabilities as jest.Mock).mockReturnValue({});
mockConnection.reserveToolsPublicationRevision = jest
.fn()
.mockResolvedValue({ orderingUnavailable: true });
const handler = jest.fn();
setMCPToolsChangedHandler(handler);
await repository.get('server1');
expect(mockConnection.refreshToolList).toHaveBeenCalledTimes(1);
expect(handler).not.toHaveBeenCalled();
});
it('retries a fetched catalog it could not reserve ordering for', async () => {
mockConnection.fetchToolsSnapshot.mockResolvedValue({
tools: [],
complete: true,
orderingUnavailable: true,
});
const handler = jest.fn();
setMCPToolsChangedHandler(handler);
await repository.get('server1');
expect(mockConnection.refreshToolList).toHaveBeenCalledTimes(1);
expect(handler).not.toHaveBeenCalled();
});
it('can defer the initial app tool refresh for startup synchronization', async () => {
await repository.get('server1', { refreshTools: false });
expect(mockConnection.fetchToolsSnapshot).not.toHaveBeenCalled();
expect(mockConnection.refreshToolList).not.toHaveBeenCalled();
});
it('queues the connection retry path when the initial app snapshot is incomplete', async () => {
mockConnection.fetchToolsSnapshot.mockResolvedValue({ tools: [], complete: false });
await repository.get('server1');
expect(mockConnection.refreshToolList).toHaveBeenCalledTimes(1);
});
it('does not publish an initial snapshot superseded by a list-changed refresh', async () => {
let toolsChanged: ((tools: t.MCPTool[]) => void) | undefined;
mockConnection.on.mockImplementation((event, listener) => {
if (event === 'toolsChanged') {
toolsChanged = listener as (tools: t.MCPTool[]) => void;
}
return mockConnection;
});
let releaseInitialSnapshot:
| ((snapshot: { tools: t.MCPTool[]; complete: boolean }) => void)
| undefined;
mockConnection.fetchToolsSnapshot.mockReturnValue(
new Promise((resolve) => {
releaseInitialSnapshot = resolve;
}),
);
const handler = jest.fn().mockResolvedValue(undefined);
setMCPToolsChangedHandler(handler);
const load = repository.get('server1');
await new Promise((resolve) => setImmediate(resolve));
toolsChanged?.([{ name: 'current', inputSchema: { type: 'object' } } as t.MCPTool]);
releaseInitialSnapshot?.({
tools: [{ name: 'stale', inputSchema: { type: 'object' } } as t.MCPTool],
complete: true,
});
await load;
expect(handler).toHaveBeenCalledWith(
expect.objectContaining({ tools: [expect.objectContaining({ name: 'current' })] }),
);
expect(handler).not.toHaveBeenCalledWith(
expect.objectContaining({ tools: [expect.objectContaining({ name: 'stale' })] }),
);
});
it('publishes an empty snapshot without listing tools when the server lacks the capability', async () => {
const handler = jest.fn().mockResolvedValue(undefined);
setMCPToolsChangedHandler(handler);
(mockConnection.client.getServerCapabilities as jest.Mock).mockReturnValue({ resources: {} });
await repository.get('server1');
expect(mockConnection.fetchToolsSnapshot).not.toHaveBeenCalled();
expect(handler).toHaveBeenCalledWith(
expect.objectContaining({ serverName: 'server1', tools: [] }),
);
});
it('should create new connection if existing connection is not connected', async () => {
const oldConnection = {
isConnected: jest.fn().mockResolvedValue(false),
disconnect: jest.fn().mockResolvedValue(undefined),
dispose: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<MCPConnection>;
repository['connections'].set('server1', oldConnection);
const result = await repository.get('server1');
expect(result).toBe(mockConnection);
expect(oldConnection.dispose).toHaveBeenCalled();
expect(MCPConnectionFactory.create).toHaveBeenCalledWith(
{
serverName: 'server1',
serverConfig: mockServerConfigs.server1,
useSSRFProtection: false,
allowedDomains: null,
allowedAddresses: null,
dbSourced: false,
capabilityProfile: STANDARD_MCP_CAPABILITY_PROFILE,
},
undefined,
);
});
it('should recreate connection when existing connection is stale', async () => {
const connectionCreatedAt = Date.now();
const configCachedAt = connectionCreatedAt + 10000; // Config updated 10 seconds after connection was created
const staleConnection = {
isConnected: jest.fn().mockResolvedValue(true),
disconnect: jest.fn().mockResolvedValue(undefined),
dispose: jest.fn().mockResolvedValue(undefined),
createdAt: connectionCreatedAt,
isStale: jest.fn().mockReturnValue(true),
} as unknown as jest.Mocked<MCPConnection>;
// Update server config with updatedAt timestamp
const configWithCachedAt = {
...mockServerConfigs.server1,
updatedAt: configCachedAt,
};
mockRegistry.getServerConfig.mockResolvedValueOnce(configWithCachedAt);
repository['connections'].set('server1', staleConnection);
const result = await repository.get('server1');
// Verify stale check was called with the config's updatedAt timestamp
expect(staleConnection.isStale).toHaveBeenCalledWith(configCachedAt);
// Verify old connection was disconnected
expect(staleConnection.dispose).toHaveBeenCalled();
// Verify new connection was created
expect(MCPConnectionFactory.create).toHaveBeenCalledWith(
{
serverName: 'server1',
serverConfig: configWithCachedAt,
useSSRFProtection: false,
allowedDomains: null,
allowedAddresses: null,
dbSourced: false,
capabilityProfile: STANDARD_MCP_CAPABILITY_PROFILE,
},
undefined,
);
// Verify new connection is returned
expect(result).toBe(mockConnection);
// Verify the new connection replaced the stale one in the repository
expect(repository['connections'].get('server1')).toBe(mockConnection);
expect(repository['connections'].get('server1')).not.toBe(staleConnection);
});
it('should return existing connection when it is not stale', async () => {
const connectionCreatedAt = Date.now();
const configCachedAt = connectionCreatedAt - 10000; // Config is older than connection
const freshConnection = {
isConnected: jest.fn().mockResolvedValue(true),
disconnect: jest.fn().mockResolvedValue(undefined),
dispose: jest.fn().mockResolvedValue(undefined),
createdAt: connectionCreatedAt,
isStale: jest.fn().mockReturnValue(false),
} as unknown as jest.Mocked<MCPConnection>;
// Update server config with updatedAt timestamp
const configWithCachedAt = {
...mockServerConfigs.server1,
updatedAt: configCachedAt,
};
mockRegistry.getServerConfig.mockResolvedValueOnce(configWithCachedAt);
repository['connections'].set('server1', freshConnection);
const result = await repository.get('server1');
// Verify stale check was called
expect(freshConnection.isStale).toHaveBeenCalledWith(configCachedAt);
// Verify connection was not disconnected
expect(freshConnection.dispose).not.toHaveBeenCalled();
// Verify no new connection was created
expect(MCPConnectionFactory.create).not.toHaveBeenCalled();
// Verify existing connection is returned
expect(result).toBe(freshConnection);
// Verify repository still has the same connection
expect(repository['connections'].get('server1')).toBe(freshConnection);
});
it('uses the repository cleanup path when a loaded server config is removed', async () => {
repository['connections'].set('server1', mockConnection);
delete mockServerConfigs.server1;
await expect(repository.get('server1')).resolves.toBeNull();
expect(mockConnection.removeAllListeners).toHaveBeenCalledWith('toolsChanged');
expect(mockConnection.dispose).toHaveBeenCalled();
expect(repository['connections'].has('server1')).toBe(false);
});
it('should handle MCPConnectionFactory.create errors', async () => {
const createError = new Error('Connection creation failed');
(MCPConnectionFactory.create as jest.Mock).mockRejectedValue(createError);
await expect(repository.get('server1')).rejects.toThrow('Connection creation failed');
});
});
describe('getMany', () => {
it('should return connections for multiple servers', async () => {
const result = await repository.getMany(['server1', 'server3']);
expect(result).toBeInstanceOf(Map);
expect(result.size).toBe(2);
expect(result.get('server1')).toBe(mockConnection);
expect(result.get('server3')).toBe(mockConnection);
});
});
describe('getLoaded', () => {
it('should return connections for loaded servers only', async () => {
// Load one connection
await repository.get('server1');
const result = await repository.getLoaded();
expect(result).toBeInstanceOf(Map);
expect(result.size).toBe(1);
expect(result.get('server1')).toBe(mockConnection);
});
it('should return empty map when no connections are loaded', async () => {
const result = await repository.getLoaded();
expect(result).toBeInstanceOf(Map);
expect(result.size).toBe(0);
});
});
describe('getAll', () => {
it('should return connections for all configured servers', async () => {
const result = await repository.getAll();
expect(result).toBeInstanceOf(Map);
expect(result.size).toBe(3);
expect(result.get('server1')).toBe(mockConnection);
expect(result.get('server2')).toBe(mockConnection);
expect(result.get('server3')).toBe(mockConnection);
});
it('continues loading later servers when one connection fails', async () => {
(MCPConnectionFactory.create as jest.Mock).mockImplementation(
({ serverName }: { serverName: string }) => {
if (serverName === 'server1') {
return Promise.reject(new Error('server unavailable'));
}
return Promise.resolve(mockConnection);
},
);
const result = await repository.getAll({ continueOnError: true });
expect(result.has('server1')).toBe(false);
expect(result.get('server2')).toBe(mockConnection);
expect(result.get('server3')).toBe(mockConnection);
expect(mockLogger.warn).toHaveBeenCalledWith('[MCP] Failed to establish connection');
expect(JSON.stringify(mockLogger.warn.mock.calls)).not.toContain('server1');
expect(JSON.stringify(mockLogger.warn.mock.calls)).not.toContain('server unavailable');
});
});
describe('disconnect', () => {
it('should disconnect and remove existing connection', async () => {
repository['connections'].set('server1', mockConnection);
await repository.disconnect('server1');
expect(mockConnection.dispose).toHaveBeenCalled();
expect(repository['connections'].has('server1')).toBe(false);
});
it('should handle disconnect error gracefully', async () => {
const disconnectError = new Error('Disconnect failed');
mockConnection.dispose.mockRejectedValue(disconnectError);
repository['connections'].set('server1', mockConnection);
await repository.disconnect('server1');
expect(mockConnection.dispose).toHaveBeenCalled();
expect(repository['connections'].has('server1')).toBe(false);
expect(mockLogger.error).toHaveBeenCalledWith('[MCP] Error disposing');
expect(JSON.stringify(mockLogger.error.mock.calls)).not.toContain(disconnectError.message);
expect(JSON.stringify(mockLogger.error.mock.calls)).not.toContain('server1');
});
});
describe('disconnectAll', () => {
it('should disconnect all active connections', async () => {
const mockConnection1 = {
disconnect: jest.fn().mockResolvedValue(undefined),
dispose: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<MCPConnection>;
const mockConnection2 = {
disconnect: jest.fn().mockResolvedValue(undefined),
dispose: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<MCPConnection>;
const mockConnection3 = {
disconnect: jest.fn().mockResolvedValue(undefined),
dispose: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<MCPConnection>;
repository['connections'].set('server1', mockConnection1);
repository['connections'].set('server2', mockConnection2);
repository['connections'].set('server3', mockConnection3);
const promises = repository.disconnectAll();
expect(promises).toHaveLength(1);
expect(Array.isArray(promises)).toBe(true);
await Promise.all(promises);
expect(mockConnection1.dispose).toHaveBeenCalledTimes(1);
expect(mockConnection2.dispose).toHaveBeenCalledTimes(1);
expect(mockConnection3.dispose).toHaveBeenCalledTimes(1);
});
it('drains and disposes a connection whose creation finishes during shutdown', async () => {
let releaseCreation: ((connection: MCPConnection) => void) | undefined;
(MCPConnectionFactory.create as jest.Mock).mockReturnValue(
new Promise((resolve) => {
releaseCreation = resolve;
}),
);
const load = repository.get('server1');
await new Promise((resolve) => setImmediate(resolve));
const shutdown = Promise.all(repository.disconnectAll());
releaseCreation?.(mockConnection);
await expect(load).resolves.toBeNull();
await shutdown;
expect(mockConnection.dispose).toHaveBeenCalledTimes(1);
await expect(repository.get('server1')).resolves.toBeNull();
expect(MCPConnectionFactory.create).toHaveBeenCalledTimes(1);
});
});
describe('Connection policy (isAllowedToConnectToServer)', () => {
describe('App-level repository (ownerId = undefined)', () => {
beforeEach(() => {
repository = new ConnectionsRepository(undefined);
});
it('should allow connection to regular servers (startup !== false, !requiresOAuth)', async () => {
mockServerConfigs.regularServer = {
type: 'stdio',
command: 'test',
args: [],
startup: true,
requiresOAuth: false,
};
expect(await repository.has('regularServer')).toBe(true);
});
it('should allow connection when startup is undefined and requiresOAuth is false', async () => {
mockServerConfigs.defaultServer = {
type: 'stdio',
command: 'test',
args: [],
requiresOAuth: false,
};
expect(await repository.has('defaultServer')).toBe(true);
});
it('should NOT allow app connections to public user-managed servers', async () => {
mockServerConfigs.publicServer = {
type: 'streamable-http',
url: 'https://public.example.com/mcp',
source: 'user',
requiresOAuth: false,
};
expect(await repository.has('publicServer')).toBe(false);
});
it('should NOT allow connection to OAuth servers', async () => {
mockServerConfigs.oauthServer = {
type: 'streamable-http',
url: 'http://example.com',
requiresOAuth: true,
};
expect(await repository.has('oauthServer')).toBe(false);
});
it('should NOT allow connection to disabled servers (startup: false)', async () => {
mockServerConfigs.disabledServer = {
type: 'stdio',
command: 'test',
args: [],
startup: false,
requiresOAuth: false,
};
expect(await repository.has('disabledServer')).toBe(false);
});
it('should NOT allow connection to OAuth servers that are also disabled', async () => {
mockServerConfigs.oauthDisabledServer = {
type: 'streamable-http',
url: 'http://example.com',
startup: false,
requiresOAuth: true,
};
expect(await repository.has('oauthDisabledServer')).toBe(false);
});
it('should NOT allow connection to servers with customUserVars', async () => {
mockServerConfigs.customVarServer = {
type: 'stdio',
command: 'npx',
args: ['-y', '@test/mcp-stdio-server'],
env: { API_KEY: '{{MY_KEY}}' },
customUserVars: {
MY_KEY: { title: 'API Key', description: 'Your API key' },
},
};
expect(await repository.has('customVarServer')).toBe(false);
});
it('should NOT allow connection when customUserVars is defined, even when startup is explicitly true', async () => {
mockServerConfigs.customVarStartupServer = {
type: 'stdio',
command: 'npx',
args: ['-y', '@test/mcp-stdio-server'],
env: { TOKEN: '{{USER_TOKEN}}' },
startup: true,
requiresOAuth: false,
customUserVars: {
USER_TOKEN: { title: 'Token', description: 'Your token' },
},
};
expect(await repository.has('customVarStartupServer')).toBe(false);
});
it('should NOT allow connection to OBO servers', async () => {
mockServerConfigs.oboServer = {
type: 'streamable-http',
url: 'http://example.com',
obo: {
scopes: 'api://mcp-server-id/Mcp.Tools.ReadWrite',
},
};
expect(await repository.has('oboServer')).toBe(false);
});
it('should disconnect existing connection when server becomes not allowed', async () => {
// Initially setup as regular server
mockServerConfigs.changingServer = {
type: 'stdio',
command: 'test',
args: [],
requiresOAuth: false,
};
// Create connection
const connection = await repository.get('changingServer');
expect(connection).toBe(mockConnection);
expect(repository['connections'].has('changingServer')).toBe(true);
// Change config to require OAuth (app-level can't connect)
mockServerConfigs.changingServer = {
type: 'streamable-http',
url: 'http://example.com',
requiresOAuth: true,
};
// Check if connection is allowed
const allowed = await repository.has('changingServer');
expect(allowed).toBe(false);
expect(mockConnection.dispose).toHaveBeenCalled();
});
});
describe('User-level repository (ownerId = userId)', () => {
beforeEach(() => {
repository = new ConnectionsRepository('user123');
});
it('should allow connection to regular servers', async () => {
mockServerConfigs.regularServer = {
type: 'stdio',
command: 'test',
args: [],
startup: true,
requiresOAuth: false,
};
expect(await repository.has('regularServer')).toBe(true);
});
it('should lazily allow user connections to public user-managed servers', async () => {
mockServerConfigs.publicServer = {
type: 'streamable-http',
url: 'https://public.example.com/mcp',
source: 'user',
requiresOAuth: false,
};
expect(await repository.has('publicServer')).toBe(true);
});
it('should allow connection to OAuth servers', async () => {
mockServerConfigs.oauthServer = {
type: 'streamable-http',
url: 'http://example.com',
requiresOAuth: true,
};
expect(await repository.has('oauthServer')).toBe(true);
});
it('should allow connection to disabled servers (startup: false)', async () => {
mockServerConfigs.disabledServer = {
type: 'stdio',
command: 'test',
args: [],
startup: false,
requiresOAuth: false,
};
expect(await repository.has('disabledServer')).toBe(true);
});
it('should allow connection to OAuth servers that are also disabled', async () => {
mockServerConfigs.oauthDisabledServer = {
type: 'streamable-http',
url: 'http://example.com',
startup: false,
requiresOAuth: true,
};
expect(await repository.has('oauthDisabledServer')).toBe(true);
});
it('should allow connection to servers with customUserVars', async () => {
mockServerConfigs.customVarServer = {
type: 'stdio',
command: 'npx',
args: ['-y', '@test/mcp-stdio-server'],
env: { API_KEY: '{{MY_KEY}}' },
customUserVars: {
MY_KEY: { title: 'API Key', description: 'Your API key' },
},
};
expect(await repository.has('customVarServer')).toBe(true);
});
it('should allow connection to OBO servers', async () => {
mockServerConfigs.oboServer = {
type: 'streamable-http',
url: 'http://example.com',
obo: {
scopes: 'api://mcp-server-id/Mcp.Tools.ReadWrite',
},
};
expect(await repository.has('oboServer')).toBe(true);
});
it('should return null from get() when server config does not exist', async () => {
const connection = await repository.get('nonexistent');
expect(connection).toBeNull();
});
});
});
});