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
🗃️ refactor: Simplify MCP Server Config to Two-Repository Pattern (#10705)
Atef Bellaajda473bf43a4f
diff --git a/packages/api/package.json b/packages/api/package.jsonindex 41e6c663b3..771d16685f 100644--- a/packages/api/package.json+++ b/packages/api/package.json@@ -22,7 +22,7 @@"test:ci": "jest --coverage --ci --testPathIgnorePatterns=\"\\.*integration\\.|\\.*helper\\.\"","test:cache-integration:core": "jest --testPathPatterns=\"src/cache/.*\\.cache_integration\\.spec\\.ts$\" --coverage=false","test:cache-integration:cluster": "jest --testPathPatterns=\"src/cluster/.*\\.cache_integration\\.spec\\.ts$\" --coverage=false --runInBand",- "test:cache-integration:mcp": "jest --testPathPatterns=\"src/mcp/.*\\.cache_integration\\.spec\\.ts$\" --coverage=false --runInBand --forceExit",+ "test:cache-integration:mcp": "jest --testPathPatterns=\"src/mcp/.*\\.cache_integration\\.spec\\.ts$\" --coverage=false","test:cache-integration": "npm run test:cache-integration:core && npm run test:cache-integration:cluster && npm run test:cache-integration:mcp","verify": "npm run test:ci","b:clean": "bun run rimraf dist",diff --git a/packages/api/src/index.ts b/packages/api/src/index.tsindex 8acaa84ba8..6350247a69 100644--- a/packages/api/src/index.ts+++ b/packages/api/src/index.ts@@ -4,7 +4,6 @@ export * from './cdn';export * from './auth';/* MCP */export * from './mcp/registry/MCPServersRegistry';-export * from './mcp/registry/MCPPrivateServerLoader';export * from './mcp/MCPManager';export * from './mcp/connection';export * from './mcp/oauth';diff --git a/packages/api/src/mcp/ConnectionsRepository.ts b/packages/api/src/mcp/ConnectionsRepository.tsindex b5f8f3609c..d5f6eba6c3 100644--- a/packages/api/src/mcp/ConnectionsRepository.ts+++ b/packages/api/src/mcp/ConnectionsRepository.ts@@ -26,18 +26,20 @@ export class ConnectionsRepository {/** Checks whether this repository can connect to a specific server */async has(serverName: string): Promise<boolean> {const config = await registry.getServerConfig(serverName, this.ownerId);- if (!config) {- //if the config does not exist, clean up any potential orphaned connections (caused by server tier migration)+ const canConnect = !!config && this.isAllowedToConnectToServer(config);+ if (!canConnect) {+ //if connection is no longer possible we attempt to disconnect any leftover connectionsawait this.disconnect(serverName);}- return !!config;+ return canConnect;}/** Gets or creates a connection for the specified server with lazy loading */async get(serverName: string): Promise<MCPConnection | null> {const serverConfig = await registry.getServerConfig(serverName, this.ownerId);+const existingConnection = this.connections.get(serverName);- if (!serverConfig) {+ if (!serverConfig || !this.isAllowedToConnectToServer(serverConfig)) {if (existingConnection) {await existingConnection.disconnect();}@@ -64,7 +66,6 @@ export class ConnectionsRepository {await this.disconnect(serverName);}}-const connection = await MCPConnectionFactory.create({serverName,@@ -92,13 +93,13 @@ export class ConnectionsRepository {/** Gets or creates connections for all configured servers in this repository's scope */async getAll(): Promise<Map<string, MCPConnection>> {//TODO in the future we should use a scoped config getter (APPLevel, UserLevel, Private)- //for now the unexisting config will not throw error+ //for now the absent config will not throw errorconst allConfigs = await registry.getAllServerConfigs(this.ownerId);return this.getMany(Object.keys(allConfigs));}/** Disconnects and removes a specific server connection from the pool */- disconnect(serverName: string): Promise<void> {+ async disconnect(serverName: string): Promise<void> {const connection = this.connections.get(serverName);if (!connection) return Promise.resolve();this.connections.delete(serverName);@@ -117,4 +118,12 @@ export class ConnectionsRepository {protected prefix(serverName: string): string {return `[MCP][${serverName}]`;}++ private isAllowedToConnectToServer(config: t.ParsedServerConfig) {+ //the repository is not allowed to be connected in case the Connection repository is shared (ownerId is undefined/null) and the server requires Auth or startup false.+ if (this.ownerId === undefined && (config.startup === false || config.requiresOAuth)) {+ return false;+ }+ return true;+ }}diff --git a/packages/api/src/mcp/__tests__/ConnectionsRepository.test.ts b/packages/api/src/mcp/__tests__/ConnectionsRepository.test.tsindex 7dae35a392..3248f13daf 100644--- a/packages/api/src/mcp/__tests__/ConnectionsRepository.test.ts+++ b/packages/api/src/mcp/__tests__/ConnectionsRepository.test.ts@@ -319,4 +319,152 @@ describe('ConnectionsRepository', () => {expect(Array.isArray(promises)).toBe(true);});});++ 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 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 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.disconnect).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 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 return null from get() when server config does not exist', async () => {+ const connection = await repository.get('nonexistent');+ expect(connection).toBeNull();+ });+ });+ });});diff --git a/packages/api/src/mcp/__tests__/MCPManager.test.ts b/packages/api/src/mcp/__tests__/MCPManager.test.tsindex 20aa0d1bd9..f1452c2938 100644--- a/packages/api/src/mcp/__tests__/MCPManager.test.ts+++ b/packages/api/src/mcp/__tests__/MCPManager.test.ts@@ -19,9 +19,6 @@ jest.mock('@librechat/data-schemas', () => ({jest.mock('~/mcp/registry/MCPServersRegistry', () => ({mcpServersRegistry: {- sharedAppServers: {- getAll: jest.fn(),- },getServerConfig: jest.fn(),getAllServerConfigs: jest.fn(),getOAuthServers: jest.fn(),@@ -50,7 +47,6 @@ describe('MCPManager', () => {// Set up default mock implementations(MCPServersInitializer.initialize as jest.Mock).mockResolvedValue(undefined);- (mcpServersRegistry.sharedAppServers.getAll as jest.Mock).mockResolvedValue({});(mcpServersRegistry.getAllServerConfigs as jest.Mock).mockResolvedValue({});});diff --git a/packages/api/src/mcp/registry/MCPPrivateServerLoader.ts b/packages/api/src/mcp/registry/MCPPrivateServerLoader.tsdeleted file mode 100644index 61cd634ed4..0000000000--- a/packages/api/src/mcp/registry/MCPPrivateServerLoader.ts+++ /dev/null@@ -1,276 +0,0 @@-import { mcpServersRegistry as registry } from './MCPServersRegistry';-import { privateServersLoadStatusCache as loadStatusCache } from './cache/PrivateServersLoadStatusCache';-import type * as t from '~/mcp/types';-import { logger } from '@librechat/data-schemas';-import { MCPServerDB } from 'librechat-data-provider';--/**- * Handles loading and updating private MCP servers for users.- * Static methods work directly with the registry's privateServersCache.- * Similar pattern to MCPServersInitializer but for runtime private server management.- */-export class MCPPrivateServerLoader {- /**- * Load private servers for a specific user with TTL synchronization and distributed locking.- * Use case: User logs in, lazy-load their private servers from DB- *- * Handles three critical issues:- * 1. Partial Load Prevention: Loaded flag only set after ALL servers load successfully- * 2. TTL Synchronization: Loaded flag expires with cache entries (prevents desync)- * 3. Race Condition Prevention: Distributed locking prevents concurrent loads- *- * Edge cases handled:- * - Process crashes mid-load: Flag not set, will retry on next attempt- * - Cache eviction: TTL ensures flag expires with cache entries- * - Concurrent loads: Lock ensures only one process loads, others wait- * - Users with 0 servers: Correctly handled (no cache verification needed)- *- * @param userId - User ID- * @param configsLoader - a callback that fetches db servers available for a user- * @param cacheTTL - Cache TTL in milliseconds (default: 3600000 = 1 hour)- * @throws {Error} If userId is invalid or loading fails- */- public static async loadPrivateServers(- userId: string,- configsLoader: (userId: string) => Promise<MCPServerDB[]>,- cacheTTL: number = 3600000, // 1 hour default- ): Promise<void> {- // Input validation- if (!userId?.trim()) {- throw new Error('[MCP][PrivateServerLoader] userId is required and cannot be empty');- }- if (typeof configsLoader !== 'function') {- throw new Error('[MCP][PrivateServerLoader] configsLoader must be a function');- }-- const alreadyLoaded = await loadStatusCache.isLoaded(userId);- if (alreadyLoaded) {- logger.debug(`[MCP][PrivateServerLoader] User ${userId} private servers already loaded`);- return;- }-- const lockAcquired = await loadStatusCache.acquireLoadLock(userId);-- if (!lockAcquired) {- logger.debug(- `[MCP][PrivateServerLoader] Another process is loading user ${userId}, waiting...`,- );- const completed = await loadStatusCache.waitForLoad(userId);-- if (completed) {- logger.debug(`[MCP][PrivateServerLoader] User ${userId} loaded by another process`);- return;- } else {- // Timeout - try to acquire lock again (maybe the other process crashed)- logger.warn(- `[MCP][PrivateServerLoader] Timeout waiting for user ${userId}, retrying lock acquisition`,- );- const retryLock = await loadStatusCache.acquireLoadLock(userId);- if (!retryLock) {- throw new Error(- `[MCP][PrivateServerLoader] Failed to acquire load lock for user ${userId}`,- );- }- }- }-- // We have the lock, proceed with loading- try {- logger.info(`[MCP][PrivateServerLoader] Loading private servers for user ${userId}`);- const servers = await configsLoader(userId);- //reset cache for the user- await registry.privateServersCache.reset(userId);-- for (const server of servers) {- const serverName = server.mcp_id;- const existing = await registry.privateServersCache.get(userId, serverName);- if (!existing) {- // Add new server config- await registry.privateServersCache.add(userId, serverName, {- ...server.config,- dbId: server._id,- });- logger.debug(`${this.prefix(serverName)} Added private server for user ${userId}`);- } else {- logger.debug(- `${this.prefix(serverName)} Private server already exists for user ${userId}`,- );- }- }-- // Mark as fully loaded with TTL (synchronized with cache entries)- await loadStatusCache.setLoaded(userId, cacheTTL);- logger.debug(- `[MCP][PrivateServerLoader] User ${userId} private servers fully loaded (${servers.length} servers, TTL: ${cacheTTL}ms)`,- );- } catch (error) {- logger.error(- `[MCP][PrivateServerLoader] Loading private servers for user ${userId} failed.`,- error,- );- throw error;- } finally {- // Always release the lock, even on error- await loadStatusCache.releaseLoadLock(userId);- }- }-- /**- * Propagate metadata changes to all users who have this server or update shared cache if the server is shared with PUBLIC.- * Use case: Admin updates server url, auth etc..- * Efficient: Uses pattern-based scan, updates only affected users- *- * @param serverName - Server name- * @param config - Updated server configuration- */- public static async updatePrivateServer(- serverName: string,- config: t.ParsedServerConfig,- ): Promise<void> {- //check if the private server is promoted to a app level or user shared level server- const sharedServer = await registry.getServerConfig(serverName);- if (sharedServer) {- logger.info(`${this.prefix(serverName)} Promoted private server update`);- // server must be removed to simplify moving from App -> Shared and Shared -> App based on the config.- // Otherwise we need to figure out if it is an APP or a User shared and whether to migrate or not.-- await registry.removeServer(serverName);- await registry.addSharedServer(serverName, config);- return;- }- logger.info(`${this.prefix(serverName)} Propagating metadata update to all users`);- await registry.privateServersCache.updateServerConfigIfExists(serverName, config);- }-- /**- * Add a private server- * Use case: Admin / user creates an mcp server from the UI- *- * @param userId - userId- * @param serverName - Server name- * @param config - Updated server configuration- */- public static async addPrivateServer(- userId: string,- serverName: string,- config: t.ParsedServerConfig,- ): Promise<void> {- logger.info(`${this.prefix(serverName)} add private server to user with Id ${userId}`);- await registry.privateServersCache.add(userId, serverName, config);- }-- /**- * Handle permission changes - grant/revoke access.- * Use case: Admin shares/unshares server with users- *- * @param serverName - Server name- * @param allowedUserIds - Array of user IDs who should have access- * @param config - Server configuration- */- public static async updatePrivateServerAccess(- serverName: string,- allowedUserIds: string[],- config: t.ParsedServerConfig,- ): Promise<void> {- if (allowedUserIds.length === 0) {- // Revoke from everyone- logger.info(`${this.prefix(serverName)} Revoking access from all users`);- const allUsers = await registry.privateServersCache.findUsersWithServer(serverName);- await registry.privateServersCache.removeServerConfigIfCacheExists(allUsers, serverName);- return;- }-- logger.info(`${this.prefix(serverName)} Updating access for ${allowedUserIds.length} users`);-- // Find current state- const currentUsers = await registry.privateServersCache.findUsersWithServer(serverName);- const allowedSet = new Set(allowedUserIds);-- // Revoke from users no longer allowed- const toRevoke = currentUsers.filter((id) => !allowedSet.has(id));- if (toRevoke.length > 0) {- logger.debug(`${this.prefix(serverName)} Revoking access from ${toRevoke.length} users`);- await registry.privateServersCache.removeServerConfigIfCacheExists(toRevoke, serverName);- }-- // Grant to allowed users (only initialized caches)- logger.debug(`${this.prefix(serverName)} Granting access to ${allowedUserIds.length} users`);- await registry.privateServersCache.addServerConfigIfCacheExists(- allowedUserIds,- serverName,- config,- );- }-- /**- * Promote a private server to shared (public) registry.- * Use case: Admin shares a private server with PUBLIC- *- * Migrates server from private user caches to shared registry (app or user tier).- * Removes from all private caches to avoid duplication.- *- * @param serverName - Server name- * @param config - Server configuration- */- public static async promoteToSharedServer(- serverName: string,- config: t.ParsedServerConfig,- ): Promise<void> {- logger.info(`${this.prefix(serverName)} Promoting to shared server`);-- // 1. Add to shared registry (app or user tier based on config)- await registry.addSharedServer(serverName, config);-- // 2. Remove from all private user caches- const affectedUsers = await registry.privateServersCache.findUsersWithServer(serverName);- if (affectedUsers.length > 0) {- logger.debug(- `${this.prefix(serverName)} Removing from ${affectedUsers.length} private user caches`,- );- await registry.privateServersCache.removeServerConfigIfCacheExists(affectedUsers, serverName);- }-- logger.info(`${this.prefix(serverName)} Successfully promoted to shared server`);- }-- /**- * Demote a shared server to private registry.- * Use case: Admin un-shares a server from PUBLIC- *- * Removes server from shared registry and adds to specified users' private caches.- * Only adds to users with initialized caches.- *- * @param serverName - Server name- * @param allowedUserIds - Array of user IDs who should have private access- * @param config - Server configuration- */- public static async demoteToPrivateServer(- serverName: string,- allowedUserIds: string[],- config: t.ParsedServerConfig,- ): Promise<void> {- logger.info(`${this.prefix(serverName)} Demoting to private server`);-- // 1. Remove from shared registries- await registry.removeServer(serverName);-- // 2. Add to private caches for allowed users (only if caches exist)- if (allowedUserIds.length > 0) {- logger.debug(- `${this.prefix(serverName)} Adding to ${allowedUserIds.length} users' private caches`,- );- await registry.privateServersCache.addServerConfigIfCacheExists(- allowedUserIds,- serverName,- config,- );- }-- logger.info(`${this.prefix(serverName)} Successfully demoted to private server`);- }-- // Returns formatted log prefix for server messages- private static prefix(serverName: string): string {- return `[MCP][PrivateServer][${serverName}]`;- }-}diff --git a/packages/api/src/mcp/registry/MCPServersInitializer.ts b/packages/api/src/mcp/registry/MCPServersInitializer.tsindex e23cfd1ea9..5265a11d70 100644--- a/packages/api/src/mcp/registry/MCPServersInitializer.ts+++ b/packages/api/src/mcp/registry/MCPServersInitializer.ts@@ -2,7 +2,6 @@ import { registryStatusCache as statusCache } from './cache/RegistryStatusCache'import { isLeader } from '~/cluster';import { withTimeout } from '~/utils';import { logger } from '@librechat/data-schemas';-import { MCPServerInspector } from './MCPServerInspector';import { ParsedServerConfig } from '~/mcp/types';import { sanitizeUrlForLogging } from '~/mcp/utils';import type * as t from '~/mcp/types';@@ -60,9 +59,7 @@ export class MCPServersInitializer {/** Initializes a single server with all its metadata and adds it to appropriate collections */public static async initializeServer(serverName: string, rawConfig: t.MCPOptions): Promise<void> {try {- const config = await MCPServerInspector.inspect(serverName, rawConfig);-- await registry.addSharedServer(serverName, config);+ const config = await registry.addServer(serverName, rawConfig, 'CACHE');MCPServersInitializer.logParsedConfig(serverName, config);} catch (error) {logger.error(`${MCPServersInitializer.prefix(serverName)} Failed to initialize:`, error);diff --git a/packages/api/src/mcp/registry/MCPServersRegistry.ts b/packages/api/src/mcp/registry/MCPServersRegistry.tsindex a9b3681c66..b99d4423c2 100644--- a/packages/api/src/mcp/registry/MCPServersRegistry.ts+++ b/packages/api/src/mcp/registry/MCPServersRegistry.ts@@ -1,81 +1,69 @@import type * as t from '~/mcp/types';-import {- ServerConfigsCacheFactory,- type ServerConfigsCache,-} from './cache/ServerConfigsCacheFactory';-import {- PrivateServerConfigsCache,- PrivateServerConfigsCacheFactory,-} from './cache/PrivateServerConfigs/PrivateServerConfigsCacheFactory';+import { ServerConfigsCacheFactory } from './cache/ServerConfigsCacheFactory';+import { MCPServerInspector } from './MCPServerInspector';+import { ServerConfigsDB } from './db/ServerConfigsDB';+import { IServerConfigsRepositoryInterface } from './ServerConfigsRepositoryInterface';/**- * Central registry for managing MCP server configurations across different scopes and users.+ * Central registry for managing MCP server configurations.* Authoritative source of truth for all MCP servers provided by LibreChat.*- * Maintains three-tier cache structure:- * - Shared App Servers: Auto-started servers available to all users (initialized at startup)- * - Shared User Servers: User-scope servers that require OAuth or on-demand startup- * - Private Servers: Per-user configurations dynamically added during runtime+ * Uses a two-repository architecture:+ * - Cache Repository: Stores YAML-defined configs loaded at startup (in-memory or Redis-backed)+ * - DB Repository: Stores dynamic configs created at runtime (not yet implemented)*- * Provides a unified query interface with proper fallback hierarchy:- * checks shared app servers first, then shared user servers, then private user servers.+ * Query priority: Cache configs are checked first, then DB configs.*/class MCPServersRegistry {- public readonly sharedAppServers: ServerConfigsCache = ServerConfigsCacheFactory.create(- 'App',- 'Shared',- false,- );+ private readonly dbConfigsRepo: IServerConfigsRepositoryInterface;+ private readonly cacheConfigsRepo: IServerConfigsRepositoryInterface;- public readonly sharedUserServers: ServerConfigsCache = ServerConfigsCacheFactory.create(- 'User',- 'Shared',- false,- );-- public readonly privateServersCache: PrivateServerConfigsCache =- PrivateServerConfigsCacheFactory.create();-- private rawConfigs: t.MCPServers = {};+ constructor() {+ this.dbConfigsRepo = new ServerConfigsDB();+ this.cacheConfigsRepo = ServerConfigsCacheFactory.create('App', false);+ }public async getServerConfig(serverName: string,userId?: string,): Promise<t.ParsedServerConfig | undefined> {- const sharedAppServer = await this.sharedAppServers.get(serverName);- if (sharedAppServer) return sharedAppServer;-- if (userId) {- //we require user id to also access sharedServers to ensure that getServerConfig(serverName, undefined) returns only app level configs.- const sharedUserServer = await this.sharedUserServers.get(serverName);- if (sharedUserServer) return sharedUserServer;-- const privateUserServer = await this.privateServersCache.get(userId, serverName);- if (privateUserServer) return privateUserServer;- }-+ // First we check if any config exist with the cache+ // Yaml config are pre loaded to the cache+ const configFromCache = await this.cacheConfigsRepo.get(serverName);+ if (configFromCache) return configFromCache;+ const configFromDB = await this.dbConfigsRepo.get(serverName, userId);+ if (configFromDB) return configFromDB;return undefined;}public async getAllServerConfigs(userId?: string): Promise<Record<string, t.ParsedServerConfig>> {- const privateConfigs = userId ? await this.privateServersCache.getAll(userId) : {};- const registryConfigs = {- ...(await this.sharedAppServers.getAll()),- ...(await this.sharedUserServers.getAll()),- ...privateConfigs,+ return {+ ...(await this.cacheConfigsRepo.getAll()),+ ...(await this.dbConfigsRepo.getAll(userId)),};- /** Include all raw configs, but registry configs take precedence (they have inspection data) */- const allConfigs: Record<string, t.ParsedServerConfig> = {};- for (const serverName in this.rawConfigs) {- allConfigs[serverName] = this.rawConfigs[serverName] as t.ParsedServerConfig;- }+ }- /** Override with registry configs where available (they have richer data) */- for (const serverName in registryConfigs) {- allConfigs[serverName] = registryConfigs[serverName];- }+ public async addServer(+ serverName: string,+ config: t.MCPOptions,+ storageLocation: 'CACHE' | 'DB',+ userId?: string,+ ): Promise<t.ParsedServerConfig> {+ const configRepo = this.getConfigRepository(storageLocation);+ const parsedConfig = await MCPServerInspector.inspect(serverName, config);+ await configRepo.add(serverName, parsedConfig, userId);+ return parsedConfig;+ }- return allConfigs;+ public async updateServer(+ serverName: string,+ config: t.MCPOptions,+ storageLocation: 'CACHE' | 'DB',+ userId?: string,+ ): Promise<void> {+ const configRepo = this.getConfigRepository(storageLocation);+ const parsedConfig = await MCPServerInspector.inspect(serverName, config);+ await configRepo.update(serverName, parsedConfig, userId);}// TODO: This is currently used to determine if a server requires OAuth. However, this info can@@ -86,57 +74,30 @@ class MCPServersRegistry {return new Set(oauthServers.map(([name]) => name));}- /**- * Add a shared server configuration.- * Automatically routes to appropriate cache (app vs user) based on config properties.- * - Servers requiring OAuth or with startup=false → sharedUserServers- * - All other servers → sharedAppServers- *- * @param serverName - Name of the MCP server- * @param config - Parsed server configuration- */- public async addSharedServer(serverName: string, config: t.ParsedServerConfig): Promise<void> {- if (config.requiresOAuth || config.startup === false) {- await this.sharedUserServers.add(serverName, config);- } else {- await this.sharedAppServers.add(serverName, config);- }- }-public async reset(): Promise<void> {- await this.sharedAppServers.reset();- await this.sharedUserServers.reset();- await this.privateServersCache.resetAll();+ await this.cacheConfigsRepo.reset();}- public async removeServer(serverName: string, userId?: string): Promise<void> {- const appServer = await this.sharedAppServers.get(serverName);- if (appServer) {- await this.sharedAppServers.remove(serverName);- return;- }-- const userServer = await this.sharedUserServers.get(serverName);- if (userServer) {- await this.sharedUserServers.remove(serverName);- return;- }+ public async removeServer(+ serverName: string,+ storageLocation: 'CACHE' | 'DB',+ userId?: string,+ ): Promise<void> {+ const configRepo = this.getConfigRepository(storageLocation);+ await configRepo.remove(serverName, userId);+ }- if (userId) {- const privateServer = await this.privateServersCache.get(userId, serverName);- if (privateServer) {- await this.privateServersCache.remove(userId, serverName);- return;- }- } else {- const affectedUsers = await this.privateServersCache.findUsersWithServer(serverName);- if (affectedUsers.length > 0) {- await this.privateServersCache.removeServerConfigIfCacheExists(affectedUsers, serverName);- return;- }+ private getConfigRepository(storageLocation: 'CACHE' | 'DB'): IServerConfigsRepositoryInterface {+ switch (storageLocation) {+ case 'CACHE':+ return this.cacheConfigsRepo;+ case 'DB':+ return this.dbConfigsRepo;+ default:+ throw new Error(+ `MCPServersRegistry: The provided storage location "${storageLocation}" is not supported`,+ );}-- throw new Error(`Server ${serverName} not found`);}}diff --git a/packages/api/src/mcp/registry/ServerConfigsRepositoryInterface.ts b/packages/api/src/mcp/registry/ServerConfigsRepositoryInterface.tsnew file mode 100644index 0000000000..9f8b2e25fe--- /dev/null+++ b/packages/api/src/mcp/registry/ServerConfigsRepositoryInterface.ts@@ -0,0 +1,22 @@+import { ParsedServerConfig } from '~/mcp/types';++/**+ * Interface for future DB implementation+ */+export interface IServerConfigsRepositoryInterface {+ add(serverName: string, config: ParsedServerConfig, userId?: string): Promise<void>;++ //ACL Entry check if update is possible+ update(serverName: string, config: ParsedServerConfig, userId?: string): Promise<void>;++ //ACL Entry check if remove is possible+ remove(serverName: string, userId?: string): Promise<void>;++ //ACL Entry check if read is possible+ get(serverName: string, userId?: string): Promise<ParsedServerConfig | undefined>;++ //ACL Entry get all accessible mcp config definitions + any mcp configured with agents+ getAll(userId?: string): Promise<Record<string, ParsedServerConfig>>;++ reset(): Promise<void>;+}diff --git a/packages/api/src/mcp/registry/__tests__/MCPPrivateServerLoader.cache_integration.spec.ts b/packages/api/src/mcp/registry/__tests__/MCPPrivateServerLoader.cache_integration.spec.tsdeleted file mode 100644index c50b613e9f..0000000000--- a/packages/api/src/mcp/registry/__tests__/MCPPrivateServerLoader.cache_integration.spec.ts+++ /dev/null@@ -1,593 +0,0 @@-import type * as t from '~/mcp/types';-import type { MCPServerDB } from 'librechat-data-provider';--describe('MCPPrivateServerLoader Cache Integration Tests', () => {- let keyvRedisClient: Awaited<typeof import('~/cache/redisClients')>['keyvRedisClient'];- let registry: typeof import('../MCPServersRegistry').mcpServersRegistry;- let MCPPrivateServerLoader: typeof import('../MCPPrivateServerLoader').MCPPrivateServerLoader;- let loadStatusCache: typeof import('../cache/PrivateServersLoadStatusCache').privateServersLoadStatusCache;- const mockConfig1: t.ParsedServerConfig = {- command: 'node',- args: ['server1.js'],- env: { TEST: 'value1' },- };-- const mockConfig2: t.ParsedServerConfig = {- command: 'python',- args: ['server2.py'],- env: { TEST: 'value2' },- };-- const mockConfig3: t.ParsedServerConfig = {- url: 'http://localhost:3000',- requiresOAuth: true,- };-- const mockUpdatedConfig: t.ParsedServerConfig = {- command: 'node',- args: ['server1-updated.js'],- env: { TEST: 'updated', NEW_VAR: 'added' },- };- beforeAll(async () => {- jest.resetModules();- // Set up environment variables for Redis (only if not already set)- process.env.USE_REDIS = process.env.USE_REDIS ?? 'true';- process.env.USE_REDIS_CLUSTER = process.env.USE_REDIS_CLUSTER ?? 'true';- process.env.REDIS_URI = process.env.REDIS_URI ?? 'redis://127.0.0.1:6379';- process.env.REDIS_KEY_PREFIX =- process.env.REDIS_KEY_PREFIX ?? `MCPPrivateServerLoader-integration-test`;-- // Import modules after setting env vars- const registryModule = await import('../MCPServersRegistry');- const redisClients = await import('~/cache/redisClients');- const MCPPrivateServerLoaderModule = await import('../MCPPrivateServerLoader');- const loadStatusCacheLoaderModule = await import('../cache/PrivateServersLoadStatusCache');-- loadStatusCache = loadStatusCacheLoaderModule.privateServersLoadStatusCache;- MCPPrivateServerLoader = MCPPrivateServerLoaderModule.MCPPrivateServerLoader;- registry = registryModule.mcpServersRegistry;- keyvRedisClient = redisClients.keyvRedisClient;-- if (!keyvRedisClient) throw new Error('Redis client is not initialized');-- await redisClients.keyvRedisClientReady;- });-- beforeEach(async () => {- // Clear load status for commonly used test users- // This ensures each test starts with a clean state- const testUsers = ['user1', 'user2', 'user3', 'user4', 'user5', 'user99'];- for (const userId of testUsers) {- try {- await loadStatusCache.clearLoaded(userId);- } catch {- // Ignore errors (user may not have load status set)- }- }- });-- afterEach(async () => {- // Restore all mocks after each test- if (keyvRedisClient && 'scanIterator' in keyvRedisClient) {- const pattern = '*MCPPrivateServerLoader-integration-test*';- const keysToDelete: string[] = [];-- // Collect all keys first- for await (const key of keyvRedisClient.scanIterator({ MATCH: pattern })) {- keysToDelete.push(key);- }-- // Delete in parallel for cluster mode efficiency- if (keysToDelete.length > 0) {- await Promise.all(keysToDelete.map((key) => keyvRedisClient!.del(key)));- }- }- jest.restoreAllMocks();- });-- afterAll(async () => {- if (keyvRedisClient?.isOpen) await keyvRedisClient.disconnect();- });-- describe('loadPrivateServers() integration', () => {- it('should load private servers from configsLoader and cache them', async () => {- const mockConfigs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- {- _id: 'mock-id-2',- mcp_id: 'server2',- config: mockConfig2,- },- ];-- const configsLoader = jest.fn().mockResolvedValue(mockConfigs);-- await MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader);-- // Verify servers were cached- const server1 = await registry.privateServersCache.get('user1', 'server1');- const server2 = await registry.privateServersCache.get('user1', 'server2');-- expect(server1).toMatchObject(mockConfig1);- expect(server2).toMatchObject(mockConfig2);- expect(configsLoader).toHaveBeenCalledWith('user1');- });-- it('should not reload servers if already cached for user', async () => {- const mockConfigs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- ];-- const configsLoader = jest.fn().mockResolvedValue(mockConfigs);-- // First load- await MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader);- expect(configsLoader).toHaveBeenCalledTimes(1);-- // Second load should skip- await MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader);- expect(configsLoader).toHaveBeenCalledTimes(1); // Still 1, not called again- });-- it('should isolate servers between different users', async () => {- const user1Configs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- ];-- const user2Configs: MCPServerDB[] = [- {- _id: 'mock-id-2',- mcp_id: 'server2',- config: mockConfig2,- },- ];-- const user1Loader = jest.fn().mockResolvedValue(user1Configs);- const user2Loader = jest.fn().mockResolvedValue(user2Configs);-- await MCPPrivateServerLoader.loadPrivateServers('user1', user1Loader);- await MCPPrivateServerLoader.loadPrivateServers('user2', user2Loader);-- // Verify isolation- const user1Server1 = await registry.privateServersCache.get('user1', 'server1');- const user1Server2 = await registry.privateServersCache.get('user1', 'server2');- const user2Server1 = await registry.privateServersCache.get('user2', 'server1');- const user2Server2 = await registry.privateServersCache.get('user2', 'server2');-- expect(user1Server1).toMatchObject(mockConfig1);- expect(user1Server2).toBeUndefined();- expect(user2Server1).toBeUndefined();- expect(user2Server2).toMatchObject(mockConfig2);- });-- it('should handle partial failures gracefully', async () => {- const mockConfigs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- {- _id: 'mock-id-2',- mcp_id: 'server2',- config: mockConfig2,- },- ];-- // Mock to fail on second server- let callCount = 0;- jest- .spyOn(registry.privateServersCache, 'add')- .mockImplementation(async (userId, serverName, config) => {- callCount++;- if (callCount === 2) {- throw new Error('Cache write failed for server2');- }- // Call the real implementation for other calls- // eslint-disable-next-line @typescript-eslint/no-explicit-any- const cache = (registry.privateServersCache as any).getOrCreatePrivateUserCache(userId);- return cache.add(serverName, config);- });-- const configsLoader = jest.fn().mockResolvedValue(mockConfigs);-- await expect(- MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader),- ).rejects.toThrow('Cache write failed for server2');-- // Verify first server was added before failure- const server1 = await registry.privateServersCache.get('user1', 'server1');- expect(server1).toMatchObject(mockConfig1);-- jest.restoreAllMocks();- });-- it('should reset cache before loading, removing old servers no longer in configs', async () => {- // Initial load with server1 and server2- const initialConfigs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- {- _id: 'mock-id-2',- mcp_id: 'server2',- config: mockConfig2,- },- ];-- const initialLoader = jest.fn().mockResolvedValue(initialConfigs);- await MCPPrivateServerLoader.loadPrivateServers('user1', initialLoader);-- // Verify both servers are cached- expect(await registry.privateServersCache.get('user1', 'server1')).toBeDefined();- expect(await registry.privateServersCache.get('user1', 'server2')).toBeDefined();-- // Clear load status to force reload- await loadStatusCache.clearLoaded('user1');-- // Second load with only server1 and a new server3- const updatedConfigs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- {- _id: 'mock-id-3',- mcp_id: 'server3',- config: mockConfig3,- },- ];-- const updatedLoader = jest.fn().mockResolvedValue(updatedConfigs);- await MCPPrivateServerLoader.loadPrivateServers('user1', updatedLoader);-- // Verify server2 is removed (cache was reset)- expect(await registry.privateServersCache.get('user1', 'server1')).toBeDefined();- expect(await registry.privateServersCache.get('user1', 'server2')).toBeUndefined();- expect(await registry.privateServersCache.get('user1', 'server3')).toBeDefined();- });- });-- describe('updatePrivateServer() integration', () => {- beforeEach(async () => {- // Setup: Load same server for multiple users- const configs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- ];- const loader = jest.fn().mockResolvedValue(configs);-- await MCPPrivateServerLoader.loadPrivateServers('user1', loader);- await MCPPrivateServerLoader.loadPrivateServers('user2', loader);- await MCPPrivateServerLoader.loadPrivateServers('user3', loader);- });-- it('should update server config for all users who have it', async () => {- await MCPPrivateServerLoader.updatePrivateServer('server1', mockUpdatedConfig);-- // Verify all users got the update- const user1Server = await registry.privateServersCache.get('user1', 'server1');- const user2Server = await registry.privateServersCache.get('user2', 'server1');- const user3Server = await registry.privateServersCache.get('user3', 'server1');-- expect(user1Server).toMatchObject({- command: 'node',- args: ['server1-updated.js'],- env: { TEST: 'updated', NEW_VAR: 'added' },- });- expect(user2Server).toMatchObject(user1Server!);- expect(user3Server).toMatchObject(user1Server!);- });-- it('should not affect other servers', async () => {- // Add another server to user1- await registry.privateServersCache.add('user1', 'server2', mockConfig2);-- await MCPPrivateServerLoader.updatePrivateServer('server1', mockUpdatedConfig);-- // Verify server2 unchanged- const server2 = await registry.privateServersCache.get('user1', 'server2');- expect(server2).toMatchObject(mockConfig2);- });-- it('should handle updating non-existent server gracefully', async () => {- await expect(- MCPPrivateServerLoader.updatePrivateServer('non-existent-server', mockUpdatedConfig),- ).resolves.not.toThrow();- });-- it('should handle promoted server by updating shared registry instead of private caches', async () => {- // First add server to shared registry (simulating promotion)- await registry.addSharedServer('promoted-server', mockConfig1);-- // Verify it's in shared registry- const sharedConfig = await registry.getServerConfig('promoted-server');- expect(sharedConfig).toBeDefined();-- // Now update it - should go through the promoted server path- await MCPPrivateServerLoader.updatePrivateServer('promoted-server', mockUpdatedConfig);-- // Verify the shared registry was updated with new config- const updatedSharedConfig = await registry.getServerConfig('promoted-server');- expect(updatedSharedConfig).toMatchObject(- expect.objectContaining({- command: 'node',- args: ['server1-updated.js'],- env: { TEST: 'updated', NEW_VAR: 'added' },- }),- );-- // Verify users' private caches were NOT updated (no users had it privately)- expect(await registry.privateServersCache.get('user1', 'promoted-server')).toBeUndefined();- expect(await registry.privateServersCache.get('user2', 'promoted-server')).toBeUndefined();- expect(await registry.privateServersCache.get('user3', 'promoted-server')).toBeUndefined();- });-- it('should handle promoted server update when users had it privately before promotion', async () => {- // Setup: Users have server1 in private caches- const configs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- ];- const loader = jest.fn().mockResolvedValue(configs);-- await MCPPrivateServerLoader.loadPrivateServers('user1', loader);- await MCPPrivateServerLoader.loadPrivateServers('user2', loader);-- // Verify they have it privately- expect(await registry.privateServersCache.get('user1', 'server1')).toBeDefined();- expect(await registry.privateServersCache.get('user2', 'server1')).toBeDefined();-- await MCPPrivateServerLoader.promoteToSharedServer('server1', mockConfig1);- // Verify it's now in shared registry and removed from private caches- expect(await registry.getServerConfig('server1')).toBeDefined();- expect(await registry.privateServersCache.get('user1', 'server1')).toBeUndefined();- expect(await registry.privateServersCache.get('user2', 'server1')).toBeUndefined();-- // Now update it - should update shared registry- await MCPPrivateServerLoader.updatePrivateServer('server1', mockUpdatedConfig);-- // Verify shared registry was updated- const updatedSharedConfig = await registry.getServerConfig('server1');- expect(updatedSharedConfig).toMatchObject(- expect.objectContaining({- command: 'node',- args: ['server1-updated.js'],- }),- );- });- });-- describe('updatePrivateServerAccess() integration', () => {- beforeEach(async () => {- // Setup: Load server for user1, user2, user3- const configs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- ];- const loader = jest.fn().mockResolvedValue(configs);-- await MCPPrivateServerLoader.loadPrivateServers('user1', loader);- await MCPPrivateServerLoader.loadPrivateServers('user2', loader);- await MCPPrivateServerLoader.loadPrivateServers('user3', loader);-- // Also initialize cache for user4 and user5 but without server1- await registry.privateServersCache.add('user4', 'other-server', mockConfig2);- await registry.privateServersCache.add('user5', 'other-server', mockConfig2);- });-- it('should revoke access from all users when allowedUserIds is empty', async () => {- await MCPPrivateServerLoader.updatePrivateServerAccess('server1', [], mockConfig1);-- // Verify all users lost access- expect(await registry.privateServersCache.get('user1', 'server1')).toBeUndefined();- expect(await registry.privateServersCache.get('user2', 'server1')).toBeUndefined();- expect(await registry.privateServersCache.get('user3', 'server1')).toBeUndefined();- });-- it('should grant access to new users with initialized caches', async () => {- const allowedUserIds = ['user1', 'user4', 'user5'];-- await MCPPrivateServerLoader.updatePrivateServerAccess(- 'server1',- allowedUserIds,- mockConfig1,- );-- // user1 should still have it- expect(await registry.privateServersCache.get('user1', 'server1')).toBeDefined();-- // user4 and user5 should now have it (they had initialized caches)- expect(await registry.privateServersCache.get('user4', 'server1')).toBeDefined();- expect(await registry.privateServersCache.get('user5', 'server1')).toBeDefined();-- // user2 and user3 should have lost access- expect(await registry.privateServersCache.get('user2', 'server1')).toBeUndefined();- expect(await registry.privateServersCache.get('user3', 'server1')).toBeUndefined();- });-- it('should not grant access to users without initialized caches', async () => {- const allowedUserIds = ['user1', 'user99']; // user99 has no cache-- await MCPPrivateServerLoader.updatePrivateServerAccess(- 'server1',- allowedUserIds,- mockConfig1,- );-- // user1 should still have it- expect(await registry.privateServersCache.get('user1', 'server1')).toBeDefined();-- // user99 should not have it (cache not initialized)- expect(await registry.privateServersCache.get('user99', 'server1')).toBeUndefined();- });-- it('should handle complex permission changes', async () => {- // Start: user1, user2, user3 have server1- // End: user2, user4, user5 should have server1-- const allowedUserIds = ['user2', 'user4', 'user5'];-- await MCPPrivateServerLoader.updatePrivateServerAccess(- 'server1',- allowedUserIds,- mockConfig1,- );-- // Revoked: user1, user3- expect(await registry.privateServersCache.get('user1', 'server1')).toBeUndefined();- expect(await registry.privateServersCache.get('user3', 'server1')).toBeUndefined();-- // Kept: user2- expect(await registry.privateServersCache.get('user2', 'server1')).toBeDefined();-- // Granted: user4, user5- expect(await registry.privateServersCache.get('user4', 'server1')).toBeDefined();- expect(await registry.privateServersCache.get('user5', 'server1')).toBeDefined();- });-- it('should be idempotent when called with same permissions', async () => {- const allowedUserIds = ['user1', 'user2'];-- // First call- await MCPPrivateServerLoader.updatePrivateServerAccess(- 'server1',- allowedUserIds,- mockConfig1,- );-- // eslint-disable-next-line @typescript-eslint/no-unused-vars- const { lastUpdatedAt: _1, ...user1ServerAfterFirst } =- (await registry.privateServersCache.get('user1', 'server1')) || {};- // eslint-disable-next-line @typescript-eslint/no-unused-vars- const { lastUpdatedAt: _2, ...user2ServerAfterFirst } =- (await registry.privateServersCache.get('user2', 'server1')) || {};- // Second call with same permissions- await MCPPrivateServerLoader.updatePrivateServerAccess(- 'server1',- allowedUserIds,- mockConfig1,- );-- // eslint-disable-next-line @typescript-eslint/no-unused-vars- const { lastUpdatedAt: _3, ...user1ServerAfterSecond } =- (await registry.privateServersCache.get('user1', 'server1')) || {};- // eslint-disable-next-line @typescript-eslint/no-unused-vars- const { lastUpdatedAt: _4, ...user2ServerAfterSecond } =- (await registry.privateServersCache.get('user2', 'server1')) || {};-- // Should be unchanged- expect(user1ServerAfterSecond).toMatchObject(user1ServerAfterFirst!);- expect(user2ServerAfterSecond).toMatchObject(user2ServerAfterFirst!);- });- });-- describe('Combined operations integration', () => {- it('should handle load, update metadata, and update access in sequence', async () => {- // 1. Load servers for user1 and user2- const configs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- ];- const loader = jest.fn().mockResolvedValue(configs);-- await MCPPrivateServerLoader.loadPrivateServers('user1', loader);- await MCPPrivateServerLoader.loadPrivateServers('user2', loader);-- // Verify initial state- let user1Server = await registry.privateServersCache.get('user1', 'server1');- let user2Server = await registry.privateServersCache.get('user2', 'server1');- expect((user1Server as typeof mockConfig1)?.args).toEqual(['server1.js']);- expect((user2Server as typeof mockConfig1)?.args).toEqual(['server1.js']);-- // 2. Update metadata for all users- await MCPPrivateServerLoader.updatePrivateServer('server1', mockUpdatedConfig);-- user1Server = await registry.privateServersCache.get('user1', 'server1');- user2Server = await registry.privateServersCache.get('user2', 'server1');-- expect((user1Server as typeof mockUpdatedConfig)?.args).toEqual(['server1-updated.js']);- expect((user2Server as typeof mockUpdatedConfig)?.args).toEqual(['server1-updated.js']);-- // 3. Update access - revoke from user1- await MCPPrivateServerLoader.updatePrivateServerAccess('server1', ['user2'], mockConfig3);-- user1Server = await registry.privateServersCache.get('user1', 'server1');- user2Server = await registry.privateServersCache.get('user2', 'server1');-- expect(user1Server).toBeUndefined();- expect(user2Server).toBeDefined();- });-- it('should handle concurrent user logins correctly', async () => {- const user1Configs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- ];- const user2Configs: MCPServerDB[] = [- {- _id: 'mock-id-2',- mcp_id: 'server1',- config: mockConfig2,- },- ];- const user3Configs: MCPServerDB[] = [- {- _id: 'mock-id-3',- mcp_id: 'server2',- config: mockConfig3,- },- ];-- const user1Loader = jest.fn().mockResolvedValue(user1Configs);- const user2Loader = jest.fn().mockResolvedValue(user2Configs);- const user3Loader = jest.fn().mockResolvedValue(user3Configs);-- // Simulate concurrent loads- await Promise.all([- MCPPrivateServerLoader.loadPrivateServers('user1', user1Loader),- MCPPrivateServerLoader.loadPrivateServers('user2', user2Loader),- MCPPrivateServerLoader.loadPrivateServers('user3', user3Loader),- ]);-- // Verify all users got their configs- const user1Server1 = await registry.privateServersCache.get('user1', 'server1');- const user2Server1 = await registry.privateServersCache.get('user2', 'server1');- const user3Server2 = await registry.privateServersCache.get('user3', 'server2');-- expect(user1Server1).toMatchObject(mockConfig1);- expect(user2Server1).toMatchObject(mockConfig2);- expect(user3Server2).toMatchObject(mockConfig3);- });- });-});diff --git a/packages/api/src/mcp/registry/__tests__/MCPPrivateServerLoader.test.ts b/packages/api/src/mcp/registry/__tests__/MCPPrivateServerLoader.test.tsdeleted file mode 100644index 59435daf07..0000000000--- a/packages/api/src/mcp/registry/__tests__/MCPPrivateServerLoader.test.ts+++ /dev/null@@ -1,702 +0,0 @@-import { mcpServersRegistry as registry } from '../MCPServersRegistry';-import { privateServersLoadStatusCache as loadStatusCache } from '../cache/PrivateServersLoadStatusCache';-import { MCPPrivateServerLoader } from '../MCPPrivateServerLoader';-import { logger } from '@librechat/data-schemas';-import type * as t from '~/mcp/types';-import type { MCPServerDB } from 'librechat-data-provider';--// Mock dependencies-jest.mock('../MCPServersRegistry', () => ({- mcpServersRegistry: {- privateServersCache: {- get: jest.fn(),- add: jest.fn(),- reset: jest.fn(),- updateServerConfigIfExists: jest.fn(),- findUsersWithServer: jest.fn(),- removeServerConfigIfCacheExists: jest.fn(),- addServerConfigIfCacheExists: jest.fn(),- reset: jest.fn(),- },- getServerConfig: jest.fn(),- addSharedServer: jest.fn(),- removeServer: jest.fn(),- getServerConfig: jest.fn(),- },-}));--jest.mock('../cache/PrivateServersLoadStatusCache', () => ({- privateServersLoadStatusCache: {- isLoaded: jest.fn(),- setLoaded: jest.fn(),- acquireLoadLock: jest.fn(),- releaseLoadLock: jest.fn(),- waitForLoad: jest.fn(),- },-}));--jest.mock('@librechat/data-schemas', () => ({- logger: {- debug: jest.fn(),- info: jest.fn(),- warn: jest.fn(),- error: jest.fn(),- },-}));--describe('MCPPrivateServerLoader', () => {- const mockConfig1: t.ParsedServerConfig = {- command: 'node',- args: ['server1.js'],- env: { TEST: 'value1' },- lastUpdatedAt: Date.now(),- };-- const mockConfig2: t.ParsedServerConfig = {- command: 'python',- args: ['server2.py'],- env: { TEST: 'value2' },- lastUpdatedAt: Date.now(),- };-- beforeEach(() => {- jest.clearAllMocks();- });-- describe('loadPrivateServers()', () => {- it('should validate userId and throw error if empty', async () => {- const configsLoader = jest.fn();-- await expect(MCPPrivateServerLoader.loadPrivateServers('', configsLoader)).rejects.toThrow(- 'userId is required and cannot be empty',- );-- await expect(MCPPrivateServerLoader.loadPrivateServers(' ', configsLoader)).rejects.toThrow(- 'userId is required and cannot be empty',- );- });-- it('should validate configsLoader and throw error if not a function', async () => {- // eslint-disable-next-line @typescript-eslint/no-explicit-any- await expect(MCPPrivateServerLoader.loadPrivateServers('user1', null as any)).rejects.toThrow(- 'configsLoader must be a function',- );-- await expect(- // eslint-disable-next-line @typescript-eslint/no-explicit-any- MCPPrivateServerLoader.loadPrivateServers('user1', 'not-a-function' as any),- ).rejects.toThrow('configsLoader must be a function');- });-- it('should skip loading if user servers are already loaded', async () => {- const configsLoader = jest.fn();- (loadStatusCache.isLoaded as jest.Mock).mockResolvedValue(true);-- await MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader);-- expect(loadStatusCache.isLoaded).toHaveBeenCalledWith('user1');- expect(configsLoader).not.toHaveBeenCalled();- expect(loadStatusCache.acquireLoadLock).not.toHaveBeenCalled();- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][PrivateServerLoader] User user1 private servers already loaded',- );- });-- it('should load private servers for a user successfully', async () => {- const mockConfigs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- {- _id: 'mock-id-2',- mcp_id: 'server2',- config: mockConfig2,- },- ];-- const configsLoader = jest.fn().mockResolvedValue(mockConfigs);- (loadStatusCache.isLoaded as jest.Mock).mockResolvedValue(false);- (loadStatusCache.acquireLoadLock as jest.Mock).mockResolvedValue(true);- (registry.privateServersCache.get as jest.Mock).mockResolvedValue(undefined);-- await MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader);-- expect(loadStatusCache.acquireLoadLock).toHaveBeenCalledWith('user1');- expect(configsLoader).toHaveBeenCalledWith('user1');- expect(registry.privateServersCache.add).toHaveBeenCalledWith('user1', 'server1', {- ...mockConfig1,- dbId: 'mock-id-1',- });- expect(registry.privateServersCache.add).toHaveBeenCalledWith('user1', 'server2', {- ...mockConfig2,- dbId: 'mock-id-2',- });- expect(loadStatusCache.setLoaded).toHaveBeenCalledWith('user1', 3600_000);- expect(loadStatusCache.releaseLoadLock).toHaveBeenCalledWith('user1');- expect(logger.info).toHaveBeenCalledWith(- '[MCP][PrivateServerLoader] Loading private servers for user user1',- );- });-- it('should skip servers that already exist in cache', async () => {- const mockConfigs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- {- _id: 'mock-id-2',- mcp_id: 'server2',- config: mockConfig2,- },- ];-- const configsLoader = jest.fn().mockResolvedValue(mockConfigs);- (loadStatusCache.isLoaded as jest.Mock).mockResolvedValue(false);- (loadStatusCache.acquireLoadLock as jest.Mock).mockResolvedValue(true);- (registry.privateServersCache.get as jest.Mock)- .mockResolvedValueOnce(mockConfig1) // server1 exists- .mockResolvedValueOnce(undefined); // server2 doesn't exist-- await MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader);-- expect(registry.privateServersCache.add).toHaveBeenCalledTimes(1);- expect(registry.privateServersCache.add).toHaveBeenCalledWith('user1', 'server2', {- ...mockConfig2,- dbId: 'mock-id-2',- });- expect(loadStatusCache.setLoaded).toHaveBeenCalledWith('user1', 3600_000);- expect(loadStatusCache.releaseLoadLock).toHaveBeenCalledWith('user1');- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][PrivateServer][server1] Private server already exists for user user1',- );- });-- it('should throw error if configsLoader fails', async () => {- const configsLoader = jest.fn().mockRejectedValue(new Error('DB connection failed'));- (loadStatusCache.isLoaded as jest.Mock).mockResolvedValue(false);- (loadStatusCache.acquireLoadLock as jest.Mock).mockResolvedValue(true);-- await expect(- MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader),- ).rejects.toThrow('DB connection failed');-- expect(logger.error).toHaveBeenCalledWith(- '[MCP][PrivateServerLoader] Loading private servers for user user1 failed.',- expect.any(Error),- );- expect(loadStatusCache.setLoaded).not.toHaveBeenCalled();- expect(loadStatusCache.releaseLoadLock).toHaveBeenCalledWith('user1');- });-- it('should throw error if cache.add fails', async () => {- const mockConfigs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- ];-- const configsLoader = jest.fn().mockResolvedValue(mockConfigs);- (loadStatusCache.isLoaded as jest.Mock).mockResolvedValue(false);- (loadStatusCache.acquireLoadLock as jest.Mock).mockResolvedValue(true);- (registry.privateServersCache.get as jest.Mock).mockResolvedValue(undefined);- (registry.privateServersCache.add as jest.Mock).mockRejectedValue(- new Error('Cache write failed'),- );-- await expect(- MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader),- ).rejects.toThrow('Cache write failed');- expect(loadStatusCache.setLoaded).not.toHaveBeenCalled();- expect(loadStatusCache.releaseLoadLock).toHaveBeenCalledWith('user1');- });-- it('should handle empty configs gracefully', async () => {- const mockConfigs: MCPServerDB[] = [];-- const configsLoader = jest.fn().mockResolvedValue(mockConfigs);- (loadStatusCache.isLoaded as jest.Mock).mockResolvedValue(false);- (loadStatusCache.acquireLoadLock as jest.Mock).mockResolvedValue(true);-- await MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader);-- expect(registry.privateServersCache.add).not.toHaveBeenCalled();- expect(loadStatusCache.setLoaded).toHaveBeenCalledWith('user1', 3600_000);- expect(loadStatusCache.releaseLoadLock).toHaveBeenCalledWith('user1');- });-- it('should prevent partial loads after crash - loaded flag not set on failure', async () => {- const mockConfigs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- {- _id: 'mock-id-2',- mcp_id: 'server2',- config: mockConfig2,- },- ];-- const configsLoader = jest.fn().mockResolvedValue(mockConfigs);- (loadStatusCache.isLoaded as jest.Mock).mockResolvedValue(false);- (loadStatusCache.acquireLoadLock as jest.Mock).mockResolvedValue(true);- (registry.privateServersCache.get as jest.Mock).mockResolvedValue(undefined);-- // Simulate crash after loading first server- (registry.privateServersCache.add as jest.Mock)- .mockResolvedValueOnce(undefined) // server1 succeeds- .mockRejectedValueOnce(new Error('Process crashed')); // server2 fails-- await expect(- MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader),- ).rejects.toThrow('Process crashed');-- // Loaded flag should NOT be set- expect(loadStatusCache.setLoaded).not.toHaveBeenCalled();- // Lock should be released even on error- expect(loadStatusCache.releaseLoadLock).toHaveBeenCalledWith('user1');-- // On next call, should retry full load- jest.clearAllMocks();- (loadStatusCache.isLoaded as jest.Mock).mockResolvedValue(false);- (loadStatusCache.acquireLoadLock as jest.Mock).mockResolvedValue(true);- (registry.privateServersCache.add as jest.Mock).mockResolvedValue(undefined);- await MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader);-- // Now flag should be set- expect(loadStatusCache.setLoaded).toHaveBeenCalledWith('user1', 3600_000);- });-- it('should wait for another process when lock is already held', async () => {- const configsLoader = jest.fn();- (loadStatusCache.isLoaded as jest.Mock).mockResolvedValue(false);- (loadStatusCache.acquireLoadLock as jest.Mock).mockResolvedValue(false); // Lock held- (loadStatusCache.waitForLoad as jest.Mock).mockResolvedValue(true); // Wait completes-- await MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader);-- expect(loadStatusCache.acquireLoadLock).toHaveBeenCalledWith('user1');- expect(loadStatusCache.waitForLoad).toHaveBeenCalledWith('user1');- expect(configsLoader).not.toHaveBeenCalled(); // Didn't load, waited instead- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][PrivateServerLoader] Another process is loading user user1, waiting...',- );- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][PrivateServerLoader] User user1 loaded by another process',- );- });-- it('should retry lock acquisition after wait timeout', async () => {- const mockConfigs: MCPServerDB[] = [- {- _id: 'mock-id-1',- mcp_id: 'server1',- config: mockConfig1,- },- ];-- const configsLoader = jest.fn().mockResolvedValue(mockConfigs);- (loadStatusCache.isLoaded as jest.Mock).mockResolvedValue(false);- (loadStatusCache.acquireLoadLock as jest.Mock)- .mockResolvedValueOnce(false) // First attempt: lock held- .mockResolvedValueOnce(true); // Retry after timeout: success- (loadStatusCache.waitForLoad as jest.Mock).mockResolvedValue(false); // Wait times out- (registry.privateServersCache.get as jest.Mock).mockResolvedValue(undefined);-- await MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader);-- expect(loadStatusCache.acquireLoadLock).toHaveBeenCalledTimes(2);- expect(loadStatusCache.waitForLoad).toHaveBeenCalledWith('user1');- expect(configsLoader).toHaveBeenCalled(); // Loaded after retry- expect(logger.warn).toHaveBeenCalledWith(- '[MCP][PrivateServerLoader] Timeout waiting for user user1, retrying lock acquisition',- );- });-- it('should throw error if retry lock acquisition fails', async () => {- const configsLoader = jest.fn();- (loadStatusCache.isLoaded as jest.Mock).mockResolvedValue(false);- (loadStatusCache.acquireLoadLock as jest.Mock).mockResolvedValue(false); // Both attempts fail- (loadStatusCache.waitForLoad as jest.Mock).mockResolvedValue(false); // Wait times out-- await expect(- MCPPrivateServerLoader.loadPrivateServers('user1', configsLoader),- ).rejects.toThrow('Failed to acquire load lock for user user1');-- expect(loadStatusCache.acquireLoadLock).toHaveBeenCalledTimes(2);- expect(configsLoader).not.toHaveBeenCalled();- });- });-- describe('updatePrivateServer()', () => {- it('should propagate metadata update to all users when server is not promoted', async () => {- (registry.getServerConfig as jest.Mock).mockResolvedValue(undefined);-- await MCPPrivateServerLoader.updatePrivateServer('server1', mockConfig2);-- expect(registry.getServerConfig).toHaveBeenCalledWith('server1');- expect(registry.privateServersCache.updateServerConfigIfExists).toHaveBeenCalledWith(- 'server1',- mockConfig2,- );- expect(registry.removeServer).not.toHaveBeenCalled();- expect(registry.addSharedServer).not.toHaveBeenCalled();- expect(logger.info).toHaveBeenCalledWith(- '[MCP][PrivateServer][server1] Propagating metadata update to all users',- );- });-- it('should handle promoted server by updating shared registry', async () => {- const sharedConfig: t.ParsedServerConfig = {- command: 'node',- args: ['shared.js'],- env: { SHARED: 'true' },- lastUpdatedAt: Date.now(),- };-- (registry.getServerConfig as jest.Mock).mockResolvedValue(sharedConfig);-- await MCPPrivateServerLoader.updatePrivateServer('server1', mockConfig2);-- expect(registry.getServerConfig).toHaveBeenCalledWith('server1');- expect(registry.removeServer).toHaveBeenCalledWith('server1');- expect(registry.addSharedServer).toHaveBeenCalledWith('server1', mockConfig2);- expect(registry.privateServersCache.updateServerConfigIfExists).not.toHaveBeenCalled();- expect(logger.info).toHaveBeenCalledWith(- '[MCP][PrivateServer][server1] Promoted private server update',- );- });-- it('should throw error if updateServerConfigIfExists fails', async () => {- (registry.getServerConfig as jest.Mock).mockResolvedValue(undefined);- (registry.privateServersCache.updateServerConfigIfExists as jest.Mock).mockRejectedValue(- new Error('Redis update failed'),- );-- await expect(- MCPPrivateServerLoader.updatePrivateServer('server1', mockConfig2),- ).rejects.toThrow('Redis update failed');- });-- it('should throw error if removeServer fails for promoted server', async () => {- (registry.getServerConfig as jest.Mock).mockResolvedValue(mockConfig1);- (registry.removeServer as jest.Mock).mockRejectedValue(new Error('Remove server failed'));-- await expect(- MCPPrivateServerLoader.updatePrivateServer('server1', mockConfig2),- ).rejects.toThrow('Remove server failed');- });-- it('should throw error if addSharedServer fails for promoted server', async () => {- (registry.getServerConfig as jest.Mock).mockResolvedValue(mockConfig1);- (registry.removeServer as jest.Mock).mockResolvedValue(undefined); // Ensure removeServer succeeds- (registry.addSharedServer as jest.Mock).mockRejectedValue(- new Error('Add shared server failed'),- );-- await expect(- MCPPrivateServerLoader.updatePrivateServer('server1', mockConfig2),- ).rejects.toThrow('Add shared server failed');- });- });-- describe('updatePrivateServerAccess()', () => {- it('should revoke access from all users when allowedUserIds is empty', async () => {- (registry.privateServersCache.findUsersWithServer as jest.Mock).mockResolvedValue([- 'user1',- 'user2',- 'user3',- ]);-- await MCPPrivateServerLoader.updatePrivateServerAccess('server1', [], mockConfig1);-- expect(registry.privateServersCache.findUsersWithServer).toHaveBeenCalledWith('server1');- expect(registry.privateServersCache.removeServerConfigIfCacheExists).toHaveBeenCalledWith(- ['user1', 'user2', 'user3'],- 'server1',- );- expect(logger.info).toHaveBeenCalledWith(- '[MCP][PrivateServer][server1] Revoking access from all users',- );- });-- it('should grant access to new users and revoke from removed users', async () => {- const allowedUserIds = ['user1', 'user2', 'user4'];- (registry.privateServersCache.findUsersWithServer as jest.Mock).mockResolvedValue([- 'user1',- 'user2',- 'user3',- ]);-- await MCPPrivateServerLoader.updatePrivateServerAccess(- 'server1',- allowedUserIds,- mockConfig1,- );-- // Should revoke from user3 (no longer in allowed list)- expect(registry.privateServersCache.removeServerConfigIfCacheExists).toHaveBeenCalledWith(- ['user3'],- 'server1',- );-- // Should grant to all allowed users (includes existing and new)- expect(registry.privateServersCache.addServerConfigIfCacheExists).toHaveBeenCalledWith(- allowedUserIds,- 'server1',- mockConfig1,- );-- expect(logger.info).toHaveBeenCalledWith(- '[MCP][PrivateServer][server1] Updating access for 3 users',- );- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][PrivateServer][server1] Revoking access from 1 users',- );- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][PrivateServer][server1] Granting access to 3 users',- );- });-- it('should only grant access when no users currently have the server', async () => {- const allowedUserIds = ['user1', 'user2'];- (registry.privateServersCache.findUsersWithServer as jest.Mock).mockResolvedValue([]);-- await MCPPrivateServerLoader.updatePrivateServerAccess(- 'server1',- allowedUserIds,- mockConfig1,- );-- expect(registry.privateServersCache.removeServerConfigIfCacheExists).not.toHaveBeenCalled();- expect(registry.privateServersCache.addServerConfigIfCacheExists).toHaveBeenCalledWith(- allowedUserIds,- 'server1',- mockConfig1,- );- });-- it('should only revoke access when granting to users who already have it', async () => {- const allowedUserIds = ['user1', 'user2'];- (registry.privateServersCache.findUsersWithServer as jest.Mock).mockResolvedValue([- 'user1',- 'user2',- ]);-- await MCPPrivateServerLoader.updatePrivateServerAccess(- 'server1',- allowedUserIds,- mockConfig1,- );-- // No one to revoke- expect(registry.privateServersCache.removeServerConfigIfCacheExists).not.toHaveBeenCalled();-- // Still grant (idempotent)- expect(registry.privateServersCache.addServerConfigIfCacheExists).toHaveBeenCalledWith(- allowedUserIds,- 'server1',- mockConfig1,- );- });-- it('should handle completely new access list', async () => {- const allowedUserIds = ['user4', 'user5', 'user6'];- (registry.privateServersCache.findUsersWithServer as jest.Mock).mockResolvedValue([- 'user1',- 'user2',- 'user3',- ]);-- await MCPPrivateServerLoader.updatePrivateServerAccess(- 'server1',- allowedUserIds,- mockConfig1,- );-- // Revoke from all current users- expect(registry.privateServersCache.removeServerConfigIfCacheExists).toHaveBeenCalledWith(- ['user1', 'user2', 'user3'],- 'server1',- );-- // Grant to all new users- expect(registry.privateServersCache.addServerConfigIfCacheExists).toHaveBeenCalledWith(- allowedUserIds,- 'server1',- mockConfig1,- );- });-- it('should throw error if findUsersWithServer fails', async () => {- (registry.privateServersCache.findUsersWithServer as jest.Mock).mockRejectedValue(- new Error('Redis scan failed'),- );-- await expect(- MCPPrivateServerLoader.updatePrivateServerAccess('server1', [], mockConfig1),- ).rejects.toThrow('Redis scan failed');- });- });-- describe('promoteToSharedServer()', () => {- it('should promote private server to shared registry and remove from private caches', async () => {- (registry.addSharedServer as jest.Mock).mockResolvedValue(undefined);- (registry.privateServersCache.findUsersWithServer as jest.Mock).mockResolvedValue([- 'user1',- 'user2',- 'user3',- ]);-- await MCPPrivateServerLoader.promoteToSharedServer('server1', mockConfig1);-- // Should add to shared registry- expect(registry.addSharedServer).toHaveBeenCalledWith('server1', mockConfig1);-- // Should remove from all private user caches- expect(registry.privateServersCache.removeServerConfigIfCacheExists).toHaveBeenCalledWith(- ['user1', 'user2', 'user3'],- 'server1',- );-- expect(logger.info).toHaveBeenCalledWith(- '[MCP][PrivateServer][server1] Promoting to shared server',- );- expect(logger.info).toHaveBeenCalledWith(- '[MCP][PrivateServer][server1] Successfully promoted to shared server',- );- });-- it('should handle promoting when no users have the server privately', async () => {- (registry.addSharedServer as jest.Mock).mockResolvedValue(undefined);- (registry.privateServersCache.findUsersWithServer as jest.Mock).mockResolvedValue([]);-- await MCPPrivateServerLoader.promoteToSharedServer('server1', mockConfig1);-- expect(registry.addSharedServer).toHaveBeenCalledWith('server1', mockConfig1);- expect(registry.privateServersCache.removeServerConfigIfCacheExists).not.toHaveBeenCalled();- });-- it('should throw error if addSharedServer fails', async () => {- (registry.addSharedServer as jest.Mock).mockRejectedValue(- new Error('Failed to add to shared registry'),- );-- await expect(- MCPPrivateServerLoader.promoteToSharedServer('server1', mockConfig1),- ).rejects.toThrow('Failed to add to shared registry');- });- });-- describe('demoteToPrivateServer()', () => {- it('should demote shared server to private caches for specified users', async () => {- const allowedUserIds = ['user1', 'user2', 'user3'];- (registry.removeServer as jest.Mock).mockResolvedValue(undefined);-- await MCPPrivateServerLoader.demoteToPrivateServer('server1', allowedUserIds, mockConfig1);-- // Should remove from shared registry- expect(registry.removeServer).toHaveBeenCalledWith('server1');-- // Should add to private caches for allowed users- expect(registry.privateServersCache.addServerConfigIfCacheExists).toHaveBeenCalledWith(- allowedUserIds,- 'server1',- mockConfig1,- );-- expect(logger.info).toHaveBeenCalledWith(- '[MCP][PrivateServer][server1] Demoting to private server',- );- expect(logger.info).toHaveBeenCalledWith(- '[MCP][PrivateServer][server1] Successfully demoted to private server',- );- });-- it('should handle demoting with empty user list', async () => {- (registry.removeServer as jest.Mock).mockResolvedValue(undefined);-- await MCPPrivateServerLoader.demoteToPrivateServer('server1', [], mockConfig1);-- expect(registry.removeServer).toHaveBeenCalledWith('server1');- expect(registry.privateServersCache.addServerConfigIfCacheExists).not.toHaveBeenCalled();- });-- it('should throw error if removeServer fails', async () => {- (registry.removeServer as jest.Mock).mockRejectedValue(- new Error('Server not found in shared registry'),- );-- await expect(- MCPPrivateServerLoader.demoteToPrivateServer('server1', ['user1'], mockConfig1),- ).rejects.toThrow('Server not found in shared registry');- });- });-- describe('addPrivateServer()', () => {- it('should add private server for a user', async () => {- await MCPPrivateServerLoader.addPrivateServer('user1', 'server1', mockConfig1);-- expect(registry.privateServersCache.add).toHaveBeenCalledWith(- 'user1',- 'server1',- mockConfig1,- );- expect(logger.info).toHaveBeenCalledWith(- '[MCP][PrivateServer][server1] add private server to user with Id user1',- );- });-- it('should add private server with different configs for different users', async () => {- await MCPPrivateServerLoader.addPrivateServer('user1', 'server1', mockConfig1);- await MCPPrivateServerLoader.addPrivateServer('user2', 'server2', mockConfig2);-- expect(registry.privateServersCache.add).toHaveBeenCalledWith(- 'user1',- 'server1',- mockConfig1,- );- expect(registry.privateServersCache.add).toHaveBeenCalledWith(- 'user2',- 'server2',- mockConfig2,- );- });-- it('should throw error if cache add fails', async () => {- (registry.privateServersCache.add as jest.Mock).mockRejectedValue(- new Error('Cache write failed'),- );-- await expect(- MCPPrivateServerLoader.addPrivateServer('user1', 'server1', mockConfig1),- ).rejects.toThrow('Cache write failed');- });-- it('should handle adding server with complex config', async () => {- const complexConfig: t.ParsedServerConfig = {- url: 'https://api.example.com',- requiresOAuth: true,- lastUpdatedAt: Date.now(),- };-- // Reset the mock to ensure it succeeds for this test- (registry.privateServersCache.add as jest.Mock).mockResolvedValue(undefined);-- await MCPPrivateServerLoader.addPrivateServer('user1', 'complex-server', complexConfig);-- expect(registry.privateServersCache.add).toHaveBeenCalledWith(- 'user1',- 'complex-server',- complexConfig,- );- });- });-});diff --git a/packages/api/src/mcp/registry/__tests__/MCPServersInitializer.cache_integration.spec.ts b/packages/api/src/mcp/registry/__tests__/MCPServersInitializer.cache_integration.spec.tsindex 703758c959..22a1542671 100644--- a/packages/api/src/mcp/registry/__tests__/MCPServersInitializer.cache_integration.spec.ts+++ b/packages/api/src/mcp/registry/__tests__/MCPServersInitializer.cache_integration.spec.ts@@ -213,20 +213,20 @@ describe('MCPServersInitializer Redis Integration Tests', () => {describe('initialize()', () => {it('should reset registry and status cache before initialization', async () => {- // Pre-populate registry with some old servers- await registry.sharedAppServers.add('old_app_server', testParsedConfigs.file_tools_server);- await registry.sharedUserServers.add('old_user_server', testParsedConfigs.oauth_server);+ // Pre-populate registry with some old servers using public API+ await registry.addServer('old_app_server', testConfigs.file_tools_server, 'CACHE');+ await registry.addServer('old_user_server', testConfigs.oauth_server, 'CACHE');// Initialize with new configs (this should reset first)await MCPServersInitializer.initialize(testConfigs);// Verify old servers are gone- expect(await registry.sharedAppServers.get('old_app_server')).toBeUndefined();- expect(await registry.sharedUserServers.get('old_user_server')).toBeUndefined();+ expect(await registry.getServerConfig('old_app_server')).toBeUndefined();+ expect(await registry.getServerConfig('old_user_server')).toBeUndefined();// Verify new servers are present- expect(await registry.sharedAppServers.get('file_tools_server')).toBeDefined();- expect(await registry.sharedUserServers.get('oauth_server')).toBeDefined();+ expect(await registry.getServerConfig('file_tools_server')).toBeDefined();+ expect(await registry.getServerConfig('oauth_server')).toBeDefined();expect(await registryStatusCache.isInitialized()).toBe(true);});@@ -244,54 +244,14 @@ describe('MCPServersInitializer Redis Integration Tests', () => {expect(MCPServerInspector.inspect).not.toHaveBeenCalled();});- it('should add disabled servers to sharedUserServers', async () => {+ it('should initialize all servers to cache repository', async () => {await MCPServersInitializer.initialize(testConfigs);- const disabledServer = await registry.sharedUserServers.get('disabled_server');- expect(disabledServer).toBeDefined();- expect(disabledServer).toMatchObject({- ...testParsedConfigs.disabled_server,- _processedByInspector: true,- });- });-- it('should add OAuth servers to sharedUserServers', async () => {- await MCPServersInitializer.initialize(testConfigs);-- const oauthServer = await registry.sharedUserServers.get('oauth_server');- expect(oauthServer).toBeDefined();- expect(oauthServer).toMatchObject({- ...testParsedConfigs.oauth_server,- _processedByInspector: true,- });- });-- it('should add enabled non-OAuth servers to sharedAppServers', async () => {- await MCPServersInitializer.initialize(testConfigs);-- const fileToolsServer = await registry.sharedAppServers.get('file_tools_server');- expect(fileToolsServer).toBeDefined();- expect(fileToolsServer).toMatchObject({- ...testParsedConfigs.file_tools_server,- _processedByInspector: true,- });-- const searchToolsServer = await registry.sharedAppServers.get('search_tools_server');- expect(searchToolsServer).toBeDefined();- expect(searchToolsServer).toMatchObject({- ...testParsedConfigs.search_tools_server,- _processedByInspector: true,- });- });-- it('should successfully initialize all servers', async () => {- await MCPServersInitializer.initialize(testConfigs);-- // Verify all servers were added to appropriate registries- expect(await registry.sharedUserServers.get('disabled_server')).toBeDefined();- expect(await registry.sharedUserServers.get('oauth_server')).toBeDefined();- expect(await registry.sharedAppServers.get('file_tools_server')).toBeDefined();- expect(await registry.sharedAppServers.get('search_tools_server')).toBeDefined();+ // Verify all server types (disabled, OAuth, and regular) were added to cache+ expect(await registry.getServerConfig('disabled_server')).toBeDefined();+ expect(await registry.getServerConfig('oauth_server')).toBeDefined();+ expect(await registry.getServerConfig('file_tools_server')).toBeDefined();+ expect(await registry.getServerConfig('search_tools_server')).toBeDefined();});it('should handle inspection failures gracefully', async () => {@@ -309,17 +269,17 @@ describe('MCPServersInitializer Redis Integration Tests', () => {await MCPServersInitializer.initialize(testConfigs);// Verify other servers were still processed- const disabledServer = await registry.sharedUserServers.get('disabled_server');+ const disabledServer = await registry.getServerConfig('disabled_server');expect(disabledServer).toBeDefined();- const oauthServer = await registry.sharedUserServers.get('oauth_server');+ const oauthServer = await registry.getServerConfig('oauth_server');expect(oauthServer).toBeDefined();- const searchToolsServer = await registry.sharedAppServers.get('search_tools_server');+ const searchToolsServer = await registry.getServerConfig('search_tools_server');expect(searchToolsServer).toBeDefined();// Verify file_tools_server was not added (due to inspection failure)- const fileToolsServer = await registry.sharedAppServers.get('file_tools_server');+ const fileToolsServer = await registry.getServerConfig('file_tools_server');expect(fileToolsServer).toBeUndefined();});diff --git a/packages/api/src/mcp/registry/__tests__/MCPServersInitializer.test.ts b/packages/api/src/mcp/registry/__tests__/MCPServersInitializer.test.tsindex a52d9c21b8..1c259d8da8 100644--- a/packages/api/src/mcp/registry/__tests__/MCPServersInitializer.test.ts+++ b/packages/api/src/mcp/registry/__tests__/MCPServersInitializer.test.ts@@ -157,8 +157,7 @@ describe('MCPServersInitializer', () => {// Reset caches before each testawait registryStatusCache.reset();- await registry.sharedAppServers.reset();- await registry.sharedUserServers.reset();+ await registry.reset();jest.clearAllMocks();});@@ -168,20 +167,20 @@ describe('MCPServersInitializer', () => {describe('initialize()', () => {it('should reset registry and status cache before initialization', async () => {- // Pre-populate registry with some old servers- await registry.sharedAppServers.add('old_app_server', testParsedConfigs.file_tools_server);- await registry.sharedUserServers.add('old_user_server', testParsedConfigs.oauth_server);+ // Pre-populate registry with some old servers using the public API+ await registry.addServer('old_app_server', testConfigs.file_tools_server, 'CACHE');+ await registry.addServer('old_user_server', testConfigs.oauth_server, 'CACHE');// Initialize with new configs (this should reset first)await MCPServersInitializer.initialize(testConfigs);// Verify old servers are gone- expect(await registry.sharedAppServers.get('old_app_server')).toBeUndefined();- expect(await registry.sharedUserServers.get('old_user_server')).toBeUndefined();+ expect(await registry.getServerConfig('old_app_server')).toBeUndefined();+ expect(await registry.getServerConfig('old_user_server')).toBeUndefined();// Verify new servers are present- expect(await registry.sharedAppServers.get('file_tools_server')).toBeDefined();- expect(await registry.sharedUserServers.get('oauth_server')).toBeDefined();+ expect(await registry.getServerConfig('file_tools_server')).toBeDefined();+ expect(await registry.getServerConfig('oauth_server')).toBeDefined();expect(await registryStatusCache.isInitialized()).toBe(true);});@@ -215,54 +214,14 @@ describe('MCPServersInitializer', () => {);});- it('should add disabled servers to sharedUserServers', async () => {+ it('should initialize all servers to cache repository', async () => {await MCPServersInitializer.initialize(testConfigs);- const disabledServer = await registry.sharedUserServers.get('disabled_server');- expect(disabledServer).toBeDefined();- expect(disabledServer).toMatchObject({- ...testParsedConfigs.disabled_server,- _processedByInspector: true,- });- });-- it('should add OAuth servers to sharedUserServers', async () => {- await MCPServersInitializer.initialize(testConfigs);-- const oauthServer = await registry.sharedUserServers.get('oauth_server');- expect(oauthServer).toBeDefined();- expect(oauthServer).toMatchObject({- ...testParsedConfigs.oauth_server,- _processedByInspector: true,- });- });-- it('should add enabled non-OAuth servers to sharedAppServers', async () => {- await MCPServersInitializer.initialize(testConfigs);-- const fileToolsServer = await registry.sharedAppServers.get('file_tools_server');- expect(fileToolsServer).toBeDefined();- expect(fileToolsServer).toMatchObject({- ...testParsedConfigs.file_tools_server,- _processedByInspector: true,- });-- const searchToolsServer = await registry.sharedAppServers.get('search_tools_server');- expect(searchToolsServer).toBeDefined();- expect(searchToolsServer).toMatchObject({- ...testParsedConfigs.search_tools_server,- _processedByInspector: true,- });- });-- it('should successfully initialize all servers', async () => {- await MCPServersInitializer.initialize(testConfigs);-- // Verify all servers were added to appropriate registries- expect(await registry.sharedUserServers.get('disabled_server')).toBeDefined();- expect(await registry.sharedUserServers.get('oauth_server')).toBeDefined();- expect(await registry.sharedAppServers.get('file_tools_server')).toBeDefined();- expect(await registry.sharedAppServers.get('search_tools_server')).toBeDefined();+ // Verify all server types (disabled, OAuth, and regular) were added to cache+ expect(await registry.getServerConfig('disabled_server')).toBeDefined();+ expect(await registry.getServerConfig('oauth_server')).toBeDefined();+ expect(await registry.getServerConfig('file_tools_server')).toBeDefined();+ expect(await registry.getServerConfig('search_tools_server')).toBeDefined();});it('should handle inspection failures gracefully', async () => {@@ -283,17 +242,17 @@ describe('MCPServersInitializer', () => {await MCPServersInitializer.initialize(testConfigs);// Verify other servers were still processed- const disabledServer = await registry.sharedUserServers.get('disabled_server');+ const disabledServer = await registry.getServerConfig('disabled_server');expect(disabledServer).toBeDefined();- const oauthServer = await registry.sharedUserServers.get('oauth_server');+ const oauthServer = await registry.getServerConfig('oauth_server');expect(oauthServer).toBeDefined();- const searchToolsServer = await registry.sharedAppServers.get('search_tools_server');+ const searchToolsServer = await registry.getServerConfig('search_tools_server');expect(searchToolsServer).toBeDefined();// Verify file_tools_server was not added (due to inspection failure)- const fileToolsServer = await registry.sharedAppServers.get('file_tools_server');+ const fileToolsServer = await registry.getServerConfig('file_tools_server');expect(fileToolsServer).toBeUndefined();});diff --git a/packages/api/src/mcp/registry/__tests__/MCPServersRegistry.cache_integration.spec.ts b/packages/api/src/mcp/registry/__tests__/MCPServersRegistry.cache_integration.spec.tsindex 46b049d875..ca5e9f8063 100644--- a/packages/api/src/mcp/registry/__tests__/MCPServersRegistry.cache_integration.spec.ts+++ b/packages/api/src/mcp/registry/__tests__/MCPServersRegistry.cache_integration.spec.ts@@ -4,12 +4,17 @@ import type * as t from '~/mcp/types';/*** Integration tests for MCPServersRegistry using Redis-backed cache.* For unit tests using in-memory cache, see MCPServersRegistry.test.ts+ *+ * NOTE: After refactoring, these tests have been simplified.+ * Private server functionality has been moved to DB (not yet implemented).+ * The registry now uses a unified cache repository for YAML configs only.*/describe('MCPServersRegistry Redis Integration Tests', () => {let registry: typeof import('../MCPServersRegistry').mcpServersRegistry;let keyvRedisClient: Awaited<typeof import('~/cache/redisClients')>['keyvRedisClient'];let LeaderElection: typeof import('~/cluster/LeaderElection').LeaderElection;let leaderInstance: InstanceType<typeof import('~/cluster/LeaderElection').LeaderElection>;+ let MCPServerInspector: typeof import('../MCPServerInspector').MCPServerInspector;const testParsedConfig: t.ParsedServerConfig = {type: 'stdio',@@ -31,6 +36,12 @@ describe('MCPServersRegistry Redis Integration Tests', () => {},};+ const testRawConfig: t.MCPOptions = {+ type: 'stdio',+ command: 'node',+ args: ['tools.js'],+ };+beforeAll(async () => {// Set up environment variables for Redis (only if not already set)process.env.USE_REDIS = process.env.USE_REDIS ?? 'true';@@ -43,10 +54,12 @@ describe('MCPServersRegistry Redis Integration Tests', () => {const registryModule = await import('../MCPServersRegistry');const redisClients = await import('~/cache/redisClients');const leaderElectionModule = await import('~/cluster/LeaderElection');+ const inspectorModule = await import('../MCPServerInspector');registry = registryModule.mcpServersRegistry;keyvRedisClient = redisClients.keyvRedisClient;LeaderElection = leaderElectionModule.LeaderElection;+ MCPServerInspector = inspectorModule.MCPServerInspector;// Ensure Redis is connectedif (!keyvRedisClient) throw new Error('Redis client is not initialized');@@ -60,6 +73,18 @@ describe('MCPServersRegistry Redis Integration Tests', () => {expect(isLeader).toBe(true);});+ beforeEach(() => {+ // Mock MCPServerInspector.inspect to avoid actual server connections+ // Use mockImplementation to return the config that's actually passed in+ jest.spyOn(MCPServerInspector, 'inspect').mockImplementation(async (_serverName: string, rawConfig: t.MCPOptions) => {+ return {+ ...testParsedConfig,+ ...rawConfig,+ requiresOAuth: false,+ } as unknown as t.ParsedServerConfig;+ });+ });+afterEach(async () => {// Clean up: reset registry to clear all test dataawait registry.reset();@@ -79,6 +104,8 @@ describe('MCPServersRegistry Redis Integration Tests', () => {await Promise.all(keysToDelete.map((key) => keyvRedisClient!.del(key)));}}++ jest.restoreAllMocks();});afterAll(async () => {@@ -89,230 +116,100 @@ describe('MCPServersRegistry Redis Integration Tests', () => {if (keyvRedisClient?.isOpen) await keyvRedisClient.disconnect();});- describe('private user servers', () => {- it('should add and remove private user server', async () => {- const userId = 'user123';- const serverName = 'private_server';-- // Add private user server- await registry.privateServersCache.add(userId, serverName, testParsedConfig);-- // Verify server was added- const retrievedConfig = await registry.getServerConfig(serverName, userId);- expect(retrievedConfig).toMatchObject(testParsedConfig);-- // Remove private user server- await registry.privateServersCache.remove(userId, serverName);+ // Tests for the old privateServersCache API have been removed+ // The refactoring simplified the architecture to use unified repositories (cache + DB)+ // Private server functionality is now handled by the DB repository (not yet implemented)- // Verify server was removed- const configAfterRemoval = await registry.getServerConfig(serverName, userId);- expect(configAfterRemoval).toBeUndefined();- });+ describe('cache repository functionality', () => {+ it('should add and retrieve server config from cache', async () => {+ const serverName = 'test_server';- it('should throw error when adding duplicate private user server', async () => {- const userId = 'user123';- const serverName = 'private_server';+ // Add server using public API+ await registry.addServer(serverName, testRawConfig, 'CACHE');- await registry.privateServersCache.add(userId, serverName, testParsedConfig);- await expect(- registry.privateServersCache.add(userId, serverName, testParsedConfig),- ).rejects.toThrow(- 'Server "private_server" already exists in cache. Use update() to modify existing configs.',- );+ // Verify server was added+ const retrievedConfig = await registry.getServerConfig(serverName);+ expect(retrievedConfig).toBeDefined();+ expect(retrievedConfig?.type).toBe('stdio');+ if (retrievedConfig && 'command' in retrievedConfig) {+ expect(retrievedConfig.command).toBe('node');+ expect(retrievedConfig.args).toEqual(['tools.js']);+ }});- it('should update an existing private user server', async () => {- const userId = 'user123';- const serverName = 'private_server';- const updatedConfig: t.ParsedServerConfig = {+ it('should update existing server config in cache', async () => {+ const serverName = 'test_server';+ const updatedConfig: t.MCPOptions = {type: 'stdio',command: 'python',args: ['updated.py'],- requiresOAuth: true,};- // Add private user server- await registry.privateServersCache.add(userId, serverName, testParsedConfig);+ // Add server+ await registry.addServer(serverName, testRawConfig, 'CACHE');- // Update the server config- await registry.privateServersCache.update(userId, serverName, updatedConfig);+ // Update server+ await registry.updateServer(serverName, updatedConfig, 'CACHE');// Verify server was updated- const retrievedConfig = await registry.getServerConfig(serverName, userId);- expect(retrievedConfig).toMatchObject(updatedConfig);- });-- it('should throw error when updating non-existent server', async () => {- const userId = 'user123';- const serverName = 'private_server';-- // Add a user cache first- await registry.privateServersCache.add(userId, 'other_server', testParsedConfig);-- await expect(- registry.privateServersCache.update(userId, serverName, testParsedConfig),- ).rejects.toThrow(- 'Server "private_server" does not exist in cache. Use add() to create new configs.',- );- });-- it('should throw error when updating non-existent server (lazy-loads cache)', async () => {- const userId = 'nonexistent_user';- const serverName = 'private_server';-- // With lazy-loading, cache is created but server doesn't exist in it- await expect(- registry.privateServersCache.update(userId, serverName, testParsedConfig),- ).rejects.toThrow(- 'Server "private_server" does not exist in cache. Use add() to create new configs.',- );- });- });-- describe('getPrivateServerConfig', () => {- it('should retrieve private server config for a specific user', async () => {- const userId = 'user123';- const serverName = 'private_server';-- await registry.privateServersCache.add(userId, serverName, testParsedConfig);-- const retrievedConfig = await registry.privateServersCache.get(userId, serverName);- expect(retrievedConfig).toMatchObject(testParsedConfig);- });-- it('should return undefined if server does not exist in user private cache', async () => {- const userId = 'user123';-- // Create a cache for this user with a different server- await registry.privateServersCache.add(userId, 'other_server', testParsedConfig);-- // Try to get a server that doesn't exist- const retrievedConfig = await registry.privateServersCache.get(userId, 'nonexistent_server');- expect(retrievedConfig).toBeUndefined();- });-- it('should return undefined when user has no private servers (lazy-loads cache)', async () => {- const userId = 'user_with_no_cache';-- // With lazy-loading, cache is created but is empty- const config = await registry.privateServersCache.get(userId, 'server_name');- expect(config).toBeUndefined();- });-- it('should isolate private servers between different users', async () => {- const user1 = 'user1';- const user2 = 'user2';- const serverName = 'shared_name_server';-- const config1: t.ParsedServerConfig = {- ...testParsedConfig,- args: ['user1.js'],- };- const config2: t.ParsedServerConfig = {- ...testParsedConfig,- args: ['user2.js'],- };-- await registry.privateServersCache.add(user1, serverName, config1);- await registry.privateServersCache.add(user2, serverName, config2);-- const user1Config = await registry.privateServersCache.get(user1, serverName);- const user2Config = await registry.privateServersCache.get(user2, serverName);-- // Verify each user gets their own config- expect(user1Config).toBeDefined();- expect(user2Config).toBeDefined();- if (user1Config && 'args' in user1Config) {- expect(user1Config.args).toEqual(['user1.js']);- }- if (user2Config && 'args' in user2Config) {- expect(user2Config.args).toEqual(['user2.js']);+ const retrievedConfig = await registry.getServerConfig(serverName);+ expect(retrievedConfig).toBeDefined();+ expect(retrievedConfig?.type).toBe('stdio');+ if (retrievedConfig && 'command' in retrievedConfig) {+ expect(retrievedConfig.command).toBe('python');+ expect(retrievedConfig.args).toEqual(['updated.py']);}});- it('should not retrieve shared servers through privateServersCache.get', async () => {- const userId = 'user123';+ it('should remove server config from cache', async () => {+ const serverName = 'test_server';- // Add servers to shared caches- await registry.sharedAppServers.add('app_server', testParsedConfig);- await registry.sharedUserServers.add('user_server', testParsedConfig);+ // Add server+ await registry.addServer(serverName, testRawConfig, 'CACHE');- // Create a private cache for the user (but don't add these servers to it)- await registry.privateServersCache.add(userId, 'private_server', testParsedConfig);+ // Verify server exists+ const configBefore = await registry.getServerConfig(serverName);+ expect(configBefore).toBeDefined();- // Try to get shared servers using privateServersCache.get - should return undefined- // because privateServersCache.get only looks at private cache, not shared caches- const appServerConfig = await registry.privateServersCache.get(userId, 'app_server');- const userServerConfig = await registry.privateServersCache.get(userId, 'user_server');+ // Remove server+ await registry.removeServer(serverName, 'CACHE');- expect(appServerConfig).toBeUndefined();- expect(userServerConfig).toBeUndefined();+ // Verify server was removed+ const configAfter = await registry.getServerConfig(serverName);+ expect(configAfter).toBeUndefined();});});describe('getAllServerConfigs', () => {- it('should return correct servers based on userId', async () => {- // Add servers to all three caches- await registry.sharedAppServers.add('app_server', testParsedConfig);- await registry.sharedUserServers.add('user_server', testParsedConfig);- await registry.privateServersCache.add('abc', 'abc_private_server', testParsedConfig);- await registry.privateServersCache.add('xyz', 'xyz_private_server', testParsedConfig);-- // Without userId: should return only shared app + shared user servers- const configsNoUser = await registry.getAllServerConfigs();- expect(Object.keys(configsNoUser)).toHaveLength(2);- expect(configsNoUser).toHaveProperty('app_server');- expect(configsNoUser).toHaveProperty('user_server');-- // With userId 'abc': should return shared app + shared user + abc's private servers- const configsAbc = await registry.getAllServerConfigs('abc');- expect(Object.keys(configsAbc)).toHaveLength(3);- expect(configsAbc).toHaveProperty('app_server');- expect(configsAbc).toHaveProperty('user_server');- expect(configsAbc).toHaveProperty('abc_private_server');-- // With userId 'xyz': should return shared app + shared user + xyz's private servers- const configsXyz = await registry.getAllServerConfigs('xyz');- expect(Object.keys(configsXyz)).toHaveLength(3);- expect(configsXyz).toHaveProperty('app_server');- expect(configsXyz).toHaveProperty('user_server');- expect(configsXyz).toHaveProperty('xyz_private_server');+ it('should return servers from cache repository', async () => {+ // Add servers using public API+ await registry.addServer('app_server', testRawConfig, 'CACHE');+ await registry.addServer('user_server', testRawConfig, 'CACHE');++ // Get all configs+ const configs = await registry.getAllServerConfigs();+ expect(Object.keys(configs)).toHaveLength(2);+ expect(configs).toHaveProperty('app_server');+ expect(configs).toHaveProperty('user_server');});});describe('reset', () => {- it('should clear all servers from all caches (shared app, shared user, and private user)', async () => {- const userId = 'user123';+ it('should clear all servers from cache repository', async () => {+ // Add servers+ await registry.addServer('app_server', testRawConfig, 'CACHE');+ await registry.addServer('user_server', testRawConfig, 'CACHE');- // Add servers to all three caches- await registry.sharedAppServers.add('app_server', testParsedConfig);- await registry.sharedUserServers.add('user_server', testParsedConfig);- await registry.privateServersCache.add(userId, 'private_server', testParsedConfig);-- // Verify all servers are accessible before reset- const appConfigBefore = await registry.getServerConfig('app_server');- const userConfigBefore = await registry.getServerConfig('user_server', userId);- const privateConfigBefore = await registry.getServerConfig('private_server', userId);- const allConfigsBefore = await registry.getAllServerConfigs(userId);-- expect(appConfigBefore).toMatchObject(testParsedConfig);- expect(userConfigBefore).toMatchObject(testParsedConfig);- expect(privateConfigBefore).toMatchObject(testParsedConfig);- expect(Object.keys(allConfigsBefore)).toHaveLength(3);+ // Verify servers exist+ const configsBefore = await registry.getAllServerConfigs();+ expect(Object.keys(configsBefore)).toHaveLength(2);// Reset everythingawait registry.reset();- // Verify all servers are cleared after reset- const appConfigAfter = await registry.getServerConfig('app_server');- const userConfigAfter = await registry.getServerConfig('user_server');- const privateConfigAfter = await registry.getServerConfig('private_server', userId);- const allConfigsAfter = await registry.getAllServerConfigs(userId);-- expect(appConfigAfter).toBeUndefined();- expect(userConfigAfter).toBeUndefined();- expect(privateConfigAfter).toBeUndefined();- expect(Object.keys(allConfigsAfter)).toHaveLength(0);+ // Verify all servers are cleared+ const configsAfter = await registry.getAllServerConfigs();+ expect(Object.keys(configsAfter)).toHaveLength(0);});});});diff --git a/packages/api/src/mcp/registry/__tests__/MCPServersRegistry.test.ts b/packages/api/src/mcp/registry/__tests__/MCPServersRegistry.test.tsindex b7f67bbff4..30b9e8984c 100644--- a/packages/api/src/mcp/registry/__tests__/MCPServersRegistry.test.ts+++ b/packages/api/src/mcp/registry/__tests__/MCPServersRegistry.test.ts@@ -1,5 +1,10 @@import * as t from '~/mcp/types';import { mcpServersRegistry as registry } from '~/mcp/registry/MCPServersRegistry';+import { MCPServerInspector } from '~/mcp/registry/MCPServerInspector';++// Mock MCPServerInspector to avoid actual server connections+jest.mock('~/mcp/registry/MCPServerInspector');+const FIXED_TIME = 1699564800000;const originalDateNow = Date.now;Date.now = jest.fn(() => FIXED_TIME);@@ -36,220 +41,55 @@ describe('MCPServersRegistry', () => {Date.now = originalDateNow;});beforeEach(async () => {+ // Mock MCPServerInspector.inspect to return the config that's passed in+ jest+ .spyOn(MCPServerInspector, 'inspect')+ .mockImplementation(async (_serverName: string, rawConfig: t.MCPOptions) => {+ return {+ ...testParsedConfig,+ ...rawConfig,+ requiresOAuth: false,+ } as unknown as t.ParsedServerConfig;+ });await registry.reset();});- describe('private user servers', () => {- it('should add and remove private user server', async () => {- const userId = 'user123';- const serverName = 'private_server';-- // Add private user server- await registry.privateServersCache.add(userId, serverName, testParsedConfig);-- // Verify server was added- const retrievedConfig = await registry.getServerConfig(serverName, userId);- expect(retrievedConfig).toEqual(testParsedConfig);-- // Remove private user server- await registry.privateServersCache.remove(userId, serverName);-- // Verify server was removed- const configAfterRemoval = await registry.getServerConfig(serverName, userId);- expect(configAfterRemoval).toBeUndefined();- });-- it('should throw error when adding duplicate private user server', async () => {- const userId = 'user123';- const serverName = 'private_server';-- await registry.privateServersCache.add(userId, serverName, testParsedConfig);- await expect(- registry.privateServersCache.add(userId, serverName, testParsedConfig),- ).rejects.toThrow(- 'Server "private_server" already exists in cache. Use update() to modify existing configs.',- );- });-- it('should update an existing private user server', async () => {- const userId = 'user123';- const serverName = 'private_server';- const updatedConfig: t.ParsedServerConfig = {- type: 'stdio',- command: 'python',- args: ['updated.py'],- requiresOAuth: true,- lastUpdatedAt: FIXED_TIME,- };-- // Add private user server- await registry.privateServersCache.add(userId, serverName, testParsedConfig);-- // Update the server config- await registry.privateServersCache.update(userId, serverName, updatedConfig);-- // Verify server was updated- const retrievedConfig = await registry.getServerConfig(serverName, userId);- expect(retrievedConfig).toEqual(updatedConfig);- });-- it('should throw error when updating non-existent server', async () => {- const userId = 'user123';- const serverName = 'private_server';-- // Add a user cache first- await registry.privateServersCache.add(userId, 'other_server', testParsedConfig);-- await expect(- registry.privateServersCache.update(userId, serverName, testParsedConfig),- ).rejects.toThrow(- 'Server "private_server" does not exist in cache. Use add() to create new configs.',- );- });-- it('should throw error when updating non-existent server (lazy-loads cache)', async () => {- const userId = 'nonexistent_user';- const serverName = 'private_server';-- // With lazy-loading, cache is created but server doesn't exist in it- await expect(- registry.privateServersCache.update(userId, serverName, testParsedConfig),- ).rejects.toThrow(- 'Server "private_server" does not exist in cache. Use add() to create new configs.',- );- });- });-- describe('getPrivateServerConfig', () => {- it('should retrieve private server config for a specific user', async () => {- const userId = 'user123';- const serverName = 'private_server';-- await registry.privateServersCache.add(userId, serverName, testParsedConfig);-- const retrievedConfig = await registry.privateServersCache.get(userId, serverName);- expect(retrievedConfig).toEqual(testParsedConfig);- });-- it('should return undefined if server does not exist in user private cache', async () => {- const userId = 'user123';+ // Tests for the old privateServersCache API have been removed+ // The refactoring simplified the architecture to use unified repositories (cache + DB)+ // instead of the three-tier system (sharedAppServers, sharedUserServers, privateServersCache)- // Create a cache for this user with a different server- await registry.privateServersCache.add(userId, 'other_server', testParsedConfig);-- // Try to get a server that doesn't exist- const retrievedConfig = await registry.privateServersCache.get(userId, 'nonexistent_server');- expect(retrievedConfig).toBeUndefined();- });-- it('should return undefined when user has no private servers (lazy-loads cache)', async () => {- const userId = 'user_with_no_cache';-- // With lazy-loading, cache is created but is empty- const config = await registry.privateServersCache.get(userId, 'server_name');- expect(config).toBeUndefined();- });-- it('should isolate private servers between different users', async () => {- const user1 = 'user1';- const user2 = 'user2';- const serverName = 'shared_name_server';-- const config1: t.ParsedServerConfig = {- ...testParsedConfig,- args: ['user1.js'],- };- const config2: t.ParsedServerConfig = {- ...testParsedConfig,- args: ['user2.js'],- };-- await registry.privateServersCache.add(user1, serverName, config1);- await registry.privateServersCache.add(user2, serverName, config2);-- const user1Config = await registry.privateServersCache.get(user1, serverName);- const user2Config = await registry.privateServersCache.get(user2, serverName);-- // Verify each user gets their own config- expect(user1Config).toBeDefined();- expect(user2Config).toBeDefined();- if (user1Config && 'args' in user1Config) {- expect(user1Config.args).toEqual(['user1.js']);- }- if (user2Config && 'args' in user2Config) {- expect(user2Config.args).toEqual(['user2.js']);- }- });-- it('should not retrieve shared servers through privateServersCache.get', async () => {- const userId = 'user123';-- // Add servers to shared caches- await registry.sharedAppServers.add('app_server', testParsedConfig);- await registry.sharedUserServers.add('user_server', testParsedConfig);-- // Create a private cache for the user (but don't add these servers to it)- await registry.privateServersCache.add(userId, 'private_server', testParsedConfig);-- // Try to get shared servers using privateServersCache.get - should return undefined- // because privateServersCache.get only looks at private cache, not shared caches- const appServerConfig = await registry.privateServersCache.get(userId, 'app_server');- const userServerConfig = await registry.privateServersCache.get(userId, 'user_server');-- expect(appServerConfig).toBeUndefined();- expect(userServerConfig).toBeUndefined();- });- });+ // Tests for getPrivateServerConfig have been removed+ // The new architecture uses getServerConfig() which checks cache first, then DB+ // Private server functionality is now handled by the DB repository (not yet implemented)describe('getAllServerConfigs', () => {- it('should return correct servers based on userId', async () => {- // Add servers to all three caches- await registry.sharedAppServers.add('app_server', testParsedConfig);- await registry.sharedUserServers.add('user_server', testParsedConfig);- await registry.privateServersCache.add('abc', 'abc_private_server', testParsedConfig);- await registry.privateServersCache.add('xyz', 'xyz_private_server', testParsedConfig);-- // Without userId: should return only shared app + shared user servers- const configsNoUser = await registry.getAllServerConfigs();- expect(Object.keys(configsNoUser)).toHaveLength(2);- expect(configsNoUser).toHaveProperty('app_server');- expect(configsNoUser).toHaveProperty('user_server');-- // With userId 'abc': should return shared app + shared user + abc's private servers- const configsAbc = await registry.getAllServerConfigs('abc');- expect(Object.keys(configsAbc)).toHaveLength(3);- expect(configsAbc).toHaveProperty('app_server');- expect(configsAbc).toHaveProperty('user_server');- expect(configsAbc).toHaveProperty('abc_private_server');-- // With userId 'xyz': should return shared app + shared user + xyz's private servers- const configsXyz = await registry.getAllServerConfigs('xyz');- expect(Object.keys(configsXyz)).toHaveLength(3);- expect(configsXyz).toHaveProperty('app_server');- expect(configsXyz).toHaveProperty('user_server');- expect(configsXyz).toHaveProperty('xyz_private_server');+ it('should return servers from cache repository', async () => {+ // Add servers to cache using the new API+ await registry['cacheConfigsRepo'].add('app_server', testParsedConfig);+ await registry['cacheConfigsRepo'].add('user_server', testParsedConfig);++ // getAllServerConfigs should return configs from cache (DB is not implemented yet)+ const configs = await registry.getAllServerConfigs();+ expect(Object.keys(configs)).toHaveLength(2);+ expect(configs).toHaveProperty('app_server');+ expect(configs).toHaveProperty('user_server');});});describe('reset', () => {- it('should clear all servers from all caches (shared app, shared user, and private user)', async () => {- const userId = 'user123';+ it('should clear all servers from cache repository', async () => {+ // Add servers to cache using the new API+ await registry.addServer('app_server', testParsedConfig, 'CACHE');+ await registry.addServer('user_server', testParsedConfig, 'CACHE');- // Add servers to all three caches- await registry.sharedAppServers.add('app_server', testParsedConfig);- await registry.sharedUserServers.add('user_server', testParsedConfig);- await registry.privateServersCache.add(userId, 'private_server', testParsedConfig);-- // Verify all servers are accessible before reset+ // Verify servers are accessible before resetconst appConfigBefore = await registry.getServerConfig('app_server');- const userConfigBefore = await registry.getServerConfig('user_server', userId);- const privateConfigBefore = await registry.getServerConfig('private_server', userId);- const allConfigsBefore = await registry.getAllServerConfigs(userId);+ const userConfigBefore = await registry.getServerConfig('user_server');+ const allConfigsBefore = await registry.getAllServerConfigs();expect(appConfigBefore).toEqual(testParsedConfig);expect(userConfigBefore).toEqual(testParsedConfig);- expect(privateConfigBefore).toEqual(testParsedConfig);- expect(Object.keys(allConfigsBefore)).toHaveLength(3);+ expect(Object.keys(allConfigsBefore)).toHaveLength(2);// Reset everythingawait registry.reset();@@ -257,13 +97,72 @@ describe('MCPServersRegistry', () => {// Verify all servers are cleared after resetconst appConfigAfter = await registry.getServerConfig('app_server');const userConfigAfter = await registry.getServerConfig('user_server');- const privateConfigAfter = await registry.getServerConfig('private_server', userId);- const allConfigsAfter = await registry.getAllServerConfigs(userId);+ const allConfigsAfter = await registry.getAllServerConfigs();expect(appConfigAfter).toBeUndefined();expect(userConfigAfter).toBeUndefined();- expect(privateConfigAfter).toBeUndefined();expect(Object.keys(allConfigsAfter)).toHaveLength(0);});});++ describe('Storage location routing (getConfigRepository)', () => {+ describe('CACHE storage location', () => {+ it('should route addServer to cache repository', async () => {+ await registry.addServer('cache_server', testParsedConfig, 'CACHE');++ const config = await registry.getServerConfig('cache_server');+ expect(config).toBeDefined();+ expect(config?.type).toBe('stdio');+ if (config && 'command' in config) {+ expect(config.command).toBe('node');+ }+ });++ it('should route updateServer to cache repository', async () => {+ await registry.addServer('cache_server', testParsedConfig, 'CACHE');++ const updatedConfig = { ...testParsedConfig, command: 'python' } as t.ParsedServerConfig;+ await registry.updateServer('cache_server', updatedConfig, 'CACHE');++ const config = await registry.getServerConfig('cache_server');+ expect(config).toBeDefined();+ if (config && 'command' in config) {+ expect(config.command).toBe('python');+ }+ });++ it('should route removeServer to cache repository', async () => {+ await registry.addServer('cache_server', testParsedConfig, 'CACHE');+ expect(await registry.getServerConfig('cache_server')).toBeDefined();++ await registry.removeServer('cache_server', 'CACHE');++ const config = await registry.getServerConfig('cache_server');+ expect(config).toBeUndefined();+ });+ });++ describe('Invalid storage location', () => {+ it('should throw error for unsupported storage location in addServer', async () => {+ await expect(+ // eslint-disable-next-line @typescript-eslint/no-explicit-any+ registry.addServer('test_server', testParsedConfig, 'INVALID' as any),+ ).rejects.toThrow('The provided storage location "INVALID" is not supported');+ });++ it('should throw error for unsupported storage location in updateServer', async () => {+ await expect(+ // eslint-disable-next-line @typescript-eslint/no-explicit-any+ registry.updateServer('test_server', testParsedConfig, 'REDIS' as any),+ ).rejects.toThrow('The provided storage location "REDIS" is not supported');+ });++ it('should throw error for unsupported storage location in removeServer', async () => {+ // eslint-disable-next-line @typescript-eslint/no-explicit-any+ await expect(registry.removeServer('test_server', 'S3' as any)).rejects.toThrow(+ 'The provided storage location "S3" is not supported',+ );+ });+ });+ });});diff --git a/packages/api/src/mcp/registry/cache/PrivateServerConfigs/PrivateServerConfigsCacheBase.ts b/packages/api/src/mcp/registry/cache/PrivateServerConfigs/PrivateServerConfigsCacheBase.tsdeleted file mode 100644index 791971c7ec..0000000000--- a/packages/api/src/mcp/registry/cache/PrivateServerConfigs/PrivateServerConfigsCacheBase.ts+++ /dev/null@@ -1,115 +0,0 @@-import type * as t from '~/mcp/types';-import { ServerConfigsCache, ServerConfigsCacheFactory } from '../ServerConfigsCacheFactory';-import { logger } from '@librechat/data-schemas';--export abstract class PrivateServerConfigsCacheBase {- protected readonly PREFIX = 'MCP::ServersRegistry::Servers::Private';- protected caches: Map<string, ServerConfigsCache> = new Map();-- public async add(- userId: string,- serverName: string,- config: t.ParsedServerConfig,- ): Promise<void> {- const userCache = this.getOrCreatePrivateUserCache(userId);- await userCache.add(serverName, config);- }-- public async update(- userId: string,- serverName: string,- config: t.ParsedServerConfig,- ): Promise<void> {- const userCache = this.getOrCreatePrivateUserCache(userId);- await userCache.update(serverName, config);- }-- /**- * Get a specific server config from a user's cache.- */- public async get(userId: string, serverName: string): Promise<t.ParsedServerConfig | undefined> {- const cache = this.getOrCreatePrivateUserCache(userId);- return await cache.get(serverName);- }-- /**- * Get all server configs for a user.- */- public async getAll(userId: string): Promise<Record<string, t.ParsedServerConfig>> {- const cache = this.getOrCreatePrivateUserCache(userId);- return await cache.getAll();- }-- /**- * Check if a user has a cache instance loaded.- */- public abstract has(userId: string): Promise<boolean>;-- public async remove(userId: string, serverName: string): Promise<void> {- const userCache = this.getOrCreatePrivateUserCache(userId);- await userCache.remove(serverName);- }-- public async reset(userId: string): Promise<void> {- const cache = this.getOrCreatePrivateUserCache(userId);- return cache.reset();- }-- // ============= BATCH OPERATION PRIMITIVES =============- // Simple primitives for MCPPrivateServerLoader orchestration - no business logic-- /**- * Update server config in ALL user caches that already have it.- * Efficient: Uses pattern-based scan, skips users who don't have it.- * Use case: Metadata changed (command, args, env)- */- public abstract updateServerConfigIfExists(- serverName: string,- config: t.ParsedServerConfig,- ): Promise<void>;-- /**- * Add server config ONLY to users whose caches are already initialized.- * Skips users without initialized caches (doesn't create new caches).- * Use case: Granting access to existing users- */- public abstract addServerConfigIfCacheExists(- userIds: string[],- serverName: string,- config: t.ParsedServerConfig,- ): Promise<void>;-- /**- * Remove server config ONLY from users whose caches exist.- * Ignores users without initialized caches.- * Use case: Revoking access from users- */- public abstract removeServerConfigIfCacheExists(- userIds: string[],- serverName: string,- ): Promise<void>;-- /**- * Find all users who have this server in their cache.- * Primitive for determining affected users.- */- public abstract findUsersWithServer(serverName: string): Promise<string[]>;-- /**- * Clear all private server configs for all users (nuclear option).- * Use sparingly - typically only for testing or full reset.- */- public abstract resetAll(): Promise<void>;-- protected getOrCreatePrivateUserCache(userId: string): ServerConfigsCache {- if (!userId) {- logger.error('userId is required to get or create private user cache');- throw new Error('userId is required to get or create private user cache');- }- if (!this.caches.has(userId)) {- const cache = ServerConfigsCacheFactory.create(userId, 'Private', false);- this.caches.set(userId, cache);- }- return this.caches.get(userId)!;- }-}diff --git a/packages/api/src/mcp/registry/cache/PrivateServerConfigs/PrivateServerConfigsCacheFactory.ts b/packages/api/src/mcp/registry/cache/PrivateServerConfigs/PrivateServerConfigsCacheFactory.tsdeleted file mode 100644index 6a91909b52..0000000000--- a/packages/api/src/mcp/registry/cache/PrivateServerConfigs/PrivateServerConfigsCacheFactory.ts+++ /dev/null@@ -1,32 +0,0 @@-import { cacheConfig } from '~/cache';--import { PrivateServerConfigsCacheInMemory } from './PrivateServerConfigsCacheInMemory';-import { PrivateServerConfigsCacheRedis } from './PrivateServerConfigsCacheRedis';--export type PrivateServerConfigsCache =- | PrivateServerConfigsCacheInMemory- | PrivateServerConfigsCacheRedis;--/**- * Factory for creating the appropriate PrivateServerConfigsCache implementation based on deployment mode.- * Automatically selects between in-memory and Redis-backed storage depending on USE_REDIS config.- * In single-instance mode (USE_REDIS=false), returns lightweight in-memory cache.- * In cluster mode (USE_REDIS=true), returns Redis-backed cache with distributed coordination.- * Provides a unified interface regardless of the underlying storage mechanism.- */-export class PrivateServerConfigsCacheFactory {- /**- * Create a ServerConfigsCache instance.- * Returns Redis implementation if Redis is configured, otherwise in-memory implementation.- *- * @returns PrivateServerConfigsCache instance- */- static create(): PrivateServerConfigsCache {- if (cacheConfig.USE_REDIS) {- return new PrivateServerConfigsCacheRedis();- }-- // In-memory mode uses a simple Map - doesn't need owner/namespace- return new PrivateServerConfigsCacheInMemory();- }-}diff --git a/packages/api/src/mcp/registry/cache/PrivateServerConfigs/PrivateServerConfigsCacheInMemory.ts b/packages/api/src/mcp/registry/cache/PrivateServerConfigs/PrivateServerConfigsCacheInMemory.tsdeleted file mode 100644index 7b237c536e..0000000000--- a/packages/api/src/mcp/registry/cache/PrivateServerConfigs/PrivateServerConfigsCacheInMemory.ts+++ /dev/null@@ -1,105 +0,0 @@-import { ParsedServerConfig } from '~/mcp/types';-import { PrivateServerConfigsCacheBase } from './PrivateServerConfigsCacheBase';-import { logger } from '@librechat/data-schemas';-import { ServerConfigsCacheInMemory } from '../ServerConfigsCacheInMemory';--export class PrivateServerConfigsCacheInMemory extends PrivateServerConfigsCacheBase {- public async has(userId: string): Promise<boolean> {- return this.caches.has(userId);- }-- public async updateServerConfigIfExists(- serverName: string,- config: ParsedServerConfig,- ): Promise<void> {- let updatedCount = 0;-- for (const [userId, userCache] of this.caches.entries()) {- const existing = await userCache.get(serverName);- if (existing) {- const inMemoryCache = userCache as ServerConfigsCacheInMemory;- await inMemoryCache.set(serverName, config);- updatedCount++;- logger.debug(`[MCP][PrivateServers][InMemory] Updated "${serverName}" for user ${userId}`);- }- }-- logger.info(- `[MCP][PrivateServers][InMemory] Propagated config update for "${serverName}" to ${updatedCount} users`,- );- }-- public async addServerConfigIfCacheExists(- userIds: string[],- serverName: string,- config: ParsedServerConfig,- ): Promise<void> {- let addedCount = 0;-- for (const userId of userIds) {- if (this.caches.has(userId)) {- // Only if cache initialized- const userCache = this.getOrCreatePrivateUserCache(userId);- const inMemoryCache = userCache as ServerConfigsCacheInMemory;- await inMemoryCache.set(serverName, config);- addedCount++;- logger.debug(`[MCP][PrivateServers][InMemory] Added "${serverName}" to user ${userId}`);- }- }-- logger.info(- `[MCP][PrivateServers][InMemory] Granted access to "${serverName}" for ${addedCount}/${userIds.length} initialized users`,- );- }-- public async removeServerConfigIfCacheExists(- userIds: string[],- serverName: string,- ): Promise<void> {- let removedCount = 0;-- for (const userId of userIds) {- if (this.caches.has(userId)) {- try {- const userCache = this.getOrCreatePrivateUserCache(userId);- await userCache.remove(serverName);- removedCount++;- logger.debug(- `[MCP][PrivateServers][InMemory] Removed "${serverName}" from user ${userId}`,- );- } catch (error) {- // Ignore - server might not exist for this user- logger.debug(- `[MCP][PrivateServers][InMemory] Server "${serverName}" not found for user ${userId}`,- error,- );- }- }- }-- logger.info(- `[MCP][PrivateServers][InMemory] Revoked access to "${serverName}" from ${removedCount}/${userIds.length} users`,- );- }-- public async findUsersWithServer(serverName: string): Promise<string[]> {- const userIds: string[] = [];-- for (const [userId, userCache] of this.caches.entries()) {- const config = await userCache.get(serverName);- if (config) {- userIds.push(userId);- }- }-- return userIds;- }-- /**- * Clear ALL servers from ALL user caches (nuclear option).- */- public async resetAll(): Promise<void> {- this.caches.clear();- logger.info(`[MCP][PrivateServers][InMemory] Cleared ALL user caches`);- }-}diff --git a/packages/api/src/mcp/registry/cache/PrivateServerConfigs/PrivateServerConfigsCacheRedis.ts b/packages/api/src/mcp/registry/cache/PrivateServerConfigs/PrivateServerConfigsCacheRedis.tsdeleted file mode 100644index fdd88b1f4d..0000000000--- a/packages/api/src/mcp/registry/cache/PrivateServerConfigs/PrivateServerConfigsCacheRedis.ts+++ /dev/null@@ -1,284 +0,0 @@-import { ParsedServerConfig } from '~/mcp/types';-import { keyvRedisClient } from '~/cache';-import { PrivateServerConfigsCacheBase } from './PrivateServerConfigsCacheBase';-import { logger } from '@librechat/data-schemas';-import { cacheConfig } from '~/cache/cacheConfig';-import { batchDeleteKeys, scanKeys } from '~/cache/redisUtils';--export class PrivateServerConfigsCacheRedis extends PrivateServerConfigsCacheBase {- /**- * Detect if Redis is running in cluster mode.- * In cluster mode, we need to avoid CROSSSLOT errors by using pipelines instead of multi() transactions.- */- private isClusterMode(): boolean {- return cacheConfig.USE_REDIS_CLUSTER;- }-- public async has(userId: string): Promise<boolean> {- if (!userId || !keyvRedisClient || !('scanIterator' in keyvRedisClient)) {- return false;- }-- const pattern = `*${this.PREFIX}::${userId}:*`;-- for await (const _key of keyvRedisClient.scanIterator({- MATCH: pattern,- COUNT: 1,- })) {- return true;- }-- return false; // No keys found - cache not initialized- }-- public async updateServerConfigIfExists(- serverName: string,- config: ParsedServerConfig,- ): Promise<void> {- if (!keyvRedisClient || !('scanIterator' in keyvRedisClient)) {- logger.warn('[MCP][PrivateServers][Redis] Redis SCAN not available');- return;- }-- const pattern = this.generateScanKeyPattern(serverName);-- try {- // Efficient: Pattern-based scan for specific serverName- // All cache keys that have the serverName- const keysToUpdate = await scanKeys(keyvRedisClient, pattern);-- if (keysToUpdate.length > 0) {- const updatedConfig = { ...config, lastUpdatedAt: Date.now() };- const keyvFormat = { value: updatedConfig, expires: null };- const serializedConfig = JSON.stringify(keyvFormat);-- const chunkSize = cacheConfig.REDIS_UPDATE_CHUNK_SIZE;-- if (this.isClusterMode()) {- // Cluster mode: Use individual commands in parallel (no atomicity, but works across slots)- for (let i = 0; i < keysToUpdate.length; i += chunkSize) {- const chunk = keysToUpdate.slice(i, i + chunkSize);- await Promise.all(- chunk.map((key) => keyvRedisClient!.set(key, serializedConfig, { XX: true })),- );- }- } else {- // Single-node mode: Use multi() for atomic transactions- for (let i = 0; i < keysToUpdate.length; i += chunkSize) {- const chunk = keysToUpdate.slice(i, i + chunkSize);- const multi = keyvRedisClient.multi();- for (const key of chunk) {- multi.set(key, serializedConfig, { XX: true });- }- await multi.exec();- }- }-- logger.info(- `[MCP][PrivateServers][Redis] Propagated config update for "${serverName}" to ${keysToUpdate.length} users`,- );- } else {- logger.debug(`[MCP][PrivateServers][Redis] No users have "${serverName}"`);- }- } catch (error) {- logger.error(`[MCP][PrivateServers][Redis] Error updating "${serverName}"`, error);- throw error;- }- }-- public async addServerConfigIfCacheExists(- userIds: string[],- serverName: string,- config: ParsedServerConfig,- ): Promise<void> {- if (!keyvRedisClient) return;-- // Optimized: Single SCAN to get all users with initialized caches- const allUsersWithCaches = await this.getAllUserIds();-- // Filter to only users with initialized caches- const eligibleUserIds = userIds.filter((id) => allUsersWithCaches.has(id));-- if (eligibleUserIds.length === 0) {- logger.info(- `[MCP][PrivateServers][Redis] No initialized users to grant access to "${serverName}"`,- );- return;- }-- // Batch add using pipeline with NX (only set if key doesn't exist)- const updatedConfig = { ...config, lastUpdatedAt: Date.now() };- const keyvFormat = { value: updatedConfig, expires: null };- const serializedConfig = JSON.stringify(keyvFormat);-- const globalPrefix = cacheConfig.REDIS_KEY_PREFIX;- const separator = cacheConfig.GLOBAL_PREFIX_SEPARATOR;-- const chunkSize = cacheConfig.REDIS_UPDATE_CHUNK_SIZE;-- if (this.isClusterMode()) {- // Cluster mode: Use individual commands in parallel (no atomicity, but works across slots)- for (let i = 0; i < eligibleUserIds.length; i += chunkSize) {- const chunk = eligibleUserIds.slice(i, i + chunkSize);- await Promise.all(- chunk.map((userId) => {- const namespace = `${this.PREFIX}::${userId}`;- const fullKey = globalPrefix- ? `${globalPrefix}${separator}${namespace}:${serverName}`- : `${namespace}:${serverName}`;- return keyvRedisClient!.set(fullKey, serializedConfig, { NX: true });- }),- );- }- } else {- // Single-node mode: Use multi() for atomic transactions- for (let i = 0; i < eligibleUserIds.length; i += chunkSize) {- const chunk = eligibleUserIds.slice(i, i + chunkSize);- const multi = keyvRedisClient.multi();- for (const userId of chunk) {- const namespace = `${this.PREFIX}::${userId}`;- const fullKey = globalPrefix- ? `${globalPrefix}${separator}${namespace}:${serverName}`- : `${namespace}:${serverName}`;- multi.set(fullKey, serializedConfig, { NX: true });- }- await multi.exec();- }- }-- logger.info(- `[MCP][PrivateServers][Redis] Granted access to "${serverName}" for ${eligibleUserIds.length}/${userIds.length} initialized users`,- );- }-- public async removeServerConfigIfCacheExists(- userIds: string[],- serverName: string,- ): Promise<void> {- if (!keyvRedisClient) return;-- // Optimized: Direct key construction - no SCAN needed!- // Build full Redis keys directly since we know userId and serverName- const globalPrefix = cacheConfig.REDIS_KEY_PREFIX;- const separator = cacheConfig.GLOBAL_PREFIX_SEPARATOR;- const keysToDelete: string[] = [];-- for (const userId of userIds) {- // Construct the full Redis key- const namespace = `${this.PREFIX}::${userId}`;- const fullKey = globalPrefix- ? `${globalPrefix}${separator}${namespace}:${serverName}`- : `${namespace}:${serverName}`;- keysToDelete.push(fullKey);- }-- if (keysToDelete.length > 0) {- // Use utility function for efficient parallel deletion- const removedCount = await batchDeleteKeys(keyvRedisClient, keysToDelete);-- logger.info(- `[MCP][PrivateServers][Redis] Revoked access to "${serverName}" from ${removedCount}/${userIds.length} users`,- );- }- }-- public async findUsersWithServer(serverName: string): Promise<string[]> {- if (!keyvRedisClient || !('scanIterator' in keyvRedisClient)) {- return [];- }-- const pattern = this.generateScanKeyPattern(serverName);-- try {- const keys = await scanKeys(keyvRedisClient, pattern);- const userIds: string[] = [];-- for (const key of keys) {- const userId = this.extractUserIdFromKey(key);- if (userId) {- userIds.push(userId);- }- }-- return userIds;- } catch (error) {- logger.error(`[MCP][PrivateServers][Redis] Error finding users with "${serverName}"`, error);- return [];- }- }-- /**- * Scans Redis to find all unique userIds that have private server configs.- * This method is used for efficient batch operations (add/update/delete) across all users.- *- * Performance note: This scans all private server config keys in Redis.- * Use sparingly as it can be expensive with many users.- */- private async getAllUserIds(): Promise<Set<string>> {- if (!keyvRedisClient || !('scanIterator' in keyvRedisClient)) {- logger.warn('[MCP][PrivateServerConfigs][Redis] Redis SCAN not available');- return new Set();- }-- const userIds = new Set<string>();- // Pattern to match all private server configs: MCP::ServersRegistry::Servers::*:*- const pattern = `*${this.PREFIX}::*:*`;-- try {- const keys = await scanKeys(keyvRedisClient, pattern);-- for (const key of keys) {- const userId = this.extractUserIdFromKey(key);- if (userId) {- userIds.add(userId);- }- }- } catch (error) {- logger.error('[MCP][PrivateServerConfigs][Redis] Error scanning for userIds', error);- throw error;- }-- return userIds;- }-- /**- * Extract userId from a Redis key.- * Key format: MCP::ServersRegistry::Servers::userId:serverName- */- private extractUserIdFromKey(key: string): string | null {- // Remove any global prefix, then extract userId- const keyWithoutGlobalPrefix = key.includes(this.PREFIX)- ? key.substring(key.indexOf(this.PREFIX))- : key;-- const withoutPrefix = keyWithoutGlobalPrefix.replace(`${this.PREFIX}::`, '');- const lastColonIndex = withoutPrefix.lastIndexOf(':');- if (lastColonIndex === -1) return null;-- return withoutPrefix.substring(0, lastColonIndex);- }-- /**- * Clear ALL servers from ALL user caches (nuclear option).- */- public async resetAll(): Promise<void> {- if (!keyvRedisClient || !('scanIterator' in keyvRedisClient)) return;-- // Pattern to match all private user server configs- // Format: MCP::ServersRegistry::Servers::userId:serverName- const pattern = `*${this.PREFIX}::*:*`;-- // Use utility functions for efficient scan and parallel deletion- const keysToDelete = await scanKeys(keyvRedisClient, pattern);-- if (keysToDelete.length > 0) {- await batchDeleteKeys(keyvRedisClient, keysToDelete);- }-- logger.info(`[MCP][Cache][Redis] Cleared all user caches: ${keysToDelete.length} entries`);- }-- private generateScanKeyPattern(serverName: string): string {- return `*${this.PREFIX}::*:${serverName}`;- }-}diff --git a/packages/api/src/mcp/registry/cache/PrivateServersLoadStatusCache.ts b/packages/api/src/mcp/registry/cache/PrivateServersLoadStatusCache.tsdeleted file mode 100644index 2aafcf70d9..0000000000--- a/packages/api/src/mcp/registry/cache/PrivateServersLoadStatusCache.ts+++ /dev/null@@ -1,166 +0,0 @@-import { standardCache, keyvRedisClient } from '~/cache';-import { cacheConfig } from '~/cache/cacheConfig';-import { BaseRegistryCache } from './BaseRegistryCache';-import { logger } from '@librechat/data-schemas';--const LOADED_KEY_PREFIX = 'USER_PRIVATE_SERVERS_LOADED';-const LOCK_KEY_PREFIX = 'USER_PRIVATE_SERVERS_LOAD_LOCK';--// Default TTL values (in milliseconds)-const DEFAULT_LOADED_TTL = 3600 * 1000; // 1 hour - should match cache entry TTL-const DEFAULT_LOCK_TTL = 30 * 1000; // 30 seconds - lock timeout-const DEFAULT_WAIT_INTERVAL = 100; // 100ms between checks--/**- * Dedicated cache for managing private server loading status with TTL synchronization.- * Solves three critical issues:- * 1. TTL Synchronization: Loaded flags expire in sync with cache entries- * 2. Cache Eviction Detection: When cache expires, flag expires too- * 3. Race Condition Prevention: Distributed locking prevents concurrent loads- *- * Design:- * - Loaded flags have same TTL as cache entries (prevents desync)- * - Distributed locks prevent multiple processes loading same user- * - Wait mechanism allows processes to wait for ongoing loads- * - Works correctly for users with 0 servers (trusts TTL, no cache verification)- */-class PrivateServersLoadStatusCache extends BaseRegistryCache {- protected readonly cache = standardCache(`${this.PREFIX}::PrivateServersLoadStatus`);-- /**- * Check if user's private servers are fully loaded.- * If false, servers need to be loaded from DB.- *- * @param userId - User ID- * @returns true if user's private servers are fully loaded- */- public async isLoaded(userId: string): Promise<boolean> {- const key = `${LOADED_KEY_PREFIX}::${userId}`;- return (await this.cache.get(key)) === true;- }-- /**- * Mark user's private servers as fully loaded with TTL.- * TTL MUST match the cache entry TTL to prevent desync.- *- * @param userId - User ID- * @param ttl - Time to live in milliseconds (default: 1 hour)- */- public async setLoaded(userId: string, ttl: number = DEFAULT_LOADED_TTL): Promise<void> {- const key = `${LOADED_KEY_PREFIX}::${userId}`;- const success = await this.cache.set(key, true, ttl);- this.successCheck(`set loaded status for user ${userId}`, success);- logger.debug(`[MCP][LoadStatusCache] Marked user ${userId} as loaded (TTL: ${ttl}ms)`);- }-- /**- * Acquire a distributed lock for loading a user's private servers.- * Prevents concurrent processes from loading the same user's servers.- *- * Uses atomic Redis SET NX PX for race-free locking.- * Returns true immediately if Redis is not available (no locking needed in single-process mode).- *- * @param userId - User ID- * @param ttl - Lock timeout in milliseconds (default: 30s)- * @returns true if lock acquired, false if already locked- */- public async acquireLoadLock(userId: string, ttl: number = DEFAULT_LOCK_TTL): Promise<boolean> {- const key = `${LOCK_KEY_PREFIX}::${userId}`;-- // Distributed locking only needed when Redis is available (multi-instance mode)- if (!keyvRedisClient || !('set' in keyvRedisClient)) {- logger.debug(`[MCP][LoadStatusCache] Redis not available, skipping lock for user ${userId}`);- return true;- }-- try {- // Build the full Redis key (accounting for namespace and global prefix)- const namespace = `${this.PREFIX}::PrivateServersLoadStatus`;- const globalPrefix = cacheConfig.REDIS_KEY_PREFIX;- const separator = cacheConfig.GLOBAL_PREFIX_SEPARATOR;- const fullKey = globalPrefix- ? `${globalPrefix}${separator}${namespace}:${key}`- : `${namespace}:${key}`;-- // Redis SET with NX (only if not exists) and PX (millisecond expiry) - ATOMIC!- const result = await keyvRedisClient.set(fullKey, Date.now().toString(), {- NX: true, // Only set if key doesn't exist- PX: ttl, // Expiry in milliseconds- });-- const acquired = result === 'OK';-- if (acquired) {- logger.debug(- `[MCP][LoadStatusCache] Acquired load lock for user ${userId} (TTL: ${ttl}ms)`,- );- } else {- logger.debug(`[MCP][LoadStatusCache] Load lock already held for user ${userId}`);- }-- return acquired;- } catch (error) {- logger.error(`[MCP][LoadStatusCache] Error acquiring lock for user ${userId}:`, error);- return false;- }- }-- /**- * Release the distributed lock for a user's private server loading.- * Should be called in a finally block to ensure lock is always released.- *- * @param userId - User ID- */- public async releaseLoadLock(userId: string): Promise<void> {- const key = `${LOCK_KEY_PREFIX}::${userId}`;- await this.cache.delete(key);- logger.debug(`[MCP][LoadStatusCache] Released load lock for user ${userId}`);- }-- /**- * Wait for another process to finish loading a user's private servers.- * Used when a lock is already held by another process.- *- * @param userId - User ID- * @param maxWaitTime - Maximum time to wait in milliseconds (default: 5s)- * @param checkInterval - Interval between checks in milliseconds (default: 100ms)- * @returns true if loading completed within maxWaitTime, false if timeout- */- public async waitForLoad(- userId: string,- maxWaitTime: number = 5000,- checkInterval: number = DEFAULT_WAIT_INTERVAL,- ): Promise<boolean> {- const startTime = Date.now();-- while (Date.now() - startTime < maxWaitTime) {- const loaded = await this.isLoaded(userId);- if (loaded) {- logger.debug(`[MCP][LoadStatusCache] User ${userId} loading completed by another process`);- return true;- }-- // Wait before checking again- await new Promise((resolve) => setTimeout(resolve, checkInterval));- }-- logger.warn(- `[MCP][LoadStatusCache] Timeout waiting for user ${userId} loading (waited ${maxWaitTime}ms)`,- );- return false;- }-- /**- * Clear loaded status for a user.- * Used for testing or manual cache invalidation.- *- * @param userId - User ID- */- public async clearLoaded(userId: string): Promise<void> {- const key = `${LOADED_KEY_PREFIX}::${userId}`;- await this.cache.delete(key);- logger.debug(`[MCP][LoadStatusCache] Cleared loaded status for user ${userId}`);- }-}--export const privateServersLoadStatusCache = new PrivateServersLoadStatusCache();diff --git a/packages/api/src/mcp/registry/cache/RegistryStatusCache.ts b/packages/api/src/mcp/registry/cache/RegistryStatusCache.tsindex 6555eb291a..5fbd18ffdf 100644--- a/packages/api/src/mcp/registry/cache/RegistryStatusCache.ts+++ b/packages/api/src/mcp/registry/cache/RegistryStatusCache.ts@@ -9,9 +9,6 @@ const INITIALIZED = 'INITIALIZED';* Uses Redis-backed storage to coordinate state between leader and follower nodes.* Tracks global initialization status for the registry.*- * Note: Per-user private server loading status is tracked separately in PrivateServersLoadStatusCache- * to enable TTL synchronization and distributed locking.- ** Designed to be extended with additional global registry metadata as needed* (e.g., last update timestamps, version info, health status).* This cache is only meant to be used internally by registry management components.diff --git a/packages/api/src/mcp/registry/cache/ServerConfigsCacheFactory.ts b/packages/api/src/mcp/registry/cache/ServerConfigsCacheFactory.tsindex a707edfeba..ba0cec90ea 100644--- a/packages/api/src/mcp/registry/cache/ServerConfigsCacheFactory.ts+++ b/packages/api/src/mcp/registry/cache/ServerConfigsCacheFactory.ts@@ -16,20 +16,16 @@ export class ServerConfigsCacheFactory {* Create a ServerConfigsCache instance.* Returns Redis implementation if Redis is configured, otherwise in-memory implementation.*- * @param owner - The owner of the cache (e.g., 'user', 'global') - only used for Redis namespacing+ * @param namespace - The namespace for the cache (e.g., 'App') - only used for Redis namespacing* @param leaderOnly - Whether operations should only be performed by the leader (only applies to Redis)* @returns ServerConfigsCache instance*/- static create(- owner: string,- scope: 'Shared' | 'Private',- leaderOnly: boolean,- ): ServerConfigsCache {+ static create(namespace: string, leaderOnly: boolean): ServerConfigsCache {if (cacheConfig.USE_REDIS) {- return new ServerConfigsCacheRedis(owner, scope, leaderOnly);+ return new ServerConfigsCacheRedis(namespace, leaderOnly);}- // In-memory mode uses a simple Map - doesn't need owner/namespace+ // In-memory mode uses a simple Map - doesn't need namespacereturn new ServerConfigsCacheInMemory();}}diff --git a/packages/api/src/mcp/registry/cache/ServerConfigsCacheInMemory.ts b/packages/api/src/mcp/registry/cache/ServerConfigsCacheInMemory.tsindex 4261dd3b85..0e03bf8dff 100644--- a/packages/api/src/mcp/registry/cache/ServerConfigsCacheInMemory.ts+++ b/packages/api/src/mcp/registry/cache/ServerConfigsCacheInMemory.ts@@ -26,14 +26,6 @@ export class ServerConfigsCacheInMemory {this.cache.set(serverName, { ...config, lastUpdatedAt: Date.now() });}- /**- * Sets a server config without checking if it exists (upsert operation).- * Use this for bulk operations where you want to add or update without error handling.- */- public async set(serverName: string, config: ParsedServerConfig): Promise<void> {- this.cache.set(serverName, { ...config, lastUpdatedAt: Date.now() });- }-public async remove(serverName: string): Promise<void> {if (!this.cache.delete(serverName)) {throw new Error(`Failed to remove server "${serverName}" in cache.`);@@ -51,12 +43,4 @@ export class ServerConfigsCacheInMemory {public async reset(): Promise<void> {this.cache.clear();}-- /**- * Returns a placeholder namespace for consistency with Redis implementation.- * In-memory cache doesn't use namespaces, so this always returns empty string.- */- public getNamespace(): string {- return '';- }}diff --git a/packages/api/src/mcp/registry/cache/ServerConfigsCacheRedis.ts b/packages/api/src/mcp/registry/cache/ServerConfigsCacheRedis.tsindex 99e64cc52b..f5126a640f 100644--- a/packages/api/src/mcp/registry/cache/ServerConfigsCacheRedis.ts+++ b/packages/api/src/mcp/registry/cache/ServerConfigsCacheRedis.ts@@ -3,61 +3,54 @@ import { fromPairs } from 'lodash';import { standardCache, keyvRedisClient } from '~/cache';import { ParsedServerConfig } from '~/mcp/types';import { BaseRegistryCache } from './BaseRegistryCache';+import { IServerConfigsRepositoryInterface } from '../ServerConfigsRepositoryInterface';/*** Redis-backed implementation of MCP server configurations cache for distributed deployments.- * Stores server configs in Redis with namespace isolation by owner (App, User, or specific user ID).+ * Stores server configs in Redis with namespace isolation.* Enables data sharing across multiple server instances in a cluster environment.* Supports optional leader-only write operations to prevent race conditions during initialization.* Data persists across server restarts and is accessible from any instance in the cluster.*/-export class ServerConfigsCacheRedis extends BaseRegistryCache {+export class ServerConfigsCacheRedis+ extends BaseRegistryCache+ implements IServerConfigsRepositoryInterface+{protected readonly cache: Keyv;- private readonly owner: string;+ private readonly namespace: string;- constructor(owner: string, scope: 'Shared' | 'Private', leaderOnly: boolean) {+ constructor(namespace: string, leaderOnly: boolean) {super(leaderOnly);- this.owner = owner;- this.cache = standardCache(`${this.PREFIX}::Servers::${scope}::${owner}`);+ this.namespace = namespace;+ this.cache = standardCache(`${this.PREFIX}::Servers::${namespace}`);}public async add(serverName: string, config: ParsedServerConfig): Promise<void> {- if (this.leaderOnly) await this.leaderCheck(`add ${this.owner} MCP servers`);+ if (this.leaderOnly) await this.leaderCheck(`add ${this.namespace} MCP servers`);const exists = await this.cache.has(serverName);if (exists)throw new Error(`Server "${serverName}" already exists in cache. Use update() to modify existing configs.`,);const success = await this.cache.set(serverName, { ...config, lastUpdatedAt: Date.now() });- this.successCheck(`add ${this.owner} server "${serverName}"`, success);+ this.successCheck(`add ${this.namespace} server "${serverName}"`, success);}public async update(serverName: string, config: ParsedServerConfig): Promise<void> {- if (this.leaderOnly) await this.leaderCheck(`update ${this.owner} MCP servers`);+ if (this.leaderOnly) await this.leaderCheck(`update ${this.namespace} MCP servers`);const exists = await this.cache.has(serverName);if (!exists)throw new Error(`Server "${serverName}" does not exist in cache. Use add() to create new configs.`,);const success = await this.cache.set(serverName, { ...config, lastUpdatedAt: Date.now() });- this.successCheck(`update ${this.owner} server "${serverName}"`, success);- }-- /**- * Sets a server config without checking if it exists (upsert operation).- * Use this for bulk operations where you want to add or update without error handling.- * Note: Respects leaderOnly flag if set.- */- public async set(serverName: string, config: ParsedServerConfig): Promise<void> {- if (this.leaderOnly) await this.leaderCheck(`set ${this.owner} MCP servers`);- const success = await this.cache.set(serverName, { ...config, lastUpdatedAt: Date.now() });- this.successCheck(`set ${this.owner} server "${serverName}"`, success);+ this.successCheck(`update ${this.namespace} server "${serverName}"`, success);}public async remove(serverName: string): Promise<void> {- if (this.leaderOnly) await this.leaderCheck(`remove ${this.owner} MCP servers`);+ if (this.leaderOnly) await this.leaderCheck(`remove ${this.namespace} MCP servers`);const success = await this.cache.delete(serverName);- this.successCheck(`remove ${this.owner} server "${serverName}"`, success);+ this.successCheck(`remove ${this.namespace} server "${serverName}"`, success);}public async get(serverName: string): Promise<ParsedServerConfig | undefined> {@@ -88,12 +81,4 @@ export class ServerConfigsCacheRedis extends BaseRegistryCache {return fromPairs(entries);}-- /**- * Returns the Redis namespace for this cache instance.- * Used for constructing full Redis keys when needed for batch operations.- */- public getNamespace(): string {- return this.cache.namespace ?? '';- }}diff --git a/packages/api/src/mcp/registry/cache/__tests__/PrivateServerConfigsCacheFactory.test.ts b/packages/api/src/mcp/registry/cache/__tests__/PrivateServerConfigsCacheFactory.test.tsdeleted file mode 100644index 018f2db8b5..0000000000--- a/packages/api/src/mcp/registry/cache/__tests__/PrivateServerConfigsCacheFactory.test.ts+++ /dev/null@@ -1,71 +0,0 @@-import { PrivateServerConfigsCacheFactory } from '../PrivateServerConfigs/PrivateServerConfigsCacheFactory';-import { PrivateServerConfigsCacheInMemory } from '../PrivateServerConfigs/PrivateServerConfigsCacheInMemory';-import { PrivateServerConfigsCacheRedis } from '../PrivateServerConfigs/PrivateServerConfigsCacheRedis';-import { cacheConfig } from '~/cache';--// Mock the cache implementations-jest.mock('../PrivateServerConfigs/PrivateServerConfigsCacheInMemory');-jest.mock('../PrivateServerConfigs/PrivateServerConfigsCacheRedis');--// Mock the cache config module-jest.mock('~/cache', () => ({- cacheConfig: {- USE_REDIS: false,- },-}));--describe('PrivateServerConfigsCacheFactory', () => {- beforeEach(() => {- jest.clearAllMocks();- });-- describe('create()', () => {- it('should return PrivateServerConfigsCacheRedis when USE_REDIS is true', () => {- // Arrange- cacheConfig.USE_REDIS = true;-- // Act- const cache = PrivateServerConfigsCacheFactory.create();-- // Assert- expect(cache).toBeInstanceOf(PrivateServerConfigsCacheRedis);- expect(PrivateServerConfigsCacheRedis).toHaveBeenCalled();- });-- it('should return PrivateServerConfigsCacheInMemory when USE_REDIS is false', () => {- // Arrange- cacheConfig.USE_REDIS = false;-- // Act- const cache = PrivateServerConfigsCacheFactory.create();-- // Assert- expect(cache).toBeInstanceOf(PrivateServerConfigsCacheInMemory);- expect(PrivateServerConfigsCacheInMemory).toHaveBeenCalled();- });-- it('should create PrivateServerConfigsCacheInMemory without parameters when USE_REDIS is false', () => {- // Arrange- cacheConfig.USE_REDIS = false;-- // Act- PrivateServerConfigsCacheFactory.create();-- // Assert- // Private cache doesn't use any parameters- expect(PrivateServerConfigsCacheInMemory).toHaveBeenCalledWith();- });-- it('should create PrivateServerConfigsCacheRedis without parameters when USE_REDIS is true', () => {- // Arrange- cacheConfig.USE_REDIS = true;-- // Act- PrivateServerConfigsCacheFactory.create();-- // Assert- // Private cache doesn't use any parameters- expect(PrivateServerConfigsCacheRedis).toHaveBeenCalledWith();- });- });-});diff --git a/packages/api/src/mcp/registry/cache/__tests__/PrivateServerConfigsCacheInMemory.test.ts b/packages/api/src/mcp/registry/cache/__tests__/PrivateServerConfigsCacheInMemory.test.tsdeleted file mode 100644index 64a7feca2a..0000000000--- a/packages/api/src/mcp/registry/cache/__tests__/PrivateServerConfigsCacheInMemory.test.ts+++ /dev/null@@ -1,346 +0,0 @@-import { expect } from '@playwright/test';-import { ParsedServerConfig } from '~/mcp/types';-const FIXED_TIME = 1699564800000;-const originalDateNow = Date.now;-Date.now = jest.fn(() => FIXED_TIME);--describe('PrivateServerConfigsCacheInMemory Tests', () => {- let PrivateServerConfigsCacheInMemory: typeof import('../PrivateServerConfigs/PrivateServerConfigsCacheInMemory').PrivateServerConfigsCacheInMemory;- let cache: InstanceType<- typeof import('../PrivateServerConfigs/PrivateServerConfigsCacheInMemory').PrivateServerConfigsCacheInMemory- >;-- // Test data- const mockConfig1: ParsedServerConfig = {- command: 'node',- args: ['server1.js'],- env: { TEST: 'value1' },- lastUpdatedAt: FIXED_TIME,- };-- const mockConfig2: ParsedServerConfig = {- command: 'python',- args: ['server2.py'],- env: { TEST: 'value2' },- lastUpdatedAt: FIXED_TIME,- };-- const mockConfig3: ParsedServerConfig = {- command: 'node',- args: ['server3.js'],- url: 'http://localhost:3000',- requiresOAuth: true,- lastUpdatedAt: FIXED_TIME,- };-- beforeAll(async () => {- // Import modules- const cacheModule = await import('../PrivateServerConfigs/PrivateServerConfigsCacheInMemory');- PrivateServerConfigsCacheInMemory = cacheModule.PrivateServerConfigsCacheInMemory;- });-- afterAll(() => {- Date.now = originalDateNow;- });-- beforeEach(() => {- // Create a fresh instance for each test- cache = new PrivateServerConfigsCacheInMemory();- });-- describe('add and get operations', () => {- it('should add and retrieve a server config for a user', async () => {- await cache.add('user1', 'server1', mockConfig1);- const result = await cache.get('user1', 'server1');- expect(result).toEqual(mockConfig1);- });-- it('should return undefined for non-existent server', async () => {- const result = await cache.get('user1', 'non-existent');- expect(result).toBeUndefined();- });-- it('should throw error when adding duplicate server for same user', async () => {- await cache.add('user1', 'server1', mockConfig1);- await expect(cache.add('user1', 'server1', mockConfig2)).rejects.toThrow(- 'Server "server1" already exists in cache. Use update() to modify existing configs.',- );- });-- it('should handle multiple server configs for a single user', async () => {- await cache.add('user1', 'server1', mockConfig1);- await cache.add('user1', 'server2', mockConfig2);- await cache.add('user1', 'server3', mockConfig3);-- const result1 = await cache.get('user1', 'server1');- const result2 = await cache.get('user1', 'server2');- const result3 = await cache.get('user1', 'server3');-- expect(result1).toEqual(mockConfig1);- expect(result2).toEqual(mockConfig2);- expect(result3).toEqual(mockConfig3);- });-- it('should isolate server configs between different users', async () => {- await cache.add('user1', 'server1', mockConfig1);- await cache.add('user2', 'server1', mockConfig2);-- const user1Result = await cache.get('user1', 'server1');- const user2Result = await cache.get('user2', 'server1');-- expect(user1Result).toEqual(mockConfig1);- expect(user2Result).toEqual(mockConfig2);- });- });-- describe('getAll operation', () => {- it('should return empty object when user has no servers', async () => {- const result = await cache.getAll('user1');- expect(result).toEqual({});- });-- it('should return all server configs for a user', async () => {- await cache.add('user1', 'server1', mockConfig1);- await cache.add('user1', 'server2', mockConfig2);- await cache.add('user1', 'server3', mockConfig3);-- const result = await cache.getAll('user1');- expect(result).toEqual({- server1: mockConfig1,- server2: mockConfig2,- server3: mockConfig3,- });- });-- it('should only return configs for specific user', async () => {- await cache.add('user1', 'server1', mockConfig1);- await cache.add('user1', 'server2', mockConfig2);- await cache.add('user2', 'server3', mockConfig3);-- const user1Result = await cache.getAll('user1');- const user2Result = await cache.getAll('user2');-- expect(Object.keys(user1Result).length).toBe(2);- expect(Object.keys(user2Result).length).toBe(1);- expect(user1Result.server3).toBeUndefined();- expect(user2Result.server1).toBeUndefined();- });- });-- describe('update operation', () => {- it('should update an existing server config', async () => {- await cache.add('user1', 'server1', mockConfig1);- expect(await cache.get('user1', 'server1')).toEqual(mockConfig1);-- await cache.update('user1', 'server1', mockConfig2);- const result = await cache.get('user1', 'server1');- expect(result).toEqual(mockConfig2);- });-- it('should throw error when updating non-existent server', async () => {- await expect(cache.update('user1', 'non-existent', mockConfig1)).rejects.toThrow(- 'Server "non-existent" does not exist in cache. Use add() to create new configs.',- );- });-- it('should only update for specific user', async () => {- await cache.add('user1', 'server1', mockConfig1);- await cache.add('user2', 'server1', mockConfig2);-- await cache.update('user1', 'server1', mockConfig3);-- expect(await cache.get('user1', 'server1')).toEqual(mockConfig3);- expect(await cache.get('user2', 'server1')).toEqual(mockConfig2);- });- });-- describe('remove operation', () => {- it('should remove an existing server config', async () => {- await cache.add('user1', 'server1', mockConfig1);- expect(await cache.get('user1', 'server1')).toEqual(mockConfig1);-- await cache.remove('user1', 'server1');- expect(await cache.get('user1', 'server1')).toBeUndefined();- });-- it('should throw error when removing non-existent server', async () => {- await expect(cache.remove('user1', 'non-existent')).rejects.toThrow(- 'Failed to remove server "non-existent" in cache.',- );- });-- it('should only remove from specific user', async () => {- await cache.add('user1', 'server1', mockConfig1);- await cache.add('user2', 'server1', mockConfig2);-- await cache.remove('user1', 'server1');-- expect(await cache.get('user1', 'server1')).toBeUndefined();- expect(await cache.get('user2', 'server1')).toEqual(mockConfig2);- });-- it('should allow re-adding a removed server', async () => {- await cache.add('user1', 'server1', mockConfig1);- await cache.remove('user1', 'server1');- await cache.add('user1', 'server1', mockConfig3);-- const result = await cache.get('user1', 'server1');- expect(result).toEqual(mockConfig3);- });- });-- describe('reset operation', () => {- it('should clear all servers for a specific user', async () => {- await cache.add('user1', 'server1', mockConfig1);- await cache.add('user1', 'server2', mockConfig2);- await cache.add('user2', 'server3', mockConfig3);-- await cache.reset('user1');-- const user1Result = await cache.getAll('user1');- const user2Result = await cache.getAll('user2');-- expect(Object.keys(user1Result).length).toBe(0);- expect(Object.keys(user2Result).length).toBe(1);- });- });-- describe('has operation', () => {- it('should return true for users with loaded cache', async () => {- await cache.add('user1', 'server1', mockConfig1);- expect(await cache.has('user1')).toBe(true);- });-- it('should return false for users without loaded cache', async () => {- expect(await cache.has('user1')).toBe(false);- });- });-- describe('updateServerConfigIfExists operation', () => {- it('should update server config for all users who have it', async () => {- await cache.add('user1', 'server1', mockConfig1);- await cache.add('user2', 'server1', mockConfig1);- await cache.add('user3', 'server2', mockConfig2);-- await cache.updateServerConfigIfExists('server1', mockConfig3);-- expect(await cache.get('user1', 'server1')).toEqual(mockConfig3);- expect(await cache.get('user2', 'server1')).toEqual(mockConfig3);- expect(await cache.get('user3', 'server1')).toBeUndefined();- expect(await cache.get('user3', 'server2')).toEqual(mockConfig2);- });-- it('should handle case when no users have the server', async () => {- await cache.add('user1', 'server2', mockConfig2);- await cache.add('user2', 'server3', mockConfig3);-- await expect(cache.updateServerConfigIfExists('server1', mockConfig1)).resolves.not.toThrow();-- expect(await cache.get('user1', 'server2')).toEqual(mockConfig2);- expect(await cache.get('user2', 'server3')).toEqual(mockConfig3);- });-- it('should handle case with no loaded user caches', async () => {- await expect(cache.updateServerConfigIfExists('server1', mockConfig1)).resolves.not.toThrow();- });- });-- describe('addServerConfigIfCacheExists operation', () => {- it('should add server to specified users with initialized caches', async () => {- await cache.add('user1', 'other', mockConfig1);- await cache.add('user2', 'other', mockConfig1);-- await cache.addServerConfigIfCacheExists(['user1', 'user2', 'user3'], 'server1', mockConfig2);-- expect(await cache.get('user1', 'server1')).toEqual(mockConfig2);- expect(await cache.get('user2', 'server1')).toEqual(mockConfig2);- expect(await cache.get('user3', 'server1')).toBeUndefined();- });-- it('should not add to users without initialized caches', async () => {- await cache.addServerConfigIfCacheExists(['user1', 'user2'], 'server1', mockConfig1);-- expect(await cache.get('user1', 'server1')).toBeUndefined();- expect(await cache.get('user2', 'server1')).toBeUndefined();- });-- it('should handle empty userIds array', async () => {- await expect(- cache.addServerConfigIfCacheExists([], 'server1', mockConfig1),- ).resolves.not.toThrow();- });- });-- describe('removeServerConfigIfCacheExists operation', () => {- it('should remove server from specified users', async () => {- await cache.add('user1', 'server1', mockConfig1);- await cache.add('user2', 'server1', mockConfig1);- await cache.add('user3', 'server1', mockConfig1);-- await cache.removeServerConfigIfCacheExists(['user1', 'user3'], 'server1');-- expect(await cache.get('user1', 'server1')).toBeUndefined();- expect(await cache.get('user2', 'server1')).toEqual(mockConfig1);- expect(await cache.get('user3', 'server1')).toBeUndefined();- });-- it('should handle users who do not have the server', async () => {- await cache.add('user1', 'server1', mockConfig1);-- await expect(- cache.removeServerConfigIfCacheExists(['user1', 'user2'], 'server1'),- ).resolves.not.toThrow();-- expect(await cache.get('user1', 'server1')).toBeUndefined();- });-- it('should handle empty userIds array', async () => {- await expect(cache.removeServerConfigIfCacheExists([], 'server1')).resolves.not.toThrow();- });- });-- describe('findUsersWithServer operation', () => {- it('should return all users who have the server', async () => {- await cache.add('user1', 'server1', mockConfig1);- await cache.add('user2', 'server1', mockConfig1);- await cache.add('user3', 'other', mockConfig2);-- const users = await cache.findUsersWithServer('server1');-- expect(users.sort()).toEqual(['user1', 'user2'].sort());- });-- it('should return empty array if no users have the server', async () => {- await cache.add('user1', 'other', mockConfig1);-- const users = await cache.findUsersWithServer('server1');-- expect(users).toEqual([]);- });-- it('should return empty array with no loaded user caches', async () => {- const users = await cache.findUsersWithServer('server1');-- expect(users).toEqual([]);- });- });-- describe('resetAll operation', () => {- it('should clear all servers for all users', async () => {- await cache.add('user1', 'server1', mockConfig1);- await cache.add('user1', 'server2', mockConfig2);- await cache.add('user2', 'server1', mockConfig1);- await cache.add('user2', 'server3', mockConfig3);-- await cache.resetAll();-- expect(await cache.has('user1')).toBe(false);- expect(await cache.has('user2')).toBe(false);- });-- it('should handle case with no loaded user caches', async () => {- // Should not throw- await expect(cache.resetAll()).resolves.not.toThrow();- });- });-});diff --git a/packages/api/src/mcp/registry/cache/__tests__/PrivateServerConfigsCacheRedis.cache_integration.spec.ts b/packages/api/src/mcp/registry/cache/__tests__/PrivateServerConfigsCacheRedis.cache_integration.spec.tsdeleted file mode 100644index 3c4978169d..0000000000--- a/packages/api/src/mcp/registry/cache/__tests__/PrivateServerConfigsCacheRedis.cache_integration.spec.ts+++ /dev/null@@ -1,606 +0,0 @@-import { expect } from '@playwright/test';-import { ParsedServerConfig } from '~/mcp/types';--describe('PrivateServerConfigsCacheRedis Integration Tests', () => {- let PrivateServerConfigsCacheRedis: typeof import('../PrivateServerConfigs/PrivateServerConfigsCacheRedis').PrivateServerConfigsCacheRedis;- let keyvRedisClient: Awaited<typeof import('~/cache/redisClients')>['keyvRedisClient'];- let cache: InstanceType<- typeof import('../PrivateServerConfigs/PrivateServerConfigsCacheRedis').PrivateServerConfigsCacheRedis- >;-- // Test data- const mockConfig1: ParsedServerConfig = {- command: 'node',- args: ['server1.js'],- env: { TEST: 'value1' },- };-- const mockConfig2: ParsedServerConfig = {- command: 'python',- args: ['server2.py'],- env: { TEST: 'value2' },- };-- const mockConfig3: ParsedServerConfig = {- command: 'node',- args: ['server3.js'],- url: 'http://localhost:3000',- requiresOAuth: true,- };-- beforeAll(async () => {- // Set up environment variables for Redis (only if not already set)- process.env.USE_REDIS = process.env.USE_REDIS ?? 'true';- process.env.REDIS_URI = process.env.REDIS_URI ?? 'redis://127.0.0.1:6379';- process.env.USE_REDIS_CLUSTER = process.env.USE_REDIS_CLUSTER ?? 'false';- console.log('USING CLUSETER....', process.env.USE_REDIS_CLUSTER);-- process.env.REDIS_KEY_PREFIX =- process.env.REDIS_KEY_PREFIX ?? 'PrivateServerConfigsCacheRedis-IntegrationTest';-- // Import modules after setting env vars- const cacheModule = await import('../PrivateServerConfigs/PrivateServerConfigsCacheRedis');- const redisClients = await import('~/cache/redisClients');-- PrivateServerConfigsCacheRedis = cacheModule.PrivateServerConfigsCacheRedis;- keyvRedisClient = redisClients.keyvRedisClient;-- // Ensure Redis is connected- if (!keyvRedisClient) throw new Error('Redis client is not initialized');-- // Wait for connection and topology discovery to complete- await redisClients.keyvRedisClientReady;- });-- beforeEach(() => {- // Create a fresh instance for each test- cache = new PrivateServerConfigsCacheRedis();- });-- afterEach(async () => {- // Clean up: clear all test keys from Redis- if (keyvRedisClient && 'scanIterator' in keyvRedisClient) {- const pattern = '*PrivateServerConfigsCacheRedis-IntegrationTest*';- const keysToDelete: string[] = [];-- // Collect all keys first- for await (const key of keyvRedisClient.scanIterator({ MATCH: pattern })) {- keysToDelete.push(key);- }-- // Delete in parallel for cluster mode efficiency- if (keysToDelete.length > 0) {- await Promise.all(keysToDelete.map((key) => keyvRedisClient!.del(key)));- }- }- });-- afterAll(async () => {- // Close Redis connection- if (keyvRedisClient?.isOpen) await keyvRedisClient.disconnect();- });-- describe('add and get operations', () => {- it('should add and retrieve a server config for a user', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- const result = await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`);- expect(result).toMatchObject(mockConfig1);- });-- it('should return undefined for non-existent server', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- const result = await cache.get(`user1-${randonPrefix}`, 'non-existent');- expect(result).toBeUndefined();- });-- it('should throw error when adding duplicate server for same user', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await expect(- cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig2),- ).rejects.toThrow(- `Server "server1-${randonPrefix}" already exists in cache. Use update() to modify existing configs.`,- );- });-- it('should handle multiple server configs for a single user', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user1-${randonPrefix}`, `server2-${randonPrefix}`, mockConfig2);- await cache.add(`user1-${randonPrefix}`, `server3-${randonPrefix}`, mockConfig3);-- const result1 = await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`);- const result2 = await cache.get(`user1-${randonPrefix}`, `server2-${randonPrefix}`);- const result3 = await cache.get(`user1-${randonPrefix}`, `server3-${randonPrefix}`);-- expect(result1).toMatchObject(mockConfig1);- expect(result2).toMatchObject(mockConfig2);- expect(result3).toMatchObject(mockConfig3);- });-- it('should isolate server configs between different users', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user2-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig2);-- const user1Result = await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`);- const user2Result = await cache.get(`user2-${randonPrefix}`, `server1-${randonPrefix}`);-- expect(user1Result).toMatchObject(mockConfig1);- expect(user2Result).toMatchObject(mockConfig2);- });- });-- describe('getAll operation', () => {- it('should return empty object when user has no servers', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- const result = await cache.getAll(`user1-${randonPrefix}`);- expect(result).toMatchObject({});- });-- it('should return all server configs for a user', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user1-${randonPrefix}`, `server2-${randonPrefix}`, mockConfig2);- await cache.add(`user1-${randonPrefix}`, `server3-${randonPrefix}`, mockConfig3);-- const result = await cache.getAll(`user1-${randonPrefix}`);- expect(result).toMatchObject({- [`server1-${randonPrefix}`]: mockConfig1,- [`server2-${randonPrefix}`]: mockConfig2,- [`server3-${randonPrefix}`]: mockConfig3,- });- });-- it('should only return configs for specific user', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user1-${randonPrefix}`, `server2-${randonPrefix}`, mockConfig2);- await cache.add(`user2-${randonPrefix}`, `server3-${randonPrefix}`, mockConfig3);-- const user1Result = await cache.getAll(`user1-${randonPrefix}`);- const user2Result = await cache.getAll(`user2-${randonPrefix}`);-- expect(Object.keys(user1Result).length).toBe(2);- expect(Object.keys(user2Result).length).toBe(1);- expect(user1Result.server3).toBeUndefined();- expect(user2Result.server1).toBeUndefined();- });- });-- describe('update operation', () => {- it('should update an existing server config', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- expect(await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig1,- );-- await cache.update(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig2);- const result = await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`);- expect(result).toMatchObject(mockConfig2);- });-- it('should throw error when updating non-existent server', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await expect(- cache.update(`user1-${randonPrefix}`, 'non-existent', mockConfig1),- ).rejects.toThrow(- 'Server "non-existent" does not exist in cache. Use add() to create new configs.',- );- });-- it('should only update for specific user', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user2-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig2);-- await cache.update(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig3);-- expect(await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig3,- );- expect(await cache.get(`user2-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig2,- );- });- });-- describe('remove operation', () => {- it('should remove an existing server config', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- expect(await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig1,- );-- await cache.remove(`user1-${randonPrefix}`, `server1-${randonPrefix}`);- expect(await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- });-- it('should throw error when removing non-existent server', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await expect(cache.remove(`user1-${randonPrefix}`, 'non-existent')).rejects.toThrow(- `Failed to remove user1-${randonPrefix} server "non-existent" in cache.`,- );- });-- it('should only remove from specific user', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user2-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig2);-- await cache.remove(`user1-${randonPrefix}`, `server1-${randonPrefix}`);-- expect(await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- expect(await cache.get(`user2-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig2,- );- });-- it('should allow re-adding a removed server', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.remove(`user1-${randonPrefix}`, `server1-${randonPrefix}`);- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig3);-- const result = await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`);- expect(result).toMatchObject(mockConfig3);- });- });-- describe('reset operation', () => {- it('should clear all servers for a specific user', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user1-${randonPrefix}`, `server2-${randonPrefix}`, mockConfig2);- await cache.add(`user2-${randonPrefix}`, `server3-${randonPrefix}`, mockConfig3);-- await cache.reset(`user1-${randonPrefix}`);-- const user1Result = await cache.getAll(`user1-${randonPrefix}`);- const user2Result = await cache.getAll(`user2-${randonPrefix}`);-- expect(Object.keys(user1Result).length).toBe(0);- expect(Object.keys(user2Result).length).toBe(1);- });- });-- describe('has operation', () => {- it('should return true for users with loaded cache', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- console.log('check');- expect(await cache.has(`user1-${randonPrefix}`)).toBe(true);- });-- it('should return false for users without loaded cache', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- expect(await cache.has(`user1-${randonPrefix}`)).toBe(false);- });- });-- describe('updateServerConfigIfExists operation', () => {- it('should update server config for all users who have it', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user2-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user3-${randonPrefix}`, `server2-${randonPrefix}`, mockConfig2);-- await cache.updateServerConfigIfExists(`server1-${randonPrefix}`, mockConfig3);-- expect(await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig3,- );- expect(await cache.get(`user2-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig3,- );- expect(await cache.get(`user3-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- expect(await cache.get(`user3-${randonPrefix}`, `server2-${randonPrefix}`)).toMatchObject(- mockConfig2,- );- });-- it('should update lastUpdatedAt timestamp', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, 'server1-share', mockConfig1);- await cache.add(`user2-${randonPrefix}`, 'server1-share', mockConfig1);-- const timeBeforeUpdate = Date.now();- await new Promise((r) => setTimeout(() => r(true), 100));- await cache.updateServerConfigIfExists('server1-share', mockConfig2);-- const user1Result = await cache.get(`user1-${randonPrefix}`, 'server1-share');- const user2Result = await cache.get(`user2-${randonPrefix}`, 'server1-share');- expect(user1Result).toBeDefined();- expect(user1Result!.lastUpdatedAt! - timeBeforeUpdate).toBeGreaterThan(0);- expect(user2Result!.lastUpdatedAt! - timeBeforeUpdate).toBeGreaterThan(0);- });-- it('should handle case when no users have the server', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server2-${randonPrefix}`, mockConfig2);- await cache.add(`user2-${randonPrefix}`, `server3-${randonPrefix}`, mockConfig3);-- await expect(- cache.updateServerConfigIfExists(`server1-${randonPrefix}`, mockConfig1),- ).resolves.not.toThrow();-- expect(await cache.get(`user1-${randonPrefix}`, `server2-${randonPrefix}`)).toMatchObject(- mockConfig2,- );- expect(await cache.get(`user2-${randonPrefix}`, `server3-${randonPrefix}`)).toMatchObject(- mockConfig3,- );- });-- it('should handle case with no user caches', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await expect(- cache.updateServerConfigIfExists(`server1-${randonPrefix}`, mockConfig1),- ).resolves.not.toThrow();- });-- it('should work across multiple cache instances (distributed scenario)', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- const cache1 = new PrivateServerConfigsCacheRedis();- const cache2 = new PrivateServerConfigsCacheRedis();-- await cache1.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache1.add(`user2-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);-- await cache2.updateServerConfigIfExists(`server1-${randonPrefix}`, mockConfig3);-- expect(await cache1.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig3,- );- expect(await cache1.get(`user2-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig3,- );- });- });-- describe('addServerConfigIfCacheExists operation', () => {- it('should add server to specified users with initialized caches', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, 'other', mockConfig1);- await cache.add(`user2-${randonPrefix}`, 'other', mockConfig1);-- await cache.addServerConfigIfCacheExists(- [`user1-${randonPrefix}`, `user2-${randonPrefix}`, `user3-${randonPrefix}`],- `server1-${randonPrefix}`,- mockConfig2,- );-- expect(await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig2,- );- expect(await cache.get(`user2-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig2,- );- expect(await cache.get(`user3-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- });-- it('should not add to users without initialized caches', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.addServerConfigIfCacheExists(- [`user1-${randonPrefix}`, `user2-${randonPrefix}`],- `server1-${randonPrefix}`,- mockConfig1,- );-- expect(await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- expect(await cache.get(`user2-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- });-- it('should handle empty userIds array', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await expect(- cache.addServerConfigIfCacheExists([], `server1-${randonPrefix}`, mockConfig1),- ).resolves.not.toThrow();- });-- it('should work across multiple cache instances (distributed scenario)', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- const cache1 = new PrivateServerConfigsCacheRedis();- const cache2 = new PrivateServerConfigsCacheRedis();-- await cache1.add(`user1-${randonPrefix}`, 'other', mockConfig1);- await cache1.add(`user2-${randonPrefix}`, 'other', mockConfig1);-- await cache2.addServerConfigIfCacheExists(- [`user1-${randonPrefix}`, `user2-${randonPrefix}`, `user3-${randonPrefix}`],- `server1-${randonPrefix}`,- mockConfig2,- );-- expect(await cache1.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig2,- );- expect(await cache1.get(`user2-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig2,- );- expect(await cache1.get(`user3-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- });- });-- describe('removeServerConfigIfCacheExists operation', () => {- it('should remove server from specified users', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user2-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user3-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);-- await cache.removeServerConfigIfCacheExists(- [`user1-${randonPrefix}`, `user3-${randonPrefix}`],- `server1-${randonPrefix}`,- );-- expect(await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- expect(await cache.get(`user2-${randonPrefix}`, `server1-${randonPrefix}`)).toMatchObject(- mockConfig1,- );- expect(await cache.get(`user3-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- });-- it('should handle users who do not have the server', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);-- await expect(- cache.removeServerConfigIfCacheExists(- [`user1-${randonPrefix}`, `user2-${randonPrefix}`],- `server1-${randonPrefix}`,- ),- ).resolves.not.toThrow();-- expect(await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- });-- it('should handle empty userIds array', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await expect(- cache.removeServerConfigIfCacheExists([], `server1-${randonPrefix}`),- ).resolves.not.toThrow();- });-- it('should work across multiple cache instances (distributed scenario)', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- const cache1 = new PrivateServerConfigsCacheRedis();- const cache2 = new PrivateServerConfigsCacheRedis();-- await cache1.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache1.add(`user2-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);-- await cache2.removeServerConfigIfCacheExists(- [`user1-${randonPrefix}`, `user2-${randonPrefix}`],- `server1-${randonPrefix}`,- );-- expect(await cache1.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- expect(await cache1.get(`user2-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- });- });-- describe('findUsersWithServer operation', () => {- it('should return all users who have the server', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user2-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user3-${randonPrefix}`, 'other', mockConfig2);-- const users = await cache.findUsersWithServer(`server1-${randonPrefix}`);-- expect(users.sort()).toEqual([`user1-${randonPrefix}`, `user2-${randonPrefix}`].sort());- });-- it('should return empty array if no users have the server', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, 'other', mockConfig1);-- const users = await cache.findUsersWithServer(`server1-${randonPrefix}`);-- expect(users).toEqual([]);- });-- it('should return empty array with no user caches', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- const users = await cache.findUsersWithServer(`server1-${randonPrefix}`);-- expect(users).toEqual([]);- });-- it('should work across multiple cache instances (distributed scenario)', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- const cache1 = new PrivateServerConfigsCacheRedis();- const cache2 = new PrivateServerConfigsCacheRedis();-- await cache1.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache1.add(`user2-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache1.add(`user3-${randonPrefix}`, 'other', mockConfig2);-- const users = await cache2.findUsersWithServer(`server1-${randonPrefix}`);-- expect(users.sort()).toEqual([`user1-${randonPrefix}`, `user2-${randonPrefix}`].sort());- });- });-- describe('resetAll operation', () => {- it('should clear all servers for all users in Redis', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- await cache.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user1-${randonPrefix}`, `server2-${randonPrefix}`, mockConfig2);- await cache.add(`user2-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache.add(`user2-${randonPrefix}`, `server3-${randonPrefix}`, mockConfig3);-- await cache.resetAll();-- expect(await cache.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- expect(await cache.get(`user1-${randonPrefix}`, `server2-${randonPrefix}`)).toBeUndefined();- expect(await cache.get(`user2-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- expect(await cache.get(`user2-${randonPrefix}`, `server3-${randonPrefix}`)).toBeUndefined();- });-- it.skip('should handle case with no user caches', async () => {- // const randonPrefix = Math.random().toString(36).substring(2, 8);-- // Should not throw- await expect(cache.resetAll()).resolves.not.toThrow();- });-- it('should work across multiple cache instances (distributed scenario)', async () => {- const randonPrefix = Math.random().toString(36).substring(2, 8);-- const cache1 = new PrivateServerConfigsCacheRedis();- const cache2 = new PrivateServerConfigsCacheRedis();-- // Add servers using cache1- await cache1.add(`user1-${randonPrefix}`, `server1-${randonPrefix}`, mockConfig1);- await cache1.add(`user2-${randonPrefix}`, `server2-${randonPrefix}`, mockConfig2);-- // Reset using cache2- await cache2.resetAll();-- // Verify using cache1- expect(await cache1.get(`user1-${randonPrefix}`, `server1-${randonPrefix}`)).toBeUndefined();- expect(await cache1.get(`user2-${randonPrefix}`, `server2-${randonPrefix}`)).toBeUndefined();- });- });-});diff --git a/packages/api/src/mcp/registry/cache/__tests__/PrivateServersLoadStatusCache.cache_integration.spec.ts b/packages/api/src/mcp/registry/cache/__tests__/PrivateServersLoadStatusCache.cache_integration.spec.tsdeleted file mode 100644index 5a98562dfa..0000000000--- a/packages/api/src/mcp/registry/cache/__tests__/PrivateServersLoadStatusCache.cache_integration.spec.ts+++ /dev/null@@ -1,397 +0,0 @@-import { expect } from '@playwright/test';--describe('PrivateServersLoadStatusCache Integration Tests', () => {- let loadStatusCache: typeof import('../PrivateServersLoadStatusCache').privateServersLoadStatusCache;- let keyvRedisClient: Awaited<typeof import('~/cache/redisClients')>['keyvRedisClient'];- let testCounter = 0;-- beforeAll(async () => {- // Set up environment variables for Redis (only if not already set)- process.env.USE_REDIS = process.env.USE_REDIS ?? 'true';- process.env.REDIS_URI = process.env.REDIS_URI ?? 'redis://127.0.0.1:6379';- process.env.REDIS_KEY_PREFIX = 'PrivateServersLoadStatusCache-IntegrationTest';-- // Import modules after setting env vars- const loadStatusCacheModule = await import('../PrivateServersLoadStatusCache');- const redisClients = await import('~/cache/redisClients');-- loadStatusCache = loadStatusCacheModule.privateServersLoadStatusCache;- keyvRedisClient = redisClients.keyvRedisClient;-- // Ensure Redis is connected- if (!keyvRedisClient) throw new Error('Redis client is not initialized');-- // Wait for Redis connection and topology discovery to complete- await redisClients.keyvRedisClientReady;-- process.setMaxListeners(200);- });-- beforeEach(() => {- jest.resetModules();- testCounter++;- });-- afterEach(async () => {- // Clean up: clear all test keys from Redis- if (keyvRedisClient && 'scanIterator' in keyvRedisClient) {- const pattern = '*PrivateServersLoadStatusCache-IntegrationTest*';- const keysToDelete: string[] = [];-- // Collect all keys first- for await (const key of keyvRedisClient.scanIterator({ MATCH: pattern })) {- keysToDelete.push(key);- }-- // Delete in parallel for cluster mode efficiency- if (keysToDelete.length > 0) {- await Promise.all(keysToDelete.map((key) => keyvRedisClient!.del(key)));- }- }- });-- afterAll(async () => {- // Close Redis connection- if (keyvRedisClient?.isOpen) await keyvRedisClient.disconnect();- });-- describe('isLoaded() and setLoaded() integration', () => {- it('should persist loaded status in cache', async () => {- const userId = `user-persist-${testCounter}`;-- expect(await loadStatusCache.isLoaded(userId)).toBe(false);-- await loadStatusCache.setLoaded(userId, 60000);-- expect(await loadStatusCache.isLoaded(userId)).toBe(true);- });-- it('should handle multiple users independently', async () => {- const user1 = `user-multi-1-${testCounter}`;- const user2 = `user-multi-2-${testCounter}`;- const user3 = `user-multi-3-${testCounter}`;-- await loadStatusCache.setLoaded(user1, 60000);- await loadStatusCache.setLoaded(user2, 60000);-- expect(await loadStatusCache.isLoaded(user1)).toBe(true);- expect(await loadStatusCache.isLoaded(user2)).toBe(true);- expect(await loadStatusCache.isLoaded(user3)).toBe(false);- });-- it('should respect TTL expiration (short TTL for testing)', async () => {- const userId = `user-ttl-expire-${testCounter}`;-- // Set with 1 second TTL- await loadStatusCache.setLoaded(userId, 1000);-- expect(await loadStatusCache.isLoaded(userId)).toBe(true);-- // Wait for TTL to expire- await new Promise((resolve) => setTimeout(resolve, 1100));-- expect(await loadStatusCache.isLoaded(userId)).toBe(false);- }, 10000);-- it('should allow re-setting loaded status', async () => {- const userId = `user-reset-${testCounter}`;-- await loadStatusCache.setLoaded(userId, 60000);- expect(await loadStatusCache.isLoaded(userId)).toBe(true);-- await loadStatusCache.clearLoaded(userId);- expect(await loadStatusCache.isLoaded(userId)).toBe(false);-- await loadStatusCache.setLoaded(userId, 60000);- expect(await loadStatusCache.isLoaded(userId)).toBe(true);- });- });-- describe('acquireLoadLock() and releaseLoadLock() integration', () => {- it('should acquire lock successfully when available', async () => {- const userId = `user-lock-acquire-${testCounter}`;-- const acquired = await loadStatusCache.acquireLoadLock(userId, 10000);-- expect(acquired).toBe(true);-- // Clean up- await loadStatusCache.releaseLoadLock(userId);- });-- it('should prevent concurrent lock acquisition', async () => {- const userId = `user-lock-concurrent-${testCounter}`;-- const lock1 = await loadStatusCache.acquireLoadLock(userId, 10000);- expect(lock1).toBe(true);-- const lock2 = await loadStatusCache.acquireLoadLock(userId, 10000);- expect(lock2).toBe(false);-- // Release lock- await loadStatusCache.releaseLoadLock(userId);-- // Should be able to acquire again- const lock3 = await loadStatusCache.acquireLoadLock(userId, 10000);- expect(lock3).toBe(true);-- await loadStatusCache.releaseLoadLock(userId);- });-- it('should auto-release lock after TTL expires', async () => {- const userId = `user-lock-ttl-${testCounter}`;-- const acquired = await loadStatusCache.acquireLoadLock(userId, 1000); // 1 second TTL- expect(acquired).toBe(true);-- // Lock should prevent acquisition- const blocked = await loadStatusCache.acquireLoadLock(userId, 1000);- expect(blocked).toBe(false);-- // Wait for TTL to expire- await new Promise((resolve) => setTimeout(resolve, 1100));-- // Should be able to acquire now- const reacquired = await loadStatusCache.acquireLoadLock(userId, 10000);- expect(reacquired).toBe(true);-- await loadStatusCache.releaseLoadLock(userId);- }, 10000);-- it('should handle locks for multiple users independently', async () => {- const user1 = `user-lock-multi-1-${testCounter}`;- const user2 = `user-lock-multi-2-${testCounter}`;- const user3 = `user-lock-multi-3-${testCounter}`;-- const lock1 = await loadStatusCache.acquireLoadLock(user1, 10000);- const lock2 = await loadStatusCache.acquireLoadLock(user2, 10000);- const lock3 = await loadStatusCache.acquireLoadLock(user3, 10000);-- expect(lock1).toBe(true);- expect(lock2).toBe(true);- expect(lock3).toBe(true);-- await loadStatusCache.releaseLoadLock(user1);- await loadStatusCache.releaseLoadLock(user2);- await loadStatusCache.releaseLoadLock(user3);- });-- it('should allow release of non-existent lock without error', async () => {- const userId = `user-lock-nonexist-${testCounter}`;- await expect(loadStatusCache.releaseLoadLock(userId)).resolves.not.toThrow();- });- });-- describe('waitForLoad() integration', () => {- it('should wait and detect when loaded flag is set', async () => {- const userId = `user-wait-detect-${testCounter}`;-- // Start waiting in background- const waitPromise = loadStatusCache.waitForLoad(userId, 2000, 100);-- // Simulate another process setting the loaded flag after 300ms- const setLoadedPromise = new Promise<void>((resolve) => {- setTimeout(async () => {- await loadStatusCache.setLoaded(userId, 60000);- // Add small delay to ensure Redis write completes- await new Promise((r) => setTimeout(r, 50));- resolve();- }, 300);- });-- // Await both in parallel - waitPromise should complete first- const [result] = await Promise.all([waitPromise, setLoadedPromise]);-- expect(result).toBe(true);- }, 5000);-- it('should timeout if loaded flag is never set', async () => {- const userId = `user-timeout-${testCounter}`;-- const result = await loadStatusCache.waitForLoad(userId, 300, 50);-- expect(result).toBe(false);- }, 1000);-- it('should return immediately if already loaded', async () => {- const userId = `user-immediate-${testCounter}`;-- await loadStatusCache.setLoaded(userId, 60000);- // Small delay to ensure Redis write completes- await new Promise((resolve) => setTimeout(resolve, 50));-- const startTime = Date.now();- const result = await loadStatusCache.waitForLoad(userId, 5000, 100);- const elapsed = Date.now() - startTime;-- expect(result).toBe(true);- expect(elapsed).toBeLessThan(300); // Increased tolerance for CI environments- });- });-- describe('Complete load workflow integration', () => {- it('should simulate distributed load coordination', async () => {- const userId = `user-distributed-${testCounter}`;-- // Process 1: Acquires lock and loads- const lock1 = await loadStatusCache.acquireLoadLock(userId, 10000);- expect(lock1).toBe(true);-- // Process 2: Tries to acquire lock (should fail) and waits- const lock2 = await loadStatusCache.acquireLoadLock(userId, 10000);- expect(lock2).toBe(false);-- const waitPromise = loadStatusCache.waitForLoad(userId, 3000, 100);-- // Process 1: Completes loading after 300ms- const process1Promise = new Promise<void>((resolve) => {- setTimeout(async () => {- await loadStatusCache.setLoaded(userId, 60000);- await new Promise((r) => setTimeout(r, 50)); // Redis write delay- await loadStatusCache.releaseLoadLock(userId);- resolve();- }, 300);- });-- // Process 2: Should detect completion- const completed = await waitPromise;- expect(completed).toBe(true);-- // Both processes should now see it as loaded- expect(await loadStatusCache.isLoaded(userId)).toBe(true);-- // Wait for process 1 to complete cleanup- await process1Promise;- }, 10000);-- it('should handle process crash scenario (lock timeout)', async () => {- const userId = `user-crash-${testCounter}`;-- // Process 1: Acquires lock but crashes (doesn't release)- const lock1 = await loadStatusCache.acquireLoadLock(userId, 1000); // 1 second TTL- expect(lock1).toBe(true);- // (simulate crash - no releaseLoadLock call)-- // Process 2: Waits for timeout- const waitResult = await loadStatusCache.waitForLoad(userId, 1500, 200);- expect(waitResult).toBe(false); // Timeout (process 1 never completed)-- // After lock TTL expires, process 2 can retry- await new Promise((resolve) => setTimeout(resolve, 200));-- const retryLock = await loadStatusCache.acquireLoadLock(userId, 10000);- expect(retryLock).toBe(true);-- // Process 2 completes successfully- await loadStatusCache.setLoaded(userId, 60000);- await loadStatusCache.releaseLoadLock(userId);-- expect(await loadStatusCache.isLoaded(userId)).toBe(true);- }, 10000);-- it('should handle concurrent user loads independently', async () => {- const user1 = `user-concurrent-1-${testCounter}`;- const user2 = `user-concurrent-2-${testCounter}`;- const user3 = `user-concurrent-3-${testCounter}`;-- // Simulate 3 users loading concurrently- const user1Lock = await loadStatusCache.acquireLoadLock(user1, 10000);- const user2Lock = await loadStatusCache.acquireLoadLock(user2, 10000);- const user3Lock = await loadStatusCache.acquireLoadLock(user3, 10000);-- expect(user1Lock).toBe(true);- expect(user2Lock).toBe(true);- expect(user3Lock).toBe(true);-- // All complete independently- await Promise.all([- (async () => {- await loadStatusCache.setLoaded(user1, 60000);- await loadStatusCache.releaseLoadLock(user1);- })(),- (async () => {- await loadStatusCache.setLoaded(user2, 60000);- await loadStatusCache.releaseLoadLock(user2);- })(),- (async () => {- await loadStatusCache.setLoaded(user3, 60000);- await loadStatusCache.releaseLoadLock(user3);- })(),- ]);-- // Small delay for Redis propagation- await new Promise((resolve) => setTimeout(resolve, 100));-- expect(await loadStatusCache.isLoaded(user1)).toBe(true);- expect(await loadStatusCache.isLoaded(user2)).toBe(true);- expect(await loadStatusCache.isLoaded(user3)).toBe(true);- });- });-- describe('TTL synchronization', () => {- it('should keep loaded flag and cache entry in sync via TTL', async () => {- const userId = `user-ttl-sync-${testCounter}`;-- // Set loaded flag with 1 second TTL- await loadStatusCache.setLoaded(userId, 1000);-- expect(await loadStatusCache.isLoaded(userId)).toBe(true);-- // After TTL expires, both should be gone- await new Promise((resolve) => setTimeout(resolve, 1100));-- expect(await loadStatusCache.isLoaded(userId)).toBe(false);-- // This simulates cache entry and loaded flag being in sync- // In real usage, if cache entries expire, loaded flag should also expire- }, 10000);-- it('should allow different TTLs for different users', async () => {- const user1 = `user-ttl-diff-1-${testCounter}`;- const user2 = `user-ttl-diff-2-${testCounter}`;-- await loadStatusCache.setLoaded(user1, 1000); // 1 second- await loadStatusCache.setLoaded(user2, 3000); // 3 seconds-- expect(await loadStatusCache.isLoaded(user1)).toBe(true);- expect(await loadStatusCache.isLoaded(user2)).toBe(true);-- // Wait for user1 to expire- await new Promise((resolve) => setTimeout(resolve, 1100));-- expect(await loadStatusCache.isLoaded(user1)).toBe(false);- expect(await loadStatusCache.isLoaded(user2)).toBe(true); // Still valid-- // Wait for user2 to expire- await new Promise((resolve) => setTimeout(resolve, 2000));-- expect(await loadStatusCache.isLoaded(user2)).toBe(false);- }, 10000);- });-- describe('clearLoaded() integration', () => {- it('should clear loaded status immediately', async () => {- const userId = `user-clear-${testCounter}`;-- await loadStatusCache.setLoaded(userId, 60000);- expect(await loadStatusCache.isLoaded(userId)).toBe(true);-- await loadStatusCache.clearLoaded(userId);- expect(await loadStatusCache.isLoaded(userId)).toBe(false);- });-- it('should allow clearing multiple users', async () => {- const user1 = `user-clear-multi-1-${testCounter}`;- const user2 = `user-clear-multi-2-${testCounter}`;-- await loadStatusCache.setLoaded(user1, 60000);- await loadStatusCache.setLoaded(user2, 60000);-- await loadStatusCache.clearLoaded(user1);- await loadStatusCache.clearLoaded(user2);-- expect(await loadStatusCache.isLoaded(user1)).toBe(false);- expect(await loadStatusCache.isLoaded(user2)).toBe(false);- });- });-});diff --git a/packages/api/src/mcp/registry/cache/__tests__/PrivateServersLoadStatusCache.test.ts b/packages/api/src/mcp/registry/cache/__tests__/PrivateServersLoadStatusCache.test.tsdeleted file mode 100644index 881f82f2e5..0000000000--- a/packages/api/src/mcp/registry/cache/__tests__/PrivateServersLoadStatusCache.test.ts+++ /dev/null@@ -1,329 +0,0 @@-// Mock dependencies BEFORE imports to avoid hoisting issues-const mockGet = jest.fn();-const mockSet = jest.fn();-const mockDelete = jest.fn();-const mockRedisSet = jest.fn();-const mockRedisDel = jest.fn();--jest.mock('~/cache', () => ({- standardCache: jest.fn(() => ({- // eslint-disable-next-line @typescript-eslint/no-explicit-any- get: (...args: any[]) => mockGet(...args),- // eslint-disable-next-line @typescript-eslint/no-explicit-any- set: (...args: any[]) => mockSet(...args),- // eslint-disable-next-line @typescript-eslint/no-explicit-any- delete: (...args: any[]) => mockDelete(...args),- })),- keyvRedisClient: {- // eslint-disable-next-line @typescript-eslint/no-explicit-any- set: (...args: any[]) => mockRedisSet(...args),- // eslint-disable-next-line @typescript-eslint/no-explicit-any- del: (...args: any[]) => mockRedisDel(...args),- },-}));--jest.mock('~/cache/cacheConfig', () => ({- cacheConfig: {- REDIS_KEY_PREFIX: '',- GLOBAL_PREFIX_SEPARATOR: '::',- },-}));--jest.mock('@librechat/data-schemas', () => ({- logger: {- debug: jest.fn(),- info: jest.fn(),- warn: jest.fn(),- error: jest.fn(),- },-}));--jest.mock('~/cluster', () => ({- isLeader: jest.fn().mockResolvedValue(true),-}));--import { privateServersLoadStatusCache as loadStatusCache } from '../PrivateServersLoadStatusCache';-import { logger } from '@librechat/data-schemas';--describe('PrivateServersLoadStatusCache', () => {- beforeEach(() => {- jest.clearAllMocks();- });-- describe('isLoaded()', () => {- it('should return true when user servers are loaded', async () => {- mockGet.mockResolvedValue(true);-- const result = await loadStatusCache.isLoaded('user1');-- expect(result).toBe(true);- expect(mockGet).toHaveBeenCalledWith('USER_PRIVATE_SERVERS_LOADED::user1');- });-- it('should return false when user servers are not loaded', async () => {- mockGet.mockResolvedValue(undefined);-- const result = await loadStatusCache.isLoaded('user1');-- expect(result).toBe(false);- expect(mockGet).toHaveBeenCalledWith('USER_PRIVATE_SERVERS_LOADED::user1');- });-- it('should return false when loaded flag is explicitly false', async () => {- mockGet.mockResolvedValue(false);-- const result = await loadStatusCache.isLoaded('user1');-- expect(result).toBe(false);- });- });-- describe('setLoaded()', () => {- it('should set loaded flag with default TTL', async () => {- mockSet.mockResolvedValue(true);-- await loadStatusCache.setLoaded('user1');-- expect(mockSet).toHaveBeenCalledWith('USER_PRIVATE_SERVERS_LOADED::user1', true, 3600_000);- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][LoadStatusCache] Marked user user1 as loaded (TTL: 3600000ms)',- );- });-- it('should set loaded flag with custom TTL', async () => {- mockSet.mockResolvedValue(true);-- await loadStatusCache.setLoaded('user1', 7200000);-- expect(mockSet).toHaveBeenCalledWith('USER_PRIVATE_SERVERS_LOADED::user1', true, 7200_000);- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][LoadStatusCache] Marked user user1 as loaded (TTL: 7200000ms)',- );- });-- it('should throw error if cache.set fails', async () => {- mockSet.mockResolvedValue(false);-- await expect(loadStatusCache.setLoaded('user1')).rejects.toThrow();- });- });-- describe('acquireLoadLock()', () => {- it('should acquire lock successfully when no lock exists (using Redis SET NX)', async () => {- mockRedisSet.mockResolvedValue('OK'); // Redis SET NX returns 'OK' on success-- const result = await loadStatusCache.acquireLoadLock('user1');-- expect(result).toBe(true);- expect(mockRedisSet).toHaveBeenCalledWith(- 'MCP::ServersRegistry::PrivateServersLoadStatus:USER_PRIVATE_SERVERS_LOAD_LOCK::user1',- expect.any(String), // Timestamp as string- { NX: true, PX: 30000 },- );- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][LoadStatusCache] Acquired load lock for user user1 (TTL: 30000ms)',- );- });-- it('should fail to acquire lock when lock already exists (Redis returns null)', async () => {- mockRedisSet.mockResolvedValue(null); // Redis SET NX returns null if key exists-- const result = await loadStatusCache.acquireLoadLock('user1');-- expect(result).toBe(false);- expect(mockRedisSet).toHaveBeenCalledWith(- 'MCP::ServersRegistry::PrivateServersLoadStatus:USER_PRIVATE_SERVERS_LOAD_LOCK::user1',- expect.any(String),- { NX: true, PX: 30000 },- );- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][LoadStatusCache] Load lock already held for user user1',- );- });-- it('should acquire lock with custom TTL', async () => {- mockRedisSet.mockResolvedValue('OK');-- const result = await loadStatusCache.acquireLoadLock('user1', 60_000);-- expect(result).toBe(true);- expect(mockRedisSet).toHaveBeenCalledWith(- 'MCP::ServersRegistry::PrivateServersLoadStatus:USER_PRIVATE_SERVERS_LOAD_LOCK::user1',- expect.any(String),- { NX: true, PX: 60_000 },- );- });-- it('should return false if Redis SET fails with error', async () => {- mockRedisSet.mockRejectedValue(new Error('Redis error'));-- const result = await loadStatusCache.acquireLoadLock('user1');-- expect(result).toBe(false);- expect(logger.error).toHaveBeenCalledWith(- '[MCP][LoadStatusCache] Error acquiring lock for user user1:',- expect.any(Error),- );- });- });-- describe('releaseLoadLock()', () => {- it('should release lock successfully', async () => {- await loadStatusCache.releaseLoadLock('user1');-- expect(mockDelete).toHaveBeenCalledWith('USER_PRIVATE_SERVERS_LOAD_LOCK::user1');- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][LoadStatusCache] Released load lock for user user1',- );- });-- it('should not throw error if lock does not exist', async () => {- mockDelete.mockResolvedValue(undefined);-- await expect(loadStatusCache.releaseLoadLock('user1')).resolves.not.toThrow();- });- });-- describe('waitForLoad()', () => {- let mockDateNow: jest.SpyInstance;- let currentTime: number;-- beforeEach(() => {- jest.useFakeTimers();- currentTime = 1000000; // Starting time- mockDateNow = jest.spyOn(Date, 'now').mockImplementation(() => currentTime);- });-- afterEach(() => {- jest.useRealTimers();- mockDateNow.mockRestore();- });-- it('should return true when loading completes within timeout', async () => {- let checkCount = 0;- mockGet.mockImplementation(async () => {- checkCount++;- return checkCount >= 3; // Return true on third check- });-- const waitPromise = loadStatusCache.waitForLoad('user1', 500, 100);-- // Simulate time passing- for (let i = 0; i < 3; i++) {- currentTime += 100;- await jest.advanceTimersByTimeAsync(100);- }-- const result = await waitPromise;-- expect(result).toBe(true);- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][LoadStatusCache] User user1 loading completed by another process',- );- });-- it('should return false when timeout is reached', async () => {- mockGet.mockResolvedValue(false); // Never becomes true-- const waitPromise = loadStatusCache.waitForLoad('user1', 300, 100);-- // Advance time past the timeout- currentTime += 400;- await jest.advanceTimersByTimeAsync(400);-- const result = await waitPromise;-- expect(result).toBe(false);- expect(logger.warn).toHaveBeenCalledWith(- '[MCP][LoadStatusCache] Timeout waiting for user user1 loading (waited 300ms)',- );- });-- it('should use default timeout and check interval', async () => {- mockGet.mockResolvedValue(true);-- const waitPromise = loadStatusCache.waitForLoad('user1');-- currentTime += 100;- await jest.advanceTimersByTimeAsync(100);-- const result = await waitPromise;-- expect(result).toBe(true);- });-- it('should poll at specified intervals', async () => {- let checkCount = 0;- mockGet.mockImplementation(async () => {- checkCount++;- return checkCount >= 4; // Return true on fourth check- });-- const waitPromise = loadStatusCache.waitForLoad('user1', 1000, 200);-- // Advance time for each poll- for (let i = 0; i < 4; i++) {- currentTime += 200;- await jest.advanceTimersByTimeAsync(200);- }-- const result = await waitPromise;-- expect(result).toBe(true);- expect(checkCount).toBe(4);- });- });-- describe('clearLoaded()', () => {- it('should clear loaded status for a user', async () => {- await loadStatusCache.clearLoaded('user1');-- expect(mockDelete).toHaveBeenCalledWith('USER_PRIVATE_SERVERS_LOADED::user1');- expect(logger.debug).toHaveBeenCalledWith(- '[MCP][LoadStatusCache] Cleared loaded status for user user1',- );- });-- it('should not throw error if loaded status does not exist', async () => {- mockDelete.mockResolvedValue(undefined);-- await expect(loadStatusCache.clearLoaded('user1')).resolves.not.toThrow();- });- });-- describe('Edge cases', () => {- it('should handle multiple users independently', async () => {- mockRedisSet.mockResolvedValue('OK');-- const lock1 = await loadStatusCache.acquireLoadLock('user1');- const lock2 = await loadStatusCache.acquireLoadLock('user2');-- expect(lock1).toBe(true);- expect(lock2).toBe(true);- expect(mockRedisSet).toHaveBeenCalledWith(- 'MCP::ServersRegistry::PrivateServersLoadStatus:USER_PRIVATE_SERVERS_LOAD_LOCK::user1',- expect.any(String),- { NX: true, PX: 30000 },- );- expect(mockRedisSet).toHaveBeenCalledWith(- 'MCP::ServersRegistry::PrivateServersLoadStatus:USER_PRIVATE_SERVERS_LOAD_LOCK::user2',- expect.any(String),- { NX: true, PX: 30000 },- );- });-- it('should handle concurrent operations on same user', async () => {- mockRedisSet- .mockResolvedValueOnce('OK') // First lock attempt succeeds- .mockResolvedValueOnce(null); // Second lock attempt fails (key exists)-- const [lock1, lock2] = await Promise.all([- loadStatusCache.acquireLoadLock('user1'),- loadStatusCache.acquireLoadLock('user1'),- ]);-- // One should succeed, one should fail (order not guaranteed)- expect([lock1, lock2].sort()).toEqual([false, true]);- });- });-});diff --git a/packages/api/src/mcp/registry/cache/__tests__/ServerConfigsCacheFactory.test.ts b/packages/api/src/mcp/registry/cache/__tests__/ServerConfigsCacheFactory.test.tsindex 1be5bf290a..7499ae127e 100644--- a/packages/api/src/mcp/registry/cache/__tests__/ServerConfigsCacheFactory.test.ts+++ b/packages/api/src/mcp/registry/cache/__tests__/ServerConfigsCacheFactory.test.ts@@ -25,11 +25,11 @@ describe('ServerConfigsCacheFactory', () => {cacheConfig.USE_REDIS = true;// Act- const cache = ServerConfigsCacheFactory.create('TestOwner', 'Private', true);+ const cache = ServerConfigsCacheFactory.create('App', true);// Assertexpect(cache).toBeInstanceOf(ServerConfigsCacheRedis);- expect(ServerConfigsCacheRedis).toHaveBeenCalledWith('TestOwner', 'Private', true);+ expect(ServerConfigsCacheRedis).toHaveBeenCalledWith('App', true);});it('should return ServerConfigsCacheInMemory when USE_REDIS is false', () => {@@ -37,7 +37,7 @@ describe('ServerConfigsCacheFactory', () => {cacheConfig.USE_REDIS = false;// Act- const cache = ServerConfigsCacheFactory.create('TestOwner', 'Private', false);+ const cache = ServerConfigsCacheFactory.create('App', false);// Assertexpect(cache).toBeInstanceOf(ServerConfigsCacheInMemory);@@ -49,10 +49,10 @@ describe('ServerConfigsCacheFactory', () => {cacheConfig.USE_REDIS = true;// Act- ServerConfigsCacheFactory.create('App', 'Shared', true);+ ServerConfigsCacheFactory.create('CustomNamespace', true);// Assert- expect(ServerConfigsCacheRedis).toHaveBeenCalledWith('App', 'Shared', true);+ expect(ServerConfigsCacheRedis).toHaveBeenCalledWith('CustomNamespace', true);});it('should create ServerConfigsCacheInMemory without parameters when USE_REDIS is false', () => {@@ -60,10 +60,10 @@ describe('ServerConfigsCacheFactory', () => {cacheConfig.USE_REDIS = false;// Act- ServerConfigsCacheFactory.create('User', 'Shared', false);+ ServerConfigsCacheFactory.create('App', false);// Assert- // In-memory cache doesn't use owner/leaderOnly parameters+ // In-memory cache doesn't use namespace/leaderOnly parametersexpect(ServerConfigsCacheInMemory).toHaveBeenCalledWith();});});diff --git a/packages/api/src/mcp/registry/db/ServerConfigsDB.ts b/packages/api/src/mcp/registry/db/ServerConfigsDB.tsnew file mode 100644index 0000000000..302a086193--- /dev/null+++ b/packages/api/src/mcp/registry/db/ServerConfigsDB.ts@@ -0,0 +1,50 @@+/* eslint-disable @typescript-eslint/no-unused-vars */+import { ParsedServerConfig } from '~/mcp/types';+import { IServerConfigsRepositoryInterface } from '../ServerConfigsRepositoryInterface';+import { logger } from '@librechat/data-schemas';++/**+ * DB backed config storage+ * Handles CRUD Methods of dynamic mcp servers+ * Will handle Permission ACL+ */+export class ServerConfigsDB implements IServerConfigsRepositoryInterface {+ public async add(serverName: string, config: ParsedServerConfig, userId?: string): Promise<void> {+ logger.debug('ServerConfigsDB add not yet implemented');+ return;+ }++ public async update(+ serverName: string,+ config: ParsedServerConfig,+ userId?: string,+ ): Promise<void> {+ logger.debug('ServerConfigsDB update not yet implemented');+ return;+ }++ public async remove(serverName: string, userId?: string): Promise<void> {+ logger.debug('ServerConfigsDB remove not yet implemented');+ return;+ }++ public async get(serverName: string, userId?: string): Promise<ParsedServerConfig | undefined> {+ logger.debug('ServerConfigsDB get not yet implemented');+ return;+ }++ /**+ * Return all DB stored configs (scoped by user Id if provided)+ * @param userId optional user id. if not provided only publicly shared mcp configs will be returned+ * @returns record of parsed configs+ */+ public async getAll(userId?: string): Promise<Record<string, ParsedServerConfig>> {+ logger.debug('ServerConfigsDB getAll not yet implemented');+ return {};+ }++ public async reset(): Promise<void> {+ logger.warn('Attempt to reset the DB config storage');+ return;+ }+}