diff --git a/packages/api/src/mcp/registry/__tests__/ServerConfigsDB.test.ts b/packages/api/src/mcp/registry/__tests__/ServerConfigsDB.test.ts index 4d8917f406..37f1096e3d 100644 --- a/packages/api/src/mcp/registry/__tests__/ServerConfigsDB.test.ts +++ b/packages/api/src/mcp/registry/__tests__/ServerConfigsDB.test.ts @@ -24,6 +24,7 @@ let MCPOAuthHandler: MCPOAuthHandlerType; let createModels: CreateModelsType; let createMethods: CreateMethodsType; let RoleBits: RoleBitsType; +let getMCPAppToolsPublicationGeneration: typeof import('~/mcp/toolsChanged').getMCPAppToolsPublicationGeneration; // Test data helpers const createSSEConfig = ( @@ -71,6 +72,7 @@ beforeAll(async () => { ServerConfigsDB = serverConfigsModule.ServerConfigsDB; const oauthModule = await import('~/mcp/oauth'); MCPOAuthHandler = oauthModule.MCPOAuthHandler; + ({ getMCPAppToolsPublicationGeneration } = await import('~/mcp/toolsChanged')); mongoServer = await MongoMemoryServer.create(); const mongoUri = mongoServer.getUri(); @@ -1046,6 +1048,157 @@ describe('ServerConfigsDB', () => { }); }); + describe.each(['sse', 'streamable-http'] as const)('%s header persistence', (type) => { + const safeHeaders = { 'X-Safe': 'value', Authorization: 'Bearer {{MCP_API_KEY}}' }; + const unsafeHeaders = { + ...safeHeaders, + 'X-Secret': '${SECRET}:{{LIBRECHAT_OPENID_ACCESS_TOKEN}}', + }; + const sanitizedHeaders = { ...safeHeaders, 'X-Secret': ':' }; + + it.each([ + { name: 'omitted', maps: {}, expected: {} }, + { + name: 'explicit undefined', + maps: { headers: undefined, requestHeaders: undefined }, + expected: {}, + }, + { + name: 'empty', + maps: { headers: {}, requestHeaders: {} }, + expected: { headers: {}, requestHeaders: {} }, + }, + { + name: 'headers only', + maps: { headers: unsafeHeaders }, + expected: { headers: sanitizedHeaders }, + }, + { + name: 'requestHeaders only', + maps: { requestHeaders: unsafeHeaders }, + expected: { requestHeaders: sanitizedHeaders }, + }, + { + name: 'both populated', + maps: { headers: unsafeHeaders, requestHeaders: unsafeHeaders }, + expected: { headers: sanitizedHeaders, requestHeaders: sanitizedHeaders }, + }, + ])('preserves $name maps through add, update and upsert', async ({ maps, expected }) => { + const config = { + type, + url: 'https://example.com/mcp', + title: 'Header Persistence', + requiresOAuth: true, + ...maps, + } satisfies ParsedServerConfig; + const original = structuredClone(config); + const created = await serverConfigsDB.add('temp-name', config, userId); + const assertRoundTrip = async (minimized = false) => { + const stored = await mongoose.models.MCPServer.collection.findOne({ + serverName: created.serverName, + }); + const result = await serverConfigsDB.get(created.serverName, userId); + const all = await serverConfigsDB.getAll(userId); + expect(result).toBeDefined(); + for (const key of ['headers', 'requestHeaders'] as const) { + const value = expected[key]; + if (value != null && (!minimized || Object.keys(value).length > 0)) { + expect(stored?.config[key]).toEqual(value); + expect(result).toHaveProperty(key, expected[key]); + } else { + expect(stored?.config).not.toHaveProperty(key); + expect(result).not.toHaveProperty(key); + } + } + expect(all[created.serverName]).toEqual(result); + expect(MCPOptionsSchema.safeParse(result).success).toBe(true); + expect(() => getMCPAppToolsPublicationGeneration(result!)).not.toThrow(); + }; + + /** Mongoose minimizes empty objects on create, but preserves them on update. */ + await assertRoundTrip(true); + for (const method of ['update', 'upsert'] as const) { + await serverConfigsDB.update( + created.serverName, + { + ...config, + headers: { 'X-Old': 'remove me' }, + requestHeaders: { 'X-Old': 'remove me too' }, + }, + userId, + ); + await serverConfigsDB[method](created.serverName, config, userId); + await assertRoundTrip(); + } + expect(config).toEqual(original); + }); + + it.each([ + { name: 'headers null', maps: { headers: null }, expected: {} }, + { name: 'requestHeaders null', maps: { requestHeaders: null }, expected: {} }, + { name: 'both null', maps: { headers: null, requestHeaders: null }, expected: {} }, + { + name: 'headers null with request headers', + maps: { headers: null, requestHeaders: safeHeaders }, + expected: { requestHeaders: safeHeaders }, + }, + { + name: 'requestHeaders null with headers', + maps: { headers: safeHeaders, requestHeaders: null }, + expected: { headers: safeHeaders }, + }, + { + name: 'headers null with empty request headers', + maps: { headers: null, requestHeaders: {} }, + expected: { requestHeaders: {} }, + }, + { + name: 'requestHeaders null with empty headers', + maps: { headers: {}, requestHeaders: null }, + expected: { headers: {} }, + }, + ])('normalizes historical $name on single and bulk reads', async ({ maps, expected }) => { + const created = await serverConfigsDB.add( + 'temp-name', + { + type, + url: 'https://example.com/mcp', + title: 'Historical Headers', + requiresOAuth: true, + }, + userId, + ); + await mongoose.models.MCPServer.collection.updateOne( + { serverName: created.serverName }, + { + $set: { config: { type, url: 'https://example.com/mcp', requiresOAuth: true, ...maps } }, + }, + ); + const stored = await mongoose.models.MCPServer.collection.findOne({ + serverName: created.serverName, + }); + expect(MCPOptionsSchema.safeParse(stored?.config).success).toBe(false); + + const result = await serverConfigsDB.get(created.serverName, userId); + const all = await serverConfigsDB.getAll(userId); + expect(result).toBeDefined(); + for (const key of ['headers', 'requestHeaders'] as const) { + if (expected[key] != null) { + expect(result).toHaveProperty(key, expected[key]); + } else { + expect(result).not.toHaveProperty(key); + } + } + expect(all[created.serverName]).toEqual(result); + expect(MCPOptionsSchema.safeParse(result).success).toBe(true); + const generation = getMCPAppToolsPublicationGeneration(result!); + expect(getMCPAppToolsPublicationGeneration(all[created.serverName])).toBe(generation); + expect( + await mongoose.models.MCPServer.collection.findOne({ serverName: created.serverName }), + ).toEqual(stored); + }); + }); + describe('get()', () => { it('normalizes null headers from historical stored configs before runtime use', async () => { const server = await mongoose.models.MCPServer.create({ diff --git a/packages/api/src/mcp/registry/db/ServerConfigsDB.ts b/packages/api/src/mcp/registry/db/ServerConfigsDB.ts index 383b6a654b..109d0572c1 100644 --- a/packages/api/src/mcp/registry/db/ServerConfigsDB.ts +++ b/packages/api/src/mcp/registry/db/ServerConfigsDB.ts @@ -62,20 +62,21 @@ function sanitizeCredentialPlaceholders( * Sanitizes every header map a shared config carries. `requestHeaders` is * included because it reaches the upstream server exactly like `headers` does: * left unsanitized, a user-managed config could name a privileged placeholder - * there and have the runtime resolve it at chat time. + * there and have the runtime resolve it at chat time. Absent maps stay omitted + * because BSON can serialize explicit undefined properties as null. */ -function sanitizeConfigHeaderMaps(config: ParsedServerConfig): { - headers?: Record; - requestHeaders?: Record; -} { - const carrier = config as ParsedServerConfig & { +function sanitizeConfigHeaderMaps(config: ParsedServerConfig): ParsedServerConfig { + const { headers, requestHeaders, ...rest } = config as ParsedServerConfig & { headers?: Record; requestHeaders?: Record; }; return { - headers: sanitizeCredentialPlaceholders(carrier.headers), - requestHeaders: sanitizeCredentialPlaceholders(carrier.requestHeaders), - }; + ...rest, + ...(headers != null && { headers: sanitizeCredentialPlaceholders(headers) }), + ...(requestHeaders != null && { + requestHeaders: sanitizeCredentialPlaceholders(requestHeaders), + }), + } as ParsedServerConfig; } function stripBlockedOAuthEndpointParams(url?: string): string | undefined { @@ -121,13 +122,18 @@ function sanitizeUserManagedOAuthConfig(config: ParsedServerConfig): ParsedServe function normalizePersistedConfig(config: ParsedServerConfig): ParsedServerConfig { const persistedConfig = config as ParsedServerConfig & { headers?: Record | null; + requestHeaders?: Record | null; }; - if (persistedConfig.headers !== null) { + if (persistedConfig.headers !== null && persistedConfig.requestHeaders !== null) { return config; } - const { headers: _legacyNullHeaders, ...normalizedConfig } = persistedConfig; - return normalizedConfig as ParsedServerConfig; + const { headers, requestHeaders, ...rest } = persistedConfig; + return { + ...rest, + ...(headers != null && { headers }), + ...(requestHeaders != null && { requestHeaders }), + } as ParsedServerConfig; } function normalizeOAuthUrl(value?: string): string | undefined { @@ -315,10 +321,7 @@ export class ServerConfigsDB implements IServerConfigsRepositoryInterface { ); } - const sanitizedConfig = sanitizeUserManagedOAuthConfig({ - ...config, - ...sanitizeConfigHeaderMaps(config), - } as ParsedServerConfig); + const sanitizedConfig = sanitizeUserManagedOAuthConfig(sanitizeConfigHeaderMaps(config)); /** Transformed user-provided API key config (adds customUserVars and headers) */ const transformedConfig = this.transformUserApiKeyConfig(sanitizedConfig); @@ -366,10 +369,9 @@ export class ServerConfigsDB implements IServerConfigsRepositoryInterface { requireApiKeyReentryForRebinding(existingServer.config, config); } - let configToSave: ParsedServerConfig = sanitizeUserManagedOAuthConfig({ - ...config, - ...sanitizeConfigHeaderMaps(config), - } as ParsedServerConfig); + let configToSave: ParsedServerConfig = sanitizeUserManagedOAuthConfig( + sanitizeConfigHeaderMaps(config), + ); /** Transformed user-provided API key config (adds customUserVars and headers) */ configToSave = this.transformUserApiKeyConfig(configToSave);