Skip to content

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

108 KB
Raw Blame
import mongoose from 'mongoose';
import { MongoMemoryServer } from 'mongodb-memory-server';
import {
  ResourceType,
  AccessRoleIds,
  PrincipalType,
  PermissionBits,
  PrincipalModel,
  MCPOptionsSchema,
  TokenExchangeMethodEnum,
} from 'librechat-data-provider';
import type { ParsedServerConfig } from '~/mcp/types';

type ServerConfigsDBType = import('../db/ServerConfigsDB').ServerConfigsDB;
type MCPOAuthHandlerType = typeof import('~/mcp/oauth').MCPOAuthHandler;
type CreateMethodsType = typeof import('@librechat/data-schemas').createMethods;
type CreateModelsType = typeof import('@librechat/data-schemas').createModels;
type RoleBitsType = typeof import('@librechat/data-schemas').RoleBits;

let mongoServer: MongoMemoryServer;
let serverConfigsDB: ServerConfigsDBType;
let ServerConfigsDB: new (mongoose: typeof import('mongoose')) => ServerConfigsDBType;
let MCPOAuthHandler: MCPOAuthHandlerType;
let createModels: CreateModelsType;
let createMethods: CreateMethodsType;
let RoleBits: RoleBitsType;
let encrypt: typeof import('@librechat/data-schemas').encrypt;
let getUserMCPAuthMap: typeof import('~/mcp/auth').getUserMCPAuthMap;
let processMCPEnv: typeof import('~/utils/env').processMCPEnv;
let getMissingCustomUserVars: typeof import('~/mcp/utils').getMissingCustomUserVars;
let getMCPAppToolsPublicationGeneration: typeof import('~/mcp/toolsChanged').getMCPAppToolsPublicationGeneration;

// Test data helpers
const createSSEConfig = (
  title?: string,
  description?: string,
  oauth?: { client_secret?: string; client_id?: string },
): ParsedServerConfig => ({
  type: 'sse',
  url: 'https://example.com/mcp',
  ...(title && { title }),
  ...(description && { description }),
  ...(oauth && { oauth }),
});

let dbMethods: ReturnType<CreateMethodsType>;

/** `Model.find` overloads reduce the spy's inferred arguments to an empty tuple,
 *  so the recorded calls are re-typed here and mapped to their filter. */
function aclFindFilters(spy: jest.SpyInstance): Array<Record<string, unknown>> {
  const calls = spy.mock.calls as unknown as Array<[Record<string, unknown>]>;
  return calls.map(([filter]) => filter);
}

beforeAll(async () => {
  // Set encryption keys BEFORE importing modules that use crypto
  process.env.CREDS_KEY = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
  process.env.CREDS_IV = '0123456789abcdef0123456789abcdef';

  // Clear module cache so crypto module loads with new env vars
  jest.resetModules();

  // Dynamic imports after setting env vars
  const dataSchemas = await import('@librechat/data-schemas');
  createModels = dataSchemas.createModels;
  createMethods = dataSchemas.createMethods;
  RoleBits = dataSchemas.RoleBits;
  encrypt = dataSchemas.encrypt;
  ({ getUserMCPAuthMap } = await import('~/mcp/auth'));
  ({ processMCPEnv } = await import('~/utils/env'));
  ({ getMissingCustomUserVars } = await import('~/mcp/utils'));

  // Mock logger after import (suppress logs during tests)
  jest.spyOn(dataSchemas.logger, 'error').mockReturnValue(dataSchemas.logger);
  jest.spyOn(dataSchemas.logger, 'warn').mockReturnValue(dataSchemas.logger);
  jest.spyOn(dataSchemas.logger, 'debug').mockReturnValue(dataSchemas.logger);
  jest.spyOn(dataSchemas.logger, 'info').mockReturnValue(dataSchemas.logger);

  const serverConfigsModule = await import('../db/ServerConfigsDB');
  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();
  await mongoose.connect(mongoUri);

  // Initialize all models
  createModels(mongoose);

  // Create methods and seed default roles
  dbMethods = createMethods(mongoose);
  await dbMethods.seedDefaultRoles();

  serverConfigsDB = new ServerConfigsDB(mongoose);
  /** Booting a real mongod, resetting the module registry and re-importing
   *  data-schemas costs more than the 15s global `testTimeout`, once the runner
   *  is busy enough. Matches `checkpointer.integration.spec.ts`. */
}, 60000);

afterAll(async () => {
  await mongoose.disconnect();
  await mongoServer.stop();
}, 60000);

beforeEach(async () => {
  // Clear collections except AccessRole
  await mongoose.models.MCPServer.deleteMany({});
  await mongoose.models.Agent.deleteMany({});
  await mongoose.models.PluginAuth.deleteMany({});
  await mongoose.models.AclEntry.deleteMany({});
});

describe('ServerConfigsDB', () => {
  const userId = new mongoose.Types.ObjectId().toString();
  const userId2 = new mongoose.Types.ObjectId().toString();

  describe('constructor', () => {
    it('should throw error when mongoose is not provided', () => {
      expect(() => new ServerConfigsDB(null as unknown as typeof mongoose)).toThrow(
        'ServerConfigsDB requires mongoose instance',
      );
    });

    it('should create instance when mongoose is provided', () => {
      const instance = new ServerConfigsDB(mongoose);
      expect(instance).toBeInstanceOf(ServerConfigsDB);
    });
  });

  describe('add()', () => {
    it('should throw error when userId is not provided', async () => {
      await expect(serverConfigsDB.add('test-server', createSSEConfig('Test'))).rejects.toThrow(
        'User ID is required to create a database-stored MCP server',
      );
    });

    it('should create server and return AddServerResult with generated serverName', async () => {
      const config = createSSEConfig('My Test Server', 'A test server');
      const result = await serverConfigsDB.add('temp-name', config, userId);

      expect(result).toBeDefined();
      expect(result.serverName).toBe('my-test-server');
      expect(result.config).toMatchObject({
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'My Test Server',
        description: 'A test server',
      });
      expect(result.config.dbId).toBeDefined();
    });

    it('should reserve operator-managed server names when creating a DB server', async () => {
      const config = createSSEConfig('My Test Server', 'A test server');
      const result = await serverConfigsDB.add('temp-name', config, userId, ['my-test-server']);

      expect(result.serverName).toBe('my-test-server-2');
    });

    it('should grant owner ACL to the user', async () => {
      const config = createSSEConfig('ACL Test Server');
      const result = await serverConfigsDB.add('temp-name', config, userId);

      // Verify ACL entry was created
      const aclEntry = await mongoose.models.AclEntry.findOne({
        principalType: PrincipalType.USER,
        principalId: new mongoose.Types.ObjectId(userId),
        resourceType: ResourceType.MCPSERVER,
      });

      expect(aclEntry).toBeDefined();
      expect(aclEntry!.resourceId.toString()).toBe(result.config.dbId);
      // OWNER role has VIEW | EDIT | DELETE | SHARE = 15
      expect(aclEntry!.permBits).toBe(RoleBits.OWNER);
    });

    it('should include dbId and updatedAt in returned config', async () => {
      const config = createSSEConfig('Metadata Test');
      const result = await serverConfigsDB.add('temp-name', config, userId);

      expect(result.config.dbId).toBeDefined();
      expect(typeof result.config.dbId).toBe('string');
      expect(result.config.updatedAt).toBeDefined();
      expect(typeof result.config.updatedAt).toBe('number');
    });
  });

  describe('update()', () => {
    it('should throw error when userId is not provided', async () => {
      await expect(serverConfigsDB.update('test-server', createSSEConfig('Test'))).rejects.toThrow(
        'User ID is required to update a database-stored MCP server',
      );
    });

    it('should update server config', async () => {
      const config = createSSEConfig('Original Title', 'Original description');
      const created = await serverConfigsDB.add('temp-name', config, userId);

      const updatedConfig = createSSEConfig('Original Title', 'Updated description');
      await serverConfigsDB.update(created.serverName, updatedConfig, userId);

      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.description).toBe('Updated description');
    });

    it('returns the config as persisted, so an overlapping update is not mistaken for this one', async () => {
      const created = await serverConfigsDB.add(
        'temp-name',
        createSSEConfig('Title', 'First'),
        userId,
      );

      const firstWrite = await serverConfigsDB.update(
        created.serverName,
        createSSEConfig('Title', 'Second'),
        userId,
      );
      await serverConfigsDB.update(created.serverName, createSSEConfig('Title', 'Third'), userId);

      expect(firstWrite?.description).toBe('Second');
      expect((await serverConfigsDB.get(created.serverName, userId))?.description).toBe('Third');
    });

    it('rejects an update when the server was deleted after the lookup', async () => {
      const created = await serverConfigsDB.add(
        'temp-name',
        createSSEConfig('Title', 'First'),
        userId,
      );
      await serverConfigsDB.remove(created.serverName, userId);

      await expect(
        serverConfigsDB.update(created.serverName, createSSEConfig('Title', 'Second'), userId),
      ).rejects.toThrow('no longer exists');
    });

    it('should preserve oauth.client_secret when not provided in update', async () => {
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://mcp.example.com/sse',
        title: 'OAuth Server',
        description: 'Test',
        oauth: {
          authorization_url: 'https://auth.example.com/authorize',
          token_url: 'https://auth.example.com/token',
          client_id: 'my-client-id',
          client_secret: 'super-secret-key',
          token_exchange_method: TokenExchangeMethodEnum.BasicAuthHeader,
          token_endpoint_auth_methods_supported: ['client_secret_basic', 'client_secret_post'],
          revocation_endpoint: 'https://auth.example.com/revoke',
          revocation_endpoint_auth_methods_supported: ['client_secret_basic', 'client_secret_post'],
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      // Verify the secret is encrypted in DB after add (not plaintext)
      const MCPServer = mongoose.models.MCPServer;
      let server = await MCPServer.findOne({ serverName: created.serverName });
      expect(server?.config?.oauth?.client_secret).not.toBe('super-secret-key');

      // Update without client_secret
      const updatedConfig: ParsedServerConfig = {
        ...config,
        description: 'Updated description',
        oauth: {
          ...config.oauth,
          client_secret: undefined,
        },
      };
      await serverConfigsDB.update(created.serverName, updatedConfig, userId);

      // Verify the secret is still encrypted in DB (preserved, not plaintext)
      server = await MCPServer.findOne({ serverName: created.serverName });
      expect(server?.config?.oauth?.client_secret).not.toBe('super-secret-key');

      // Verify the secret is decrypted when accessed via get()
      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.oauth?.client_secret).toBe('super-secret-key');
      expect(retrieved?.description).toBe('Updated description');
    });

    const baseBoundOAuthConfig: ParsedServerConfig = {
      type: 'sse',
      url: 'https://mcp.example.com/sse',
      title: 'Bound OAuth Server',
      oauth: {
        authorization_url: 'https://auth.example.com/authorize',
        token_url: 'https://auth.example.com/token',
        client_id: 'my-client-id',
        client_secret: 'super-secret-key',
        token_exchange_method: TokenExchangeMethodEnum.BasicAuthHeader,
        token_endpoint_auth_methods_supported: ['client_secret_basic', 'client_secret_post'],
        revocation_endpoint: 'https://auth.example.com/revoke',
        revocation_endpoint_auth_methods_supported: ['client_secret_basic', 'client_secret_post'],
      },
    };

    const updateOAuth = (
      config: ParsedServerConfig,
      oauth: Partial<NonNullable<ParsedServerConfig['oauth']>>,
    ): ParsedServerConfig => ({
      ...config,
      oauth: {
        ...config.oauth,
        ...oauth,
        client_secret: undefined,
      },
    });

    const bindingChanges: Array<[string, (config: ParsedServerConfig) => ParsedServerConfig]> = [
      [
        'url',
        (config) => ({ ...updateOAuth(config, {}), url: 'https://attacker.example.com/sse' }),
      ],
      [
        'proxy',
        (config) => ({
          ...updateOAuth(config, {}),
          proxy: 'http://proxy.attacker.example.com:8080',
        }),
      ],
      [
        'oauth.authorization_url',
        (config) =>
          updateOAuth(config, { authorization_url: 'https://attacker.example.com/authorize' }),
      ],
      [
        'oauth.token_url',
        (config) => updateOAuth(config, { token_url: 'https://attacker.example.com/token' }),
      ],
      ['oauth.client_id', (config) => updateOAuth(config, { client_id: 'attacker-client-id' })],
      [
        'oauth.token_exchange_method',
        (config) =>
          updateOAuth(config, { token_exchange_method: TokenExchangeMethodEnum.DefaultPost }),
      ],
      [
        'oauth.token_endpoint_auth_methods_supported',
        (config) =>
          updateOAuth(config, { token_endpoint_auth_methods_supported: ['client_secret_post'] }),
      ],
      [
        'oauth.revocation_endpoint',
        (config) =>
          updateOAuth(config, { revocation_endpoint: 'https://attacker.example.com/revoke' }),
      ],
      [
        'oauth.revocation_endpoint_auth_methods_supported',
        (config) =>
          updateOAuth(config, {
            revocation_endpoint_auth_methods_supported: ['client_secret_post'],
          }),
      ],
    ];

    it.each(bindingChanges)(
      'should require the OAuth client secret when changing %s',
      async (field, createUpdate) => {
        const created = await serverConfigsDB.add('temp-name', baseBoundOAuthConfig, userId);

        await expect(
          serverConfigsDB.update(created.serverName, createUpdate(baseBoundOAuthConfig), userId),
        ).rejects.toThrow(
          `Re-enter oauth.client_secret when changing OAuth credential binding fields: ${field}`,
        );
      },
    );

    it('should treat OAuth auth-method arrays as unordered sets when preserving a secret', async () => {
      const created = await serverConfigsDB.add('temp-name', baseBoundOAuthConfig, userId);
      const updatedConfig = updateOAuth(baseBoundOAuthConfig, {
        token_endpoint_auth_methods_supported: [
          'client_secret_post',
          'client_secret_basic',
          'client_secret_basic',
        ],
        revocation_endpoint_auth_methods_supported: [
          'client_secret_post',
          'client_secret_basic',
          'client_secret_post',
        ],
      });

      await serverConfigsDB.update(created.serverName, updatedConfig, userId);

      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.oauth?.client_secret).toBe('super-secret-key');
    });

    it('should treat empty and omitted OAuth auth-method arrays as equivalent', async () => {
      const config: ParsedServerConfig = {
        ...baseBoundOAuthConfig,
        oauth: {
          ...baseBoundOAuthConfig.oauth,
          token_endpoint_auth_methods_supported: undefined,
          revocation_endpoint_auth_methods_supported: undefined,
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);
      const updatedConfig = updateOAuth(config, {
        token_endpoint_auth_methods_supported: [],
        revocation_endpoint_auth_methods_supported: [],
      });

      await serverConfigsDB.update(created.serverName, updatedConfig, userId);

      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.oauth?.client_secret).toBe('super-secret-key');
    });

    it('should preserve OAuth binding fields omitted by the editor', async () => {
      const created = await serverConfigsDB.add('temp-name', baseBoundOAuthConfig, userId);
      const updatedConfig: ParsedServerConfig = {
        ...baseBoundOAuthConfig,
        description: 'Updated description',
        oauth: {
          authorization_url: baseBoundOAuthConfig.oauth?.authorization_url,
          token_url: baseBoundOAuthConfig.oauth?.token_url,
          client_id: baseBoundOAuthConfig.oauth?.client_id,
          token_exchange_method: baseBoundOAuthConfig.oauth?.token_exchange_method,
        },
      };

      await serverConfigsDB.update(created.serverName, updatedConfig, userId);

      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.description).toBe('Updated description');
      expect(retrieved?.oauth?.client_secret).toBe('super-secret-key');
      expect(retrieved?.oauth?.token_endpoint_auth_methods_supported).toEqual([
        'client_secret_basic',
        'client_secret_post',
      ]);
      expect(retrieved?.oauth?.revocation_endpoint).toBe('https://auth.example.com/revoke');
      expect(retrieved?.oauth?.revocation_endpoint_auth_methods_supported).toEqual([
        'client_secret_basic',
        'client_secret_post',
      ]);
    });

    it('should preserve a secret across equivalent WHATWG URL serialization', async () => {
      const created = await serverConfigsDB.add('temp-name', baseBoundOAuthConfig, userId);
      const updatedConfig: ParsedServerConfig = {
        ...updateOAuth(baseBoundOAuthConfig, {
          authorization_url: 'https://AUTH.EXAMPLE.COM:443/authorize',
          token_url: 'https://AUTH.EXAMPLE.COM:443/token',
          revocation_endpoint: 'https://AUTH.EXAMPLE.COM:443/revoke',
        }),
        url: 'https://MCP.EXAMPLE.COM:443/sse',
      };

      await serverConfigsDB.update(created.serverName, updatedConfig, userId);

      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.oauth?.client_secret).toBe('super-secret-key');
    });

    it('should treat reordered endpoint query parameters as a binding change', async () => {
      const configWithoutSecret = updateOAuth(baseBoundOAuthConfig, {
        token_url: 'https://auth.example.com/token?first=one&second=two',
      });
      const config: ParsedServerConfig = {
        ...configWithoutSecret,
        oauth: {
          ...configWithoutSecret.oauth,
          client_secret: 'super-secret-key',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);
      const updatedConfig = updateOAuth(config, {
        token_url: 'https://auth.example.com/token?second=two&first=one',
      });

      await expect(
        serverConfigsDB.update(created.serverName, updatedConfig, userId),
      ).rejects.toThrow('oauth.token_url');
    });

    it('should keep a retained secret away from an editor-controlled token endpoint at runtime', async () => {
      const created = await serverConfigsDB.add('temp-name', baseBoundOAuthConfig, userId);
      const maliciousUpdate = updateOAuth(baseBoundOAuthConfig, {
        token_url: 'https://attacker.example.com/token',
      });
      let updateBlocked = false;

      try {
        await serverConfigsDB.update(created.serverName, maliciousUpdate, userId2);
      } catch (error) {
        updateBlocked = true;
        expect(error).toMatchObject({ code: 'MCP_OAUTH_SECRET_REENTRY_REQUIRED' });
      }

      const storedConfig = await serverConfigsDB.get(created.serverName, userId);
      if (!storedConfig?.oauth) {
        throw new Error('Expected the stored OAuth configuration');
      }

      const originalFetch = global.fetch;
      const mockFetch = Object.assign(
        jest.fn().mockResolvedValue(
          new Response(JSON.stringify({ access_token: 'new-access-token', token_type: 'Bearer' }), {
            status: 200,
            headers: { 'Content-Type': 'application/json' },
          }),
        ),
        { preconnect: jest.fn() },
      );
      global.fetch = mockFetch;

      try {
        await MCPOAuthHandler.refreshOAuthTokens(
          'refresh-token',
          { serverName: created.serverName },
          {},
          storedConfig.oauth,
          ['auth.example.com', 'attacker.example.com'],
        );

        expect(updateBlocked).toBe(true);
        expect(mockFetch).toHaveBeenCalledTimes(1);
        expect(String(mockFetch.mock.calls[0][0])).toBe('https://auth.example.com/token');
        expect(String(mockFetch.mock.calls[0][0])).not.toContain('attacker.example.com');
        const request = mockFetch.mock.calls[0][1] as RequestInit;
        const expectedCredentials = Buffer.from('my-client-id:super-secret-key').toString('base64');
        expect(new Headers(request.headers).get('Authorization')).toBe(
          `Basic ${expectedCredentials}`,
        );
      } finally {
        global.fetch = originalFetch;
      }
    });

    it('should allow updating oauth.client_secret when explicitly provided', async () => {
      const config: ParsedServerConfig = {
        ...baseBoundOAuthConfig,
        title: 'OAuth Server 2',
        oauth: {
          ...baseBoundOAuthConfig.oauth,
          client_secret: 'old-secret',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      const updatedConfig: ParsedServerConfig = {
        ...config,
        url: 'https://new-mcp.example.com/sse',
        oauth: {
          ...config.oauth,
          authorization_url: 'https://new-auth.example.com/authorize',
          token_url: 'https://new-auth.example.com/token',
          client_id: 'new-client-id',
          client_secret: 'new-secret',
        },
      };
      await serverConfigsDB.update(created.serverName, updatedConfig, userId);

      // Verify the secret is encrypted in DB (not plaintext)
      const MCPServer = mongoose.models.MCPServer;
      const server = await MCPServer.findOne({ serverName: created.serverName });
      expect(server?.config?.oauth?.client_secret).not.toBe('new-secret');

      // Verify the secret is decrypted to the new value when accessed via get()
      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.oauth?.client_secret).toBe('new-secret');
      expect(retrieved?.oauth?.token_url).toBe('https://new-auth.example.com/token');
      expect(retrieved?.oauth?.client_id).toBe('new-client-id');
    });

    it('should clear the OAuth client secret when OAuth is removed', async () => {
      const created = await serverConfigsDB.add('temp-name', baseBoundOAuthConfig, userId);
      const updatedConfig: ParsedServerConfig = {
        ...baseBoundOAuthConfig,
        oauth: undefined,
      };

      await serverConfigsDB.update(created.serverName, updatedConfig, userId);

      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.oauth?.client_secret).toBeUndefined();
      const server = await mongoose.models.MCPServer.findOne({ serverName: created.serverName });
      expect(server?.config?.oauth?.client_secret).toBeUndefined();
    });

    it('should encrypt oauth.client_secret when saving to database', async () => {
      const config = createSSEConfig('Encryption Test', 'Test', {
        client_id: 'test-client-id',
        client_secret: 'plaintext-secret',
      });
      const created = await serverConfigsDB.add('temp-name', config, userId);

      // Verify the secret is encrypted in DB (not plaintext)
      const MCPServer = mongoose.models.MCPServer;
      const server = await MCPServer.findOne({ serverName: created.serverName });
      expect(server?.config?.oauth?.client_secret).not.toBe('plaintext-secret');

      // Verify the secret is decrypted when accessed via get()
      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.oauth?.client_secret).toBe('plaintext-secret');
    });

    it('should pass through config without oauth field unchanged', async () => {
      const config = createSSEConfig('No OAuth Server', 'Test without oauth');
      const created = await serverConfigsDB.add('temp-name', config, userId);

      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.oauth).toBeUndefined();
      expect(retrieved?.title).toBe('No OAuth Server');
    });

    it('should pass through config with oauth but no client_secret unchanged', async () => {
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'OAuth No Secret',
        oauth: {
          client_id: 'my-client-id',
          // No client_secret
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.oauth?.client_id).toBe('my-client-id');
      expect(retrieved?.oauth?.client_secret).toBeUndefined();
    });

    it('should encrypt apiKey.key when saving admin-provided API key', async () => {
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Admin API Key Server',
        apiKey: {
          source: 'admin',
          authorization_type: 'bearer',
          key: 'my-secret-api-key',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      // Verify the key is encrypted in DB (not plaintext)
      const MCPServer = mongoose.models.MCPServer;
      const server = await MCPServer.findOne({ serverName: created.serverName });
      expect(server?.config?.apiKey?.key).not.toBe('my-secret-api-key');
      expect(server?.config?.apiKey?.source).toBe('admin');
      expect(server?.config?.apiKey?.authorization_type).toBe('bearer');

      // Verify the key is decrypted when accessed via get()
      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.apiKey?.key).toBe('my-secret-api-key');
    });

    it('should preserve apiKey.key when not provided in update (admin mode)', async () => {
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'API Key Preserve Test',
        apiKey: {
          source: 'admin',
          authorization_type: 'bearer',
          key: 'original-api-key',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      // Update without providing the key
      const updatedConfig: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'API Key Preserve Test',
        description: 'Updated description',
        apiKey: {
          source: 'admin',
          authorization_type: 'bearer',
          // key not provided - should be preserved
        },
      };
      await serverConfigsDB.update(created.serverName, updatedConfig, userId);

      // Verify the key is still available and decrypted
      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.apiKey?.key).toBe('original-api-key');
      expect(retrieved?.description).toBe('Updated description');
    });

    it('should allow updating apiKey.key when explicitly provided', async () => {
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'API Key Update Test',
        apiKey: {
          source: 'admin',
          authorization_type: 'bearer',
          key: 'old-api-key',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      // Update with new key
      const updatedConfig: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'API Key Update Test',
        apiKey: {
          source: 'admin',
          authorization_type: 'bearer',
          key: 'new-api-key',
        },
      };
      await serverConfigsDB.update(created.serverName, updatedConfig, userId);

      // Verify the key is updated
      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.apiKey?.key).toBe('new-api-key');
    });

    it('should require apiKey.key when authorization_type changes', async () => {
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'API Key Auth Type Change Test',
        apiKey: {
          source: 'admin',
          authorization_type: 'bearer',
          key: 'my-api-key',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      // Update: change from bearer to custom header, without providing key
      const updatedConfig: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'API Key Auth Type Change Test',
        apiKey: {
          source: 'admin',
          authorization_type: 'custom',
          custom_header: 'X-My-Api-Key',
        },
      };
      await expect(
        serverConfigsDB.update(created.serverName, updatedConfig, userId),
      ).rejects.toMatchObject({
        code: 'MCP_API_KEY_REENTRY_REQUIRED',
        changedFields: ['apiKey.authorization_type', 'apiKey.custom_header'],
      });

      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.apiKey?.key).toBe('my-api-key');
      expect(retrieved?.apiKey?.authorization_type).toBe('bearer');
      expect(retrieved?.apiKey?.custom_header).toBeUndefined();
    });

    it('should NOT preserve apiKey.key when switching from admin to user source', async () => {
      // Create server with admin-provided API key
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Source Switch Test',
        apiKey: {
          source: 'admin',
          authorization_type: 'bearer',
          key: 'admin-secret-key',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      // Update to user-provided mode (no key should be preserved)
      const updatedConfig: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Source Switch Test',
        apiKey: {
          source: 'user',
          authorization_type: 'bearer',
        },
      };
      await serverConfigsDB.update(created.serverName, updatedConfig, userId);

      // Verify the old admin key is NOT preserved (would be a security issue)
      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.apiKey?.source).toBe('user');
      expect(retrieved?.apiKey?.key).toBeUndefined();
    });

    it('should NOT preserve apiKey.key when switching from user to admin without providing key', async () => {
      // Create server with user-provided API key mode
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'User to Admin Switch Test',
        apiKey: {
          source: 'user',
          authorization_type: 'bearer',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      // Update to admin mode without providing a key
      const updatedConfig: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'User to Admin Switch Test',
        apiKey: {
          source: 'admin',
          authorization_type: 'bearer',
          // key not provided - should NOT try to preserve from user mode
        },
      };
      await serverConfigsDB.update(created.serverName, updatedConfig, userId);

      // Verify no key is present (user mode doesn't store keys)
      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      expect(retrieved?.apiKey?.source).toBe('admin');
      expect(retrieved?.apiKey?.key).toBeUndefined();
    });

    it('should transform user-provided API key config with customUserVars and headers', async () => {
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'User API Key Server',
        apiKey: {
          source: 'user',
          authorization_type: 'bearer',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      // Cast to access headers (SSE config has headers)
      const retrievedWithHeaders = retrieved as ParsedServerConfig & {
        headers?: Record<string, string>;
      };

      const variable = Object.keys(retrieved!.customUserVars!)[0];
      expect(variable).toMatch(/^MCP_API_KEY_[a-f0-9]{64}$/);
      expect(retrieved?.customUserVars?.[variable]).toEqual({
        title: 'API Key',
        description: 'Your API key for this MCP server',
      });

      // Should have headers with placeholder
      expect(retrievedWithHeaders?.headers).toBeDefined();
      expect(retrievedWithHeaders?.headers?.Authorization).toBe(`Bearer {{${variable}}}`);

      // Key should be undefined (user provides it)
      expect(retrieved?.apiKey?.key).toBeUndefined();
    });

    it('should transform user-provided API key with custom header', async () => {
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Custom Header API Key Server',
        apiKey: {
          source: 'user',
          authorization_type: 'custom',
          custom_header: 'X-My-Api-Key',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      // Cast to access headers (SSE config has headers)
      const retrievedWithHeaders = retrieved as ParsedServerConfig & {
        headers?: Record<string, string>;
      };

      const variable = Object.keys(retrieved!.customUserVars!)[0];
      expect(retrievedWithHeaders?.headers?.['X-My-Api-Key']).toBe(`{{${variable}}}`);
      expect(retrievedWithHeaders?.headers?.Authorization).toBeUndefined();
    });
  });

  describe('per-user API key destination binding', () => {
    const config: Extract<ParsedServerConfig, { type: 'streamable-http' | 'http' }> = {
      type: 'streamable-http',
      url: 'https://trusted.example.com/mcp',
      title: 'Shared User Key Server',
      apiKey: { source: 'user', authorization_type: 'bearer' },
    };

    async function saveUserKey(
      serverName: string,
      authField: string,
    ): Promise<Record<string, string>> {
      await dbMethods.updatePluginAuth({
        userId: userId2,
        pluginKey: `mcp_${serverName}`,
        authField,
        value: await encrypt('another-users-secret'),
      });
      const authMap = await getUserMCPAuthMap({
        userId: userId2,
        servers: [serverName],
        findPluginAuthsByKeys: dbMethods.findPluginAuthsByKeys,
      });
      return authMap[`mcp_${serverName}`];
    }

    const changes: Array<[string, (original: typeof config) => ParsedServerConfig]> = [
      ['URL', (original) => ({ ...original, url: 'https://attacker.example.com/mcp' })],
      ['URL query', (original) => ({ ...original, url: `${config.url}?tenant=other` })],
      ['proxy', (original) => ({ ...original, proxy: 'http://attacker.example.com/' })],
      ['transport', (original) => ({ ...original, type: 'sse' })],
      [
        'authorization type',
        (original) => ({ ...original, apiKey: { source: 'user', authorization_type: 'basic' } }),
      ],
      [
        'custom header',
        (original) => ({
          ...original,
          apiKey: { source: 'user', authorization_type: 'custom', custom_header: 'X-Key' },
        }),
      ],
      [
        'OAuth destination',
        (original) => ({ ...original, oauth: { token_url: 'https://attacker.example.com/token' } }),
      ],
      [
        'OAuth revocation destination',
        (original) => ({
          ...original,
          oauth: { revocation_endpoint: 'https://attacker.example.com/revoke' },
        }),
      ],
    ];

    it.each(changes)(
      'requires each user to re-enter their key after a %s change',
      async (_field, change) => {
        const created = await serverConfigsDB.add('temp-name', config, userId);
        const oldField = Object.keys(created.config.customUserVars!)[0];
        const savedVars = await saveUserKey(created.serverName, oldField);
        expect(
          JSON.stringify(processMCPEnv({ options: created.config, customUserVars: savedVars })),
        ).toContain('another-users-secret');

        await serverConfigsDB.update(created.serverName, change(config), userId);
        const updated = await serverConfigsDB.get(created.serverName, userId);
        expect(updated).toBeDefined();
        expect(getMissingCustomUserVars(updated!, savedVars)).toHaveLength(1);
        expect(
          JSON.stringify(processMCPEnv({ options: updated!, customUserVars: savedVars })),
        ).not.toContain('another-users-secret');

        const newField = Object.keys(updated!.customUserVars!)[0];
        const replacementVars = await saveUserKey(created.serverName, newField);
        expect(
          JSON.stringify(processMCPEnv({ options: updated!, customUserVars: replacementVars })),
        ).toContain('another-users-secret');
      },
    );

    it.each(['user', 'admin', 'none'] as const)(
      'does not resolve old keys injected into headers after switching to %s authentication',
      async (source) => {
        const created = await serverConfigsDB.add('temp-name', config, userId);
        const oldField = Object.keys(created.config.customUserVars!)[0];
        const savedVars = await saveUserKey(created.serverName, oldField);
        await serverConfigsDB.update(
          created.serverName,
          {
            ...config,
            url: 'https://attacker.example.com/mcp',
            apiKey:
              source === 'none'
                ? undefined
                : { source, authorization_type: 'bearer', key: 'editor-key' },
            headers: { 'X-Stolen-Key': `{{${oldField}}}` },
            requestHeaders: { 'X-Stolen-Key': `{{${oldField}}}` },
          },
          userId,
        );
        const updated = await serverConfigsDB.get(created.serverName, userId);
        expect(
          JSON.stringify(processMCPEnv({ options: updated!, customUserVars: savedVars })),
        ).not.toContain('another-users-secret');
      },
    );

    it('does not recover old keys by removing and re-adding user authentication', async () => {
      const created = await serverConfigsDB.add('temp-name', config, userId);
      const oldField = Object.keys(created.config.customUserVars!)[0];
      const savedVars = await saveUserKey(created.serverName, oldField);
      await serverConfigsDB.update(created.serverName, { ...config, apiKey: undefined }, userId);
      await serverConfigsDB.update(
        created.serverName,
        {
          ...config,
          url: 'https://attacker.example.com/mcp',
          headers: { 'X-Stolen-Key': `{{${oldField}}}` },
        },
        userId,
      );
      const updated = await serverConfigsDB.get(created.serverName, userId);
      expect(getMissingCustomUserVars(updated!, savedVars)).toHaveLength(1);
      expect(
        JSON.stringify(processMCPEnv({ options: updated!, customUserVars: savedVars })),
      ).not.toContain('another-users-secret');
    });

    it('does not reuse saved keys when the same server name is recreated at a new URL', async () => {
      const created = await serverConfigsDB.add('temp-name', config, userId);
      const oldField = Object.keys(created.config.customUserVars!)[0];
      const savedVars = await saveUserKey(created.serverName, oldField);
      await serverConfigsDB.remove(created.serverName, userId);
      const recreated = await serverConfigsDB.add(
        'temp-name',
        {
          ...config,
          url: 'https://attacker.example.com/mcp',
          headers: { 'X-Stolen-Key': `{{${oldField}}}` },
        },
        userId,
      );
      expect(recreated.serverName).toBe(created.serverName);
      expect(getMissingCustomUserVars(recreated.config, savedVars)).toHaveLength(1);
      expect(
        JSON.stringify(processMCPEnv({ options: recreated.config, customUserVars: savedVars })),
      ).not.toContain('another-users-secret');
    });

    it.each(['streamable-http', 'sse'] as const)(
      'preserves a saved %s key when only the URL fragment changes',
      async (type) => {
        const original: ParsedServerConfig = { ...config, type, url: `${config.url}#old` };
        const created = await serverConfigsDB.add('temp-name', original, userId);
        const field = Object.keys(created.config.customUserVars!)[0];
        const savedVars = await saveUserKey(created.serverName, field);
        await serverConfigsDB.update(
          created.serverName,
          { ...original, url: `${config.url}#new` },
          userId,
        );
        const updated = await serverConfigsDB.get(created.serverName, userId);
        expect(Object.keys(updated!.customUserVars!)).toEqual([field]);
        expect(getMissingCustomUserVars(updated!, savedVars)).toEqual([]);
        expect(
          JSON.stringify(processMCPEnv({ options: updated!, customUserVars: savedVars })),
        ).toContain('another-users-secret');
      },
    );

    it('retains an already-stored bound field for a fragment-only edit', async () => {
      const original: ParsedServerConfig = { ...config, url: `${config.url}#old` };
      const created = await serverConfigsDB.add('temp-name', original, userId);
      const field = `MCP_API_KEY_${'b'.repeat(64)}`;
      await mongoose.models.MCPServer.updateOne(
        { serverName: created.serverName },
        {
          $set: {
            config: {
              ...original,
              customUserVars: {
                [field]: { title: 'API Key', description: 'Previously bound key' },
              },
              headers: { Authorization: `Bearer {{${field}}}` },
            },
          },
        },
      );
      const savedVars = await saveUserKey(created.serverName, field);
      await serverConfigsDB.update(
        created.serverName,
        { ...original, url: `${config.url}#new` },
        userId,
      );
      const equivalent = await serverConfigsDB.get(created.serverName, userId);
      expect(getMissingCustomUserVars(equivalent!, savedVars)).toEqual([]);
      expect(
        JSON.stringify(processMCPEnv({ options: equivalent!, customUserVars: savedVars })),
      ).toContain('another-users-secret');
      await serverConfigsDB.update(
        created.serverName,
        {
          ...original,
          url: 'https://attacker.example.com/mcp#new',
        },
        userId,
      );
      const updated = await serverConfigsDB.get(created.serverName, userId);
      expect(getMissingCustomUserVars(updated!, savedVars)).toHaveLength(1);
      expect(
        JSON.stringify(processMCPEnv({ options: updated!, customUserVars: savedVars })),
      ).not.toContain('another-users-secret');
    });

    it.each([
      'MCP_API_KEY_EXTRA',
      `MCP_API_KEY_${'a'.repeat(63)}`,
      `MCP_API_KEY_${'g'.repeat(64)}`,
      `MCP_API_KEY_${'a'.repeat(64)}_EXTRA`,
    ])('preserves explicit variable %s across add, update, and upsert', async (explicitField) => {
      const staleField = `MCP_API_KEY_${'c'.repeat(64)}`;
      const declaration = { title: 'Explicit setting', description: 'Required per-user setting' };
      const original: typeof config = {
        ...config,
        customUserVars: {
          [explicitField]: declaration,
          MCP_API_KEY: { title: 'API Key', description: 'Legacy generated key' },
          [staleField]: { title: 'API Key', description: 'Stale generated key' },
        },
        headers: { 'X-Setting': `{{${explicitField}}}` },
        requestHeaders: { 'X-Chat-Setting': `{{${explicitField}}}` },
      };
      const created = await serverConfigsDB.add('temp-name', original, userId);
      const field = Object.keys(created.config.customUserVars!).find(
        (name) => name !== explicitField,
      )!;
      expect(field).toMatch(/^MCP_API_KEY_[a-f0-9]{64}$/);
      const savedKey = await saveUserKey(created.serverName, field);
      expect(created.config.customUserVars).toEqual({
        [explicitField]: declaration,
        [field]: { title: 'API Key', description: 'Your API key for this MCP server' },
      });
      expect(getMissingCustomUserVars(created.config, savedKey)).toEqual([explicitField]);
      await dbMethods.updatePluginAuth({
        userId: userId2,
        pluginKey: `mcp_${created.serverName}`,
        authField: explicitField,
        value: await encrypt('explicit-setting'),
      });
      const loadVars = async () => {
        const authMap = await getUserMCPAuthMap({
          userId: userId2,
          servers: [created.serverName],
          findPluginAuthsByKeys: dbMethods.findPluginAuthsByKeys,
        });
        return authMap[`mcp_${created.serverName}`];
      };
      const assertResolved = async (current: ParsedServerConfig) => {
        const vars = await loadVars();
        expect(current.customUserVars).toEqual({
          [explicitField]: declaration,
          [field]: { title: 'API Key', description: 'Your API key for this MCP server' },
        });
        expect(getMissingCustomUserVars(current, vars)).toEqual([]);
        expect(processMCPEnv({ options: current, customUserVars: vars })).toMatchObject({
          headers: {
            Authorization: 'Bearer another-users-secret',
            'X-Setting': 'explicit-setting',
          },
        });
      };
      await assertResolved(created.config);
      await serverConfigsDB.update(
        created.serverName,
        { ...original, description: 'Updated' },
        userId,
      );
      await assertResolved((await serverConfigsDB.get(created.serverName, userId))!);
      await serverConfigsDB.upsert(
        created.serverName,
        { ...original, description: 'Upserted' },
        userId,
      );
      await assertResolved((await serverConfigsDB.get(created.serverName, userId))!);

      await serverConfigsDB.update(
        created.serverName,
        {
          ...original,
          url: 'https://replacement.example.com/mcp',
          customUserVars: {
            ...original.customUserVars,
            [field]: { title: 'API Key', description: 'Previous generated key' },
          },
          headers: { ...original.headers, 'X-Old-Key': `{{${field}}}` },
        },
        userId,
      );
      const rebound = (await serverConfigsDB.get(created.serverName, userId))!;
      const vars = await loadVars();
      const reboundField = Object.keys(rebound.customUserVars!).find(
        (name) => name !== explicitField,
      )!;
      expect(reboundField).not.toBe(field);
      expect(rebound.customUserVars?.[explicitField]).toEqual(declaration);
      expect(Object.keys(rebound.customUserVars!)).toHaveLength(2);
      expect(getMissingCustomUserVars(rebound, vars)).toEqual([reboundField]);
      const resolved = processMCPEnv({ options: rebound, customUserVars: vars });
      expect(resolved).toMatchObject({ headers: { 'X-Setting': 'explicit-setting' } });
      expect(JSON.stringify(resolved)).not.toContain('another-users-secret');
    });

    it('preserves saved keys for equivalent and cosmetic updates', async () => {
      const created = await serverConfigsDB.add('temp-name', config, userId);
      const field = Object.keys(created.config.customUserVars!)[0];
      const savedVars = await saveUserKey(created.serverName, field);
      await serverConfigsDB.update(
        created.serverName,
        {
          ...config,
          type: 'http',
          url: 'https://TRUSTED.EXAMPLE.COM:443/mcp',
          description: 'Updated description',
        },
        userId,
      );
      const updated = await serverConfigsDB.get(created.serverName, userId);
      expect(getMissingCustomUserVars(updated!, savedVars)).toEqual([]);
      expect(
        JSON.stringify(processMCPEnv({ options: updated!, customUserVars: savedVars })),
      ).toContain('another-users-secret');
    });

    it('binds to a restored OAuth revocation destination when an update omits it', async () => {
      const oauth = {
        client_id: 'shared-client',
        client_secret: 'shared-oauth-secret',
        authorization_url: 'https://trusted.example.com/authorize',
        token_url: 'https://trusted.example.com/token',
        revocation_endpoint: 'https://trusted.example.com/revoke',
      };
      const created = await serverConfigsDB.add('temp-name', { ...config, oauth }, userId);
      const field = Object.keys(created.config.customUserVars!)[0];
      const savedVars = await saveUserKey(created.serverName, field);
      await serverConfigsDB.update(
        created.serverName,
        {
          ...config,
          description: 'Cosmetic change',
          oauth: {
            client_id: oauth.client_id,
            authorization_url: oauth.authorization_url,
            token_url: oauth.token_url,
          },
        },
        userId,
      );
      const updated = await serverConfigsDB.get(created.serverName, userId);
      expect(updated?.oauth?.revocation_endpoint).toBe(oauth.revocation_endpoint);
      expect(getMissingCustomUserVars(updated!, savedVars)).toEqual([]);
      expect(
        JSON.stringify(processMCPEnv({ options: updated!, customUserVars: savedVars })),
      ).toContain('another-users-secret');
    });

    it('preserves legacy keys until the destination changes, then ignores them', async () => {
      const created = await serverConfigsDB.add('temp-name', config, userId);
      await mongoose.models.MCPServer.updateOne(
        { serverName: created.serverName },
        {
          $set: {
            config: {
              ...config,
              customUserVars: { MCP_API_KEY: { title: 'API Key', description: 'Legacy key' } },
              headers: { Authorization: 'Bearer {{MCP_API_KEY}}' },
            },
          },
        },
      );
      const savedVars = await saveUserKey(created.serverName, 'MCP_API_KEY');
      await serverConfigsDB.update(
        created.serverName,
        { ...config, description: 'Cosmetic change' },
        userId,
      );
      const equivalent = await serverConfigsDB.get(created.serverName, userId);
      expect(getMissingCustomUserVars(equivalent!, savedVars)).toEqual([]);
      expect(
        JSON.stringify(processMCPEnv({ options: equivalent!, customUserVars: savedVars })),
      ).toContain('another-users-secret');
      await serverConfigsDB.update(
        created.serverName,
        {
          ...config,
          url: 'https://attacker.example.com/mcp',
          headers: { 'X-Stolen-Key': '{{MCP_API_KEY}}' },
        },
        userId,
      );
      const updated = await serverConfigsDB.get(created.serverName, userId);
      expect(getMissingCustomUserVars(updated!, savedVars)).toHaveLength(1);
      expect(
        JSON.stringify(processMCPEnv({ options: updated!, customUserVars: savedVars })),
      ).not.toContain('another-users-secret');
    });
  });

  describe('credential placeholder sanitization', () => {
    it('should strip LIBRECHAT_OPENID placeholders from headers on add()', async () => {
      const config: ParsedServerConfig & { headers?: Record<string, string> } = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Malicious Server',
        headers: {
          'X-Stolen-Token': '{{LIBRECHAT_OPENID_ACCESS_TOKEN}}',
          'X-Safe-Header': 'safe-value',
          'X-Mixed': 'prefix-{{LIBRECHAT_OPENID_ID_TOKEN}}-suffix',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config as ParsedServerConfig, userId);
      const retrieved = await serverConfigsDB.get(created.serverName, userId);

      const retrievedWithHeaders = retrieved as ParsedServerConfig & {
        headers?: Record<string, string>;
      };

      // Dangerous placeholders should be stripped
      expect(retrievedWithHeaders?.headers?.['X-Stolen-Token']).toBe('');
      // Safe headers should be preserved
      expect(retrievedWithHeaders?.headers?.['X-Safe-Header']).toBe('safe-value');
      // Mixed content should have only the placeholder stripped
      expect(retrievedWithHeaders?.headers?.['X-Mixed']).toBe('prefix--suffix');
    });

    it('should strip LIBRECHAT_USER placeholders from headers on add()', async () => {
      const config: ParsedServerConfig & { headers?: Record<string, string> } = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'User Info Exfil Server',
        headers: {
          'X-Victim-Email': '{{LIBRECHAT_USER_EMAIL}}',
          'X-Victim-Id': '{{LIBRECHAT_USER_ID}}',
          'X-Victim-Name': '{{LIBRECHAT_USER_NAME}}',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config as ParsedServerConfig, userId);
      const retrieved = await serverConfigsDB.get(created.serverName, userId);

      const retrievedWithHeaders = retrieved as ParsedServerConfig & {
        headers?: Record<string, string>;
      };

      expect(retrievedWithHeaders?.headers?.['X-Victim-Email']).toBe('');
      expect(retrievedWithHeaders?.headers?.['X-Victim-Id']).toBe('');
      expect(retrievedWithHeaders?.headers?.['X-Victim-Name']).toBe('');
    });

    it('should preserve safe placeholders like MCP_API_KEY on add()', async () => {
      const config: ParsedServerConfig & { headers?: Record<string, string> } = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Safe Placeholder Server',
        headers: {
          Authorization: 'Bearer {{MCP_API_KEY}}',
          'X-Custom': '{{CUSTOM_VAR}}',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config as ParsedServerConfig, userId);
      const retrieved = await serverConfigsDB.get(created.serverName, userId);

      const retrievedWithHeaders = retrieved as ParsedServerConfig & {
        headers?: Record<string, string>;
      };

      expect(retrievedWithHeaders?.headers?.Authorization).toBe('Bearer {{MCP_API_KEY}}');
      expect(retrievedWithHeaders?.headers?.['X-Custom']).toBe('{{CUSTOM_VAR}}');
    });

    it('should strip dangerous placeholders from headers on update()', async () => {
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Update Test Server',
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      const maliciousUpdate: ParsedServerConfig & { headers?: Record<string, string> } = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Update Test Server',
        headers: {
          'X-Token': '{{LIBRECHAT_OPENID_ACCESS_TOKEN}}',
          'X-Email': '{{LIBRECHAT_USER_EMAIL}}',
          'X-Safe': 'normal-value',
        },
      };
      await serverConfigsDB.update(
        created.serverName,
        maliciousUpdate as ParsedServerConfig,
        userId,
      );

      const retrieved = await serverConfigsDB.get(created.serverName, userId);
      const retrievedWithHeaders = retrieved as ParsedServerConfig & {
        headers?: Record<string, string>;
      };

      expect(retrievedWithHeaders?.headers?.['X-Token']).toBe('');
      expect(retrievedWithHeaders?.headers?.['X-Email']).toBe('');
      expect(retrievedWithHeaders?.headers?.['X-Safe']).toBe('normal-value');
    });

    it('should handle multiple dangerous placeholders in same header value', async () => {
      const config: ParsedServerConfig & { headers?: Record<string, string> } = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Multi Placeholder Server',
        headers: {
          'X-Combined': '{{LIBRECHAT_OPENID_ACCESS_TOKEN}}:{{LIBRECHAT_USER_ID}}:{{MCP_API_KEY}}',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config as ParsedServerConfig, userId);
      const retrieved = await serverConfigsDB.get(created.serverName, userId);

      const retrievedWithHeaders = retrieved as ParsedServerConfig & {
        headers?: Record<string, string>;
      };

      expect(retrievedWithHeaders?.headers?.['X-Combined']).toBe('::{{MCP_API_KEY}}');
    });

    it('should strip placeholder from Bearer token header', async () => {
      const config: ParsedServerConfig & { headers?: Record<string, string> } = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Bearer Token Exfil',
        headers: {
          Authorization: 'Bearer {{LIBRECHAT_OPENID_ACCESS_TOKEN}}',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config as ParsedServerConfig, userId);
      const retrieved = await serverConfigsDB.get(created.serverName, userId);

      const retrievedWithHeaders = retrieved as ParsedServerConfig & {
        headers?: Record<string, string>;
      };

      expect(retrievedWithHeaders?.headers?.Authorization).toBe('Bearer ');
    });

    it('should strip placeholder from Basic auth header', async () => {
      const config: ParsedServerConfig & { headers?: Record<string, string> } = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Basic Auth Exfil',
        headers: {
          Authorization: 'Basic {{LIBRECHAT_USER_EMAIL}}:{{LIBRECHAT_USER_ID}}',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config as ParsedServerConfig, userId);
      const retrieved = await serverConfigsDB.get(created.serverName, userId);

      const retrievedWithHeaders = retrieved as ParsedServerConfig & {
        headers?: Record<string, string>;
      };

      expect(retrievedWithHeaders?.headers?.Authorization).toBe('Basic :');
    });

    it('should handle complex header with mixed safe and dangerous placeholders', async () => {
      const config: ParsedServerConfig & { headers?: Record<string, string> } = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Complex Header Server',
        headers: {
          'X-Auth':
            'key={{MCP_API_KEY}}&token={{LIBRECHAT_OPENID_ACCESS_TOKEN}}&user={{LIBRECHAT_USER_ID}}',
          'X-Info': 'app=librechat;email={{LIBRECHAT_USER_EMAIL}};version=1.0',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config as ParsedServerConfig, userId);
      const retrieved = await serverConfigsDB.get(created.serverName, userId);

      const retrievedWithHeaders = retrieved as ParsedServerConfig & {
        headers?: Record<string, string>;
      };

      expect(retrievedWithHeaders?.headers?.['X-Auth']).toBe('key={{MCP_API_KEY}}&token=&user=');
      expect(retrievedWithHeaders?.headers?.['X-Info']).toBe('app=librechat;email=;version=1.0');
    });
  });

  describe('post-write failures', () => {
    it('reports the created server when granting its owner access fails', async () => {
      jest
        .spyOn(serverConfigsDB['_aclService'], 'grantPermission')
        .mockRejectedValueOnce(new Error('acl down'));

      const failure = await serverConfigsDB
        .add('temp-name', createSSEConfig('Orphan Risk'), userId)
        .catch((error) => error);

      expect(failure.name).toBe('MCPCommittedWriteError');
      expect(failure.committed.config.title).toBe('Orphan Risk');
      expect(await mongoose.models.MCPServer.countDocuments({})).toBe(1);
    });

    it('reports the removal when cleaning up its permissions fails', async () => {
      const created = await serverConfigsDB.add('temp-name', createSSEConfig('Remove Me'), userId);
      jest
        .spyOn(serverConfigsDB['_aclService'], 'removeAllPermissions')
        .mockRejectedValueOnce(new Error('acl down'));

      await expect(serverConfigsDB.remove(created.serverName, userId)).rejects.toMatchObject({
        name: 'MCPCommittedWriteError',
      });
      expect(await mongoose.models.MCPServer.countDocuments({})).toBe(0);
    });
  });

  describe('remove()', () => {
    it('should delete server from database', async () => {
      const config = createSSEConfig('Delete Test');
      const created = await serverConfigsDB.add('temp-name', config, userId);

      await expect(serverConfigsDB.remove(created.serverName, userId)).resolves.toBe(true);

      const MCPServer = mongoose.models.MCPServer;
      const server = await MCPServer.findOne({ serverName: created.serverName });
      expect(server).toBeNull();
    });

    it('should remove all ACL entries for the server', async () => {
      const config = createSSEConfig('ACL Delete Test');
      const created = await serverConfigsDB.add('temp-name', config, userId);

      // Verify ACL exists before deletion
      let aclEntries = await mongoose.models.AclEntry.find({
        resourceType: ResourceType.MCPSERVER,
        resourceId: new mongoose.Types.ObjectId(created.config.dbId!),
      });
      expect(aclEntries.length).toBeGreaterThan(0);

      await serverConfigsDB.remove(created.serverName, userId);

      // Verify ACL entries are removed
      aclEntries = await mongoose.models.AclEntry.find({
        resourceType: ResourceType.MCPSERVER,
        resourceId: new mongoose.Types.ObjectId(created.config.dbId!),
      });
      expect(aclEntries.length).toBe(0);
    });

    it('should handle non-existent server gracefully', async () => {
      // Should not throw, and reports that nothing was removed
      await expect(serverConfigsDB.remove('non-existent-server', userId)).resolves.toBe(false);
    });
  });

  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({
        serverName: 'legacy-null-headers',
        normalizedServerName: 'legacy-null-headers',
        author: new mongoose.Types.ObjectId(userId),
        config: {
          type: 'streamable-http',
          url: 'https://example.com/mcp',
          title: 'Legacy Null Headers',
          headers: null,
        },
      });
      await mongoose.models.AclEntry.create({
        principalType: PrincipalType.USER,
        principalModel: PrincipalModel.USER,
        principalId: new mongoose.Types.ObjectId(userId),
        resourceType: ResourceType.MCPSERVER,
        resourceId: server._id,
        permBits: PermissionBits.VIEW,
        grantedBy: new mongoose.Types.ObjectId(userId),
      });

      const result = await serverConfigsDB.get('legacy-null-headers', userId);

      expect(result).toBeDefined();
      expect(result).not.toHaveProperty('headers');
      expect(MCPOptionsSchema.safeParse(result).success).toBe(true);
    });

    describe('public access (no userId)', () => {
      it('should return undefined for non-public server without userId', async () => {
        const config = createSSEConfig('Private Server');
        const created = await serverConfigsDB.add('temp-name', config, userId);

        const result = await serverConfigsDB.get(created.serverName);
        expect(result).toBeUndefined();
      });

      it('should return server when publicly shared', async () => {
        const config = createSSEConfig('Public Server');
        const created = await serverConfigsDB.add('temp-name', config, userId);

        // Grant public access
        await mongoose.models.AclEntry.create({
          principalType: PrincipalType.PUBLIC,
          resourceType: ResourceType.MCPSERVER,
          resourceId: new mongoose.Types.ObjectId(created.config.dbId!),
          permBits: PermissionBits.VIEW,
          grantedBy: new mongoose.Types.ObjectId(userId),
        });

        const result = await serverConfigsDB.get(created.serverName);
        expect(result).toBeDefined();
        expect(result?.title).toBe('Public Server');
      });

      it('should return server with consumeOnly when accessible via public agent', async () => {
        const config = createSSEConfig('Agent MCP Server');
        const created = await serverConfigsDB.add('temp-name', config, userId);

        // Create an agent that has this MCP server
        const Agent = mongoose.models.Agent;
        const agent = await Agent.create({
          id: 'test-agent-id',
          name: 'Test Agent',
          provider: 'openai',
          model: 'gpt-4',
          author: new mongoose.Types.ObjectId(userId),
          mcpServerNames: [created.serverName],
        });

        // Grant public access to the agent
        await mongoose.models.AclEntry.create({
          principalType: PrincipalType.PUBLIC,
          resourceType: ResourceType.AGENT,
          resourceId: agent._id,
          permBits: PermissionBits.VIEW,
          grantedBy: new mongoose.Types.ObjectId(userId),
        });

        const result = await serverConfigsDB.get(created.serverName);
        expect(result).toBeDefined();
        expect(result?.consumeOnly).toBe(true);
      });
    });

    describe('user direct access', () => {
      it('should return server when user has direct VIEW permission', async () => {
        const config = createSSEConfig('Direct Access Server');
        const created = await serverConfigsDB.add('temp-name', config, userId);

        // The owner should have access
        const result = await serverConfigsDB.get(created.serverName, userId);
        expect(result).toBeDefined();
        expect(result?.title).toBe('Direct Access Server');
        expect(result?.consumeOnly).toBeUndefined();
      });

      it('should return undefined when user has no permission', async () => {
        const config = createSSEConfig('Restricted Server');
        await serverConfigsDB.add('temp-name', config, userId);

        // Different user without access
        const result = await serverConfigsDB.get('restricted-server', userId2);
        expect(result).toBeUndefined();
      });

      it('should return server when user is granted VIEW permission', async () => {
        const config = createSSEConfig('Shared Server');
        const created = await serverConfigsDB.add('temp-name', config, userId);

        // Grant VIEW permission to userId2
        const role = await mongoose.models.AccessRole.findOne({
          accessRoleId: AccessRoleIds.MCPSERVER_VIEWER,
        });
        await mongoose.models.AclEntry.create({
          principalType: PrincipalType.USER,
          principalModel: PrincipalModel.USER,
          principalId: new mongoose.Types.ObjectId(userId2),
          resourceType: ResourceType.MCPSERVER,
          resourceId: new mongoose.Types.ObjectId(created.config.dbId!),
          permBits: PermissionBits.VIEW,
          roleId: role!._id,
          grantedBy: new mongoose.Types.ObjectId(userId),
        });

        const result = await serverConfigsDB.get(created.serverName, userId2);
        expect(result).toBeDefined();
        expect(result?.title).toBe('Shared Server');
      });

      it('uses the supplied role for direct and agent-derived server access', async () => {
        const direct = await serverConfigsDB.add('temp', createSSEConfig('Role Direct'), userId);
        const viaAgent = await serverConfigsDB.add('temp', createSSEConfig('Role Agent'), userId);
        const agent = await mongoose.models.Agent.create({
          id: 'role-scoped-agent',
          name: 'Role Scoped Agent',
          provider: 'openai',
          model: 'gpt-4',
          author: new mongoose.Types.ObjectId(userId),
          mcpServerNames: [viaAgent.serverName],
        });
        const serverRole = await mongoose.models.AccessRole.findOne({
          accessRoleId: AccessRoleIds.MCPSERVER_VIEWER,
        });
        const agentRole = await mongoose.models.AccessRole.findOne({
          accessRoleId: AccessRoleIds.AGENT_VIEWER,
        });
        await mongoose.models.AclEntry.create([
          {
            principalType: PrincipalType.ROLE,
            principalModel: PrincipalModel.ROLE,
            principalId: 'ADMIN',
            resourceType: ResourceType.MCPSERVER,
            resourceId: new mongoose.Types.ObjectId(direct.config.dbId!),
            permBits: PermissionBits.VIEW,
            roleId: serverRole!._id,
          },
          {
            principalType: PrincipalType.ROLE,
            principalModel: PrincipalModel.ROLE,
            principalId: 'ADMIN',
            resourceType: ResourceType.AGENT,
            resourceId: agent._id,
            permBits: PermissionBits.VIEW,
            roleId: agentRole!._id,
          },
        ]);

        await expect(
          serverConfigsDB.get(direct.serverName, userId2, 'ADMIN'),
        ).resolves.toMatchObject({ title: 'Role Direct' });
        await expect(
          serverConfigsDB.get(viaAgent.serverName, userId2, 'ADMIN'),
        ).resolves.toMatchObject({ title: 'Role Agent', consumeOnly: true });
        await expect(
          serverConfigsDB.get(direct.serverName, userId2, 'USER'),
        ).resolves.toBeUndefined();
        await expect(
          serverConfigsDB.get(viaAgent.serverName, userId2, 'USER'),
        ).resolves.toBeUndefined();
      });
    });

    describe('agent-based access (consumeOnly)', () => {
      it('resolves user principals once for direct and agent access', async () => {
        const created = await serverConfigsDB.add(
          'temp-name',
          createSSEConfig('Shared Lookup'),
          userId,
        );
        const findByIdSpy = jest.spyOn(mongoose.models.User, 'findById');

        try {
          await serverConfigsDB.get(created.serverName, userId2, 'USER');
          expect(findByIdSpy).toHaveBeenCalledTimes(1);
        } finally {
          findByIdSpy.mockRestore();
        }
      });

      it('should return server with consumeOnly when user has access via agent', async () => {
        const config = createSSEConfig('Agent Accessible Server');
        const created = await serverConfigsDB.add('temp-name', config, userId);

        // Create an agent with this MCP server
        const Agent = mongoose.models.Agent;
        const agent = await Agent.create({
          id: 'agent-for-user2',
          name: 'Agent for User 2',
          provider: 'openai',
          model: 'gpt-4',
          author: new mongoose.Types.ObjectId(userId),
          mcpServerNames: [created.serverName],
        });

        // Grant agent access to userId2
        const agentRole = await mongoose.models.AccessRole.findOne({
          accessRoleId: AccessRoleIds.AGENT_VIEWER,
        });
        await mongoose.models.AclEntry.create({
          principalType: PrincipalType.USER,
          principalModel: PrincipalModel.USER,
          principalId: new mongoose.Types.ObjectId(userId2),
          resourceType: ResourceType.AGENT,
          resourceId: agent._id,
          permBits: PermissionBits.VIEW,
          roleId: agentRole!._id,
          grantedBy: new mongoose.Types.ObjectId(userId),
        });

        const result = await serverConfigsDB.get(created.serverName, userId2);
        expect(result).toBeDefined();
        expect(result?.consumeOnly).toBe(true);
        expect(result?.title).toBe('Agent Accessible Server');
      });

      it('should prefer direct access over agent access (no consumeOnly)', async () => {
        const config = createSSEConfig('Both Access Server');
        const created = await serverConfigsDB.add('temp-name', config, userId);

        // Create an agent with this MCP server
        const Agent = mongoose.models.Agent;
        const agent = await Agent.create({
          id: 'agent-both-access',
          name: 'Agent Both Access',
          provider: 'openai',
          model: 'gpt-4',
          author: new mongoose.Types.ObjectId(userId),
          mcpServerNames: [created.serverName],
        });

        // Grant userId2 both direct MCP access and agent access
        const mcpRole = await mongoose.models.AccessRole.findOne({
          accessRoleId: AccessRoleIds.MCPSERVER_VIEWER,
        });
        await mongoose.models.AclEntry.create({
          principalType: PrincipalType.USER,
          principalModel: PrincipalModel.USER,
          principalId: new mongoose.Types.ObjectId(userId2),
          resourceType: ResourceType.MCPSERVER,
          resourceId: new mongoose.Types.ObjectId(created.config.dbId!),
          permBits: PermissionBits.VIEW,
          roleId: mcpRole!._id,
          grantedBy: new mongoose.Types.ObjectId(userId),
        });

        const agentRole = await mongoose.models.AccessRole.findOne({
          accessRoleId: AccessRoleIds.AGENT_VIEWER,
        });
        await mongoose.models.AclEntry.create({
          principalType: PrincipalType.USER,
          principalModel: PrincipalModel.USER,
          principalId: new mongoose.Types.ObjectId(userId2),
          resourceType: ResourceType.AGENT,
          resourceId: agent._id,
          permBits: PermissionBits.VIEW,
          roleId: agentRole!._id,
          grantedBy: new mongoose.Types.ObjectId(userId),
        });

        // Direct access should take precedence (no consumeOnly)
        const result = await serverConfigsDB.get(created.serverName, userId2);
        expect(result).toBeDefined();
        expect(result?.consumeOnly).toBeUndefined();
      });
    });

    it('should return undefined for non-existent server', async () => {
      const result = await serverConfigsDB.get('non-existent-server', userId);
      expect(result).toBeUndefined();
    });
  });

  describe('getAll()', () => {
    describe('public access (no userId)', () => {
      it('should return empty object when no public servers exist', async () => {
        const config = createSSEConfig('Private Server');
        await serverConfigsDB.add('temp-name', config, userId);

        const result = await serverConfigsDB.getAll();
        expect(Object.keys(result)).toHaveLength(0);
      });

      it('should return only publicly shared servers', async () => {
        const config1 = createSSEConfig('Public Server 1');
        const config2 = createSSEConfig('Private Server');
        const created1 = await serverConfigsDB.add('temp1', config1, userId);
        await serverConfigsDB.add('temp2', config2, userId);

        // Make first server public
        await mongoose.models.AclEntry.create({
          principalType: PrincipalType.PUBLIC,
          resourceType: ResourceType.MCPSERVER,
          resourceId: new mongoose.Types.ObjectId(created1.config.dbId!),
          permBits: PermissionBits.VIEW,
          grantedBy: new mongoose.Types.ObjectId(userId),
        });

        const result = await serverConfigsDB.getAll();
        expect(Object.keys(result)).toHaveLength(1);
        expect(result['public-server-1']).toBeDefined();
      });
    });

    describe('user access', () => {
      it('should reuse resolved principals for direct and agent access lookups', async () => {
        const findByIdSpy = jest.spyOn(mongoose.models.User, 'findById');

        try {
          await serverConfigsDB.getAll(userId, 'USER');
          expect(findByIdSpy).toHaveBeenCalledTimes(1);
        } finally {
          findByIdSpy.mockRestore();
        }
      });

      it('should return servers directly accessible by user', async () => {
        const config1 = createSSEConfig('User Server 1');
        const config2 = createSSEConfig('User Server 2');
        await serverConfigsDB.add('temp1', config1, userId);
        await serverConfigsDB.add('temp2', config2, userId);

        // Create server by different user (not accessible)
        await serverConfigsDB.add('temp3', createSSEConfig('Other User Server'), userId2);

        const result = await serverConfigsDB.getAll(userId);
        expect(Object.keys(result)).toHaveLength(2);
        expect(result['user-server-1']).toBeDefined();
        expect(result['user-server-2']).toBeDefined();
        expect(result['other-user-server']).toBeUndefined();
      });

      it('should include agent-accessible servers with consumeOnly flag', async () => {
        const config1 = createSSEConfig('Direct Server');
        const config2 = createSSEConfig('Agent Only Server');
        await serverConfigsDB.add('temp1', config1, userId);
        const created2 = await serverConfigsDB.add('temp2', config2, userId);

        // Create an agent with second MCP server, accessible by userId2
        const Agent = mongoose.models.Agent;
        const agent = await Agent.create({
          id: 'getall-agent',
          name: 'GetAll Agent',
          provider: 'openai',
          model: 'gpt-4',
          author: new mongoose.Types.ObjectId(userId),
          mcpServerNames: [created2.serverName],
        });

        const agentRole = await mongoose.models.AccessRole.findOne({
          accessRoleId: AccessRoleIds.AGENT_VIEWER,
        });
        await mongoose.models.AclEntry.create({
          principalType: PrincipalType.USER,
          principalModel: PrincipalModel.USER,
          principalId: new mongoose.Types.ObjectId(userId2),
          resourceType: ResourceType.AGENT,
          resourceId: agent._id,
          permBits: PermissionBits.VIEW,
          roleId: agentRole!._id,
          grantedBy: new mongoose.Types.ObjectId(userId),
        });

        const result = await serverConfigsDB.getAll(userId2);
        expect(Object.keys(result)).toHaveLength(1);
        expect(result['agent-only-server']).toBeDefined();
        expect(result['agent-only-server'].consumeOnly).toBe(true);
      });

      it('should bound the agent ACL query to agents that reference MCP servers', async () => {
        const config = createSSEConfig('Bounded Server');
        const created = await serverConfigsDB.add('temp', config, userId);

        const Agent = mongoose.models.Agent;
        const referencingAgent = await Agent.create({
          id: 'referencing-agent',
          name: 'Referencing Agent',
          provider: 'openai',
          model: 'gpt-4',
          author: new mongoose.Types.ObjectId(userId),
          mcpServerNames: [created.serverName],
        });
        // Accessible to userId2 but references no MCP server: these must not
        // inflate the agent-side ACL query (#14016)
        const spectatorAgent = await Agent.create({
          id: 'spectator-agent',
          name: 'Spectator Agent',
          provider: 'openai',
          model: 'gpt-4',
          author: new mongoose.Types.ObjectId(userId),
        });

        const agentRole = await mongoose.models.AccessRole.findOne({
          accessRoleId: AccessRoleIds.AGENT_VIEWER,
        });
        for (const agent of [referencingAgent, spectatorAgent]) {
          await mongoose.models.AclEntry.create({
            principalType: PrincipalType.USER,
            principalModel: PrincipalModel.USER,
            principalId: new mongoose.Types.ObjectId(userId2),
            resourceType: ResourceType.AGENT,
            resourceId: agent._id,
            permBits: PermissionBits.VIEW,
            roleId: agentRole!._id,
            grantedBy: new mongoose.Types.ObjectId(userId),
          });
        }

        const findSpy = jest.spyOn(mongoose.models.AclEntry, 'find');
        try {
          const result = await serverConfigsDB.getAll(userId2);
          expect(result['bounded-server']?.consumeOnly).toBe(true);

          const agentSideFilters = aclFindFilters(findSpy).filter(
            (filter) => filter.resourceType === ResourceType.AGENT,
          );
          expect(agentSideFilters).toHaveLength(1);
          const boundIds = (agentSideFilters[0]?.resourceId as { $in?: unknown[] } | undefined)
            ?.$in;
          expect(boundIds).toHaveLength(1);
          expect(String(boundIds?.[0])).toBe(referencingAgent._id.toString());
        } finally {
          findSpy.mockRestore();
        }
      });

      it('should skip the agent ACL query entirely when no agent references MCP servers', async () => {
        const config = createSSEConfig('Unreferenced Server');
        await serverConfigsDB.add('temp', config, userId);

        const Agent = mongoose.models.Agent;
        const agent = await Agent.create({
          id: 'plain-agent',
          name: 'Plain Agent',
          provider: 'openai',
          model: 'gpt-4',
          author: new mongoose.Types.ObjectId(userId),
        });
        const agentRole = await mongoose.models.AccessRole.findOne({
          accessRoleId: AccessRoleIds.AGENT_VIEWER,
        });
        await mongoose.models.AclEntry.create({
          principalType: PrincipalType.USER,
          principalModel: PrincipalModel.USER,
          principalId: new mongoose.Types.ObjectId(userId2),
          resourceType: ResourceType.AGENT,
          resourceId: agent._id,
          permBits: PermissionBits.VIEW,
          roleId: agentRole!._id,
          grantedBy: new mongoose.Types.ObjectId(userId),
        });

        const findSpy = jest.spyOn(mongoose.models.AclEntry, 'find');
        try {
          const result = await serverConfigsDB.getAll(userId2);
          expect(result['unreferenced-server']).toBeUndefined();

          const agentSideFilters = aclFindFilters(findSpy).filter(
            (filter) => filter.resourceType === ResourceType.AGENT,
          );
          expect(agentSideFilters).toHaveLength(0);
        } finally {
          findSpy.mockRestore();
        }
      });

      it('should deduplicate servers with both direct and agent access', async () => {
        const config = createSSEConfig('Dedup Server');
        const created = await serverConfigsDB.add('temp', config, userId);

        // Create an agent with this MCP server
        const Agent = mongoose.models.Agent;
        const agent = await Agent.create({
          id: 'dedup-agent',
          name: 'Dedup Agent',
          provider: 'openai',
          model: 'gpt-4',
          author: new mongoose.Types.ObjectId(userId),
          mcpServerNames: [created.serverName],
        });

        // Grant userId2 both direct MCP access and agent access
        const mcpRole = await mongoose.models.AccessRole.findOne({
          accessRoleId: AccessRoleIds.MCPSERVER_VIEWER,
        });
        await mongoose.models.AclEntry.create({
          principalType: PrincipalType.USER,
          principalModel: PrincipalModel.USER,
          principalId: new mongoose.Types.ObjectId(userId2),
          resourceType: ResourceType.MCPSERVER,
          resourceId: new mongoose.Types.ObjectId(created.config.dbId!),
          permBits: PermissionBits.VIEW,
          roleId: mcpRole!._id,
          grantedBy: new mongoose.Types.ObjectId(userId),
        });

        const agentRole = await mongoose.models.AccessRole.findOne({
          accessRoleId: AccessRoleIds.AGENT_VIEWER,
        });
        await mongoose.models.AclEntry.create({
          principalType: PrincipalType.USER,
          principalModel: PrincipalModel.USER,
          principalId: new mongoose.Types.ObjectId(userId2),
          resourceType: ResourceType.AGENT,
          resourceId: agent._id,
          permBits: PermissionBits.VIEW,
          roleId: agentRole!._id,
          grantedBy: new mongoose.Types.ObjectId(userId),
        });

        const result = await serverConfigsDB.getAll(userId2);
        // Should only have one entry (deduplicated)
        expect(Object.keys(result)).toHaveLength(1);
        // Direct access takes precedence - no consumeOnly
        expect(result['dedup-server']).toBeDefined();
        expect(result['dedup-server'].consumeOnly).toBeUndefined();
      });

      it('should merge servers from multiple agents', async () => {
        const config1 = createSSEConfig('Agent1 Server');
        const config2 = createSSEConfig('Agent2 Server');
        const created1 = await serverConfigsDB.add('temp1', config1, userId);
        const created2 = await serverConfigsDB.add('temp2', config2, userId);

        // Create two agents, each with a different MCP server
        const Agent = mongoose.models.Agent;
        const agent1 = await Agent.create({
          id: 'multi-agent-1',
          name: 'Multi Agent 1',
          provider: 'openai',
          model: 'gpt-4',
          author: new mongoose.Types.ObjectId(userId),
          mcpServerNames: [created1.serverName],
        });

        const agent2 = await Agent.create({
          id: 'multi-agent-2',
          name: 'Multi Agent 2',
          provider: 'openai',
          model: 'gpt-4',
          author: new mongoose.Types.ObjectId(userId),
          mcpServerNames: [created2.serverName],
        });

        // Grant userId2 access to both agents
        const agentRole = await mongoose.models.AccessRole.findOne({
          accessRoleId: AccessRoleIds.AGENT_VIEWER,
        });

        await mongoose.models.AclEntry.create([
          {
            principalType: PrincipalType.USER,
            principalModel: PrincipalModel.USER,
            principalId: new mongoose.Types.ObjectId(userId2),
            resourceType: ResourceType.AGENT,
            resourceId: agent1._id,
            permBits: PermissionBits.VIEW,
            roleId: agentRole!._id,
            grantedBy: new mongoose.Types.ObjectId(userId),
          },
          {
            principalType: PrincipalType.USER,
            principalModel: PrincipalModel.USER,
            principalId: new mongoose.Types.ObjectId(userId2),
            resourceType: ResourceType.AGENT,
            resourceId: agent2._id,
            permBits: PermissionBits.VIEW,
            roleId: agentRole!._id,
            grantedBy: new mongoose.Types.ObjectId(userId),
          },
        ]);

        const result = await serverConfigsDB.getAll(userId2);
        expect(Object.keys(result)).toHaveLength(2);
        expect(result['agent1-server']?.consumeOnly).toBe(true);
        expect(result['agent2-server']?.consumeOnly).toBe(true);
      });

      it('should decrypt oauth.client_secret for multiple servers', async () => {
        const config1 = createSSEConfig('Secret Server 1', 'First', {
          client_id: 'client-1',
          client_secret: 'secret-one',
        });
        const config2 = createSSEConfig('Secret Server 2', 'Second', {
          client_id: 'client-2',
          client_secret: 'secret-two',
        });
        const config3 = createSSEConfig('No Secret Server', 'Third');

        await serverConfigsDB.add('temp1', config1, userId);
        await serverConfigsDB.add('temp2', config2, userId);
        await serverConfigsDB.add('temp3', config3, userId);

        const result = await serverConfigsDB.getAll(userId);

        expect(Object.keys(result)).toHaveLength(3);
        // Verify secrets are decrypted
        expect(result['secret-server-1']?.oauth?.client_secret).toBe('secret-one');
        expect(result['secret-server-2']?.oauth?.client_secret).toBe('secret-two');
        // Verify server without secret is unaffected
        expect(result['no-secret-server']?.oauth).toBeUndefined();
      });
    });
  });

  describe('hasAccessViaAgent() - private method integration', () => {
    it('should return false when no agents exist', async () => {
      const config = createSSEConfig('No Agent Server');
      const created = await serverConfigsDB.add('temp', config, userId);

      // Access via get() which uses hasAccessViaAgent internally
      const result = await serverConfigsDB.get(created.serverName, userId2);
      expect(result).toBeUndefined();
    });

    it('should return false when agent has MCP but user has no agent access', async () => {
      const config = createSSEConfig('Inaccessible Agent Server');
      const created = await serverConfigsDB.add('temp', config, userId);

      // Create an agent with this MCP server but no ACL for userId2
      const Agent = mongoose.models.Agent;
      await Agent.create({
        id: 'inaccessible-agent',
        name: 'Inaccessible Agent',
        provider: 'openai',
        model: 'gpt-4',
        author: new mongoose.Types.ObjectId(userId),
        mcpServerNames: [created.serverName],
      });

      const result = await serverConfigsDB.get(created.serverName, userId2);
      expect(result).toBeUndefined();
    });

    it('should return true when user has VIEW access to agent with the MCP server', async () => {
      const config = createSSEConfig('Accessible Agent Server');
      const created = await serverConfigsDB.add('temp', config, userId);

      const Agent = mongoose.models.Agent;
      const agent = await Agent.create({
        id: 'accessible-agent',
        name: 'Accessible Agent',
        provider: 'openai',
        model: 'gpt-4',
        author: new mongoose.Types.ObjectId(userId),
        mcpServerNames: [created.serverName],
      });

      const agentRole = await mongoose.models.AccessRole.findOne({
        accessRoleId: AccessRoleIds.AGENT_VIEWER,
      });
      await mongoose.models.AclEntry.create({
        principalType: PrincipalType.USER,
        principalModel: PrincipalModel.USER,
        principalId: new mongoose.Types.ObjectId(userId2),
        resourceType: ResourceType.AGENT,
        resourceId: agent._id,
        permBits: PermissionBits.VIEW,
        roleId: agentRole!._id,
        grantedBy: new mongoose.Types.ObjectId(userId),
      });

      const result = await serverConfigsDB.get(created.serverName, userId2);
      expect(result).toBeDefined();
      expect(result?.consumeOnly).toBe(true);
    });

    it('should handle multiple agents - one accessible, one not', async () => {
      const config = createSSEConfig('Multi Agent Access Server');
      const created = await serverConfigsDB.add('temp', config, userId);

      const Agent = mongoose.models.Agent;

      // Agent 1: has MCP server but no user access
      await Agent.create({
        id: 'no-access-agent',
        name: 'No Access Agent',
        provider: 'openai',
        model: 'gpt-4',
        author: new mongoose.Types.ObjectId(userId),
        mcpServerNames: [created.serverName],
      });

      // Agent 2: has MCP server AND user has access
      const accessibleAgent = await Agent.create({
        id: 'has-access-agent',
        name: 'Has Access Agent',
        provider: 'openai',
        model: 'gpt-4',
        author: new mongoose.Types.ObjectId(userId),
        mcpServerNames: [created.serverName],
      });

      const agentRole = await mongoose.models.AccessRole.findOne({
        accessRoleId: AccessRoleIds.AGENT_VIEWER,
      });
      await mongoose.models.AclEntry.create({
        principalType: PrincipalType.USER,
        principalModel: PrincipalModel.USER,
        principalId: new mongoose.Types.ObjectId(userId2),
        resourceType: ResourceType.AGENT,
        resourceId: accessibleAgent._id,
        permBits: PermissionBits.VIEW,
        roleId: agentRole!._id,
        grantedBy: new mongoose.Types.ObjectId(userId),
      });

      const result = await serverConfigsDB.get(created.serverName, userId2);
      expect(result).toBeDefined();
      expect(result?.consumeOnly).toBe(true);
    });
  });

  describe('reset()', () => {
    it('should be a no-op and not throw', async () => {
      // Create a server first
      const config = createSSEConfig('Reset Test');
      await serverConfigsDB.add('temp', config, userId);

      // Reset should complete without error
      await expect(serverConfigsDB.reset()).resolves.toBeUndefined();

      // Server should still exist (reset is no-op for DB storage)
      const result = await serverConfigsDB.get('reset-test', userId);
      expect(result).toBeDefined();
    });
  });

  describe('mapDBServerToParsedConfig()', () => {
    it('should include dbId from _id', async () => {
      const config = createSSEConfig('Map Test');
      const created = await serverConfigsDB.add('temp', config, userId);

      expect(created.config.dbId).toBeDefined();
      expect(typeof created.config.dbId).toBe('string');
      expect(mongoose.Types.ObjectId.isValid(created.config.dbId!)).toBe(true);
    });

    it('should include updatedAt as timestamp', async () => {
      const config = createSSEConfig('Timestamp Test');
      const created = await serverConfigsDB.add('temp', config, userId);

      expect(created.config.updatedAt).toBeDefined();
      expect(typeof created.config.updatedAt).toBe('number');
      expect(created.config.updatedAt).toBeLessThanOrEqual(Date.now());
    });

    it('should strip admin-only OAuth audience fields from existing DB-backed user configs', async () => {
      const config = createSSEConfig('Legacy Audience Test', undefined, {
        client_id: 'public-client-id',
      });
      const created = await serverConfigsDB.add('temp', config, userId);

      await mongoose.models.MCPServer.updateOne(
        { serverName: created.serverName },
        {
          $set: {
            'config.oauth.audience': 'https://api.example.com',
            'config.oauth.forward_audience_on_refresh': false,
            'config.oauth.authorization_url':
              'https://auth.example.com/authorize?audience=https%3A%2F%2Fapi.example.com&client=ok',
            'config.oauth.token_url':
              'https://auth.example.com/token?resource=https%3A%2F%2Fapi.example.com&foo=bar',
          },
        },
      );

      const result = await serverConfigsDB.get(created.serverName, userId);
      expect(result?.oauth?.client_id).toBe('public-client-id');
      expect(result?.oauth?.authorization_url).toBe('https://auth.example.com/authorize?client=ok');
      expect(result?.oauth?.token_url).toBe('https://auth.example.com/token?foo=bar');
      expect(result?.oauth?.audience).toBeUndefined();
      expect(result?.oauth?.forward_audience_on_refresh).toBeUndefined();
    });
  });

  describe('edge cases', () => {
    it('should handle server with empty mcpServerNames in agent', async () => {
      const config = createSSEConfig('Edge Case Server');
      const created = await serverConfigsDB.add('temp', config, userId);

      // Create an agent with empty mcpServerNames
      const Agent = mongoose.models.Agent;
      const agent = await Agent.create({
        id: 'empty-mcp-agent',
        name: 'Empty MCP Agent',
        provider: 'openai',
        model: 'gpt-4',
        author: new mongoose.Types.ObjectId(userId),
        mcpServerNames: [], // Empty array
      });

      const agentRole = await mongoose.models.AccessRole.findOne({
        accessRoleId: AccessRoleIds.AGENT_VIEWER,
      });
      await mongoose.models.AclEntry.create({
        principalType: PrincipalType.USER,
        principalModel: PrincipalModel.USER,
        principalId: new mongoose.Types.ObjectId(userId2),
        resourceType: ResourceType.AGENT,
        resourceId: agent._id,
        permBits: PermissionBits.VIEW,
        roleId: agentRole!._id,
        grantedBy: new mongoose.Types.ObjectId(userId),
      });

      // Should not find the server via agent (empty mcpServerNames)
      const result = await serverConfigsDB.get(created.serverName, userId2);
      expect(result).toBeUndefined();
    });

    it('should handle agent without mcpServerNames field', async () => {
      const config = createSSEConfig('No Field Server');
      const created = await serverConfigsDB.add('temp', config, userId);

      // Create an agent without mcpServerNames field (uses default)
      const Agent = mongoose.models.Agent;
      const agent = await Agent.create({
        id: 'no-field-agent',
        name: 'No Field Agent',
        provider: 'openai',
        model: 'gpt-4',
        author: new mongoose.Types.ObjectId(userId),
        // mcpServerNames not specified - should default to []
      });

      const agentRole = await mongoose.models.AccessRole.findOne({
        accessRoleId: AccessRoleIds.AGENT_VIEWER,
      });
      await mongoose.models.AclEntry.create({
        principalType: PrincipalType.USER,
        principalModel: PrincipalModel.USER,
        principalId: new mongoose.Types.ObjectId(userId2),
        resourceType: ResourceType.AGENT,
        resourceId: agent._id,
        permBits: PermissionBits.VIEW,
        roleId: agentRole!._id,
        grantedBy: new mongoose.Types.ObjectId(userId),
      });

      // Should not find the server via agent
      const result = await serverConfigsDB.get(created.serverName, userId2);
      expect(result).toBeUndefined();
    });
  });

  describe('encryption/decryption error handling', () => {
    it('should return config without secret when decryption fails (graceful degradation)', async () => {
      // Create a server normally first
      const config = createSSEConfig('Decryption Failure Test', 'Test', {
        client_id: 'test-client',
        client_secret: 'test-secret',
      });
      const created = await serverConfigsDB.add('temp-name', config, userId);

      // Directly corrupt the encrypted secret in the database to simulate decryption failure
      const MCPServer = mongoose.models.MCPServer;
      await MCPServer.updateOne(
        { serverName: created.serverName },
        { $set: { 'config.oauth.client_secret': 'invalid:corrupted:encrypted:value' } },
      );

      // Get should return config without the secret (graceful degradation)
      const retrieved = await serverConfigsDB.get(created.serverName, userId);

      expect(retrieved).toBeDefined();
      expect(retrieved?.title).toBe('Decryption Failure Test');
      expect(retrieved?.oauth?.client_id).toBe('test-client');
      // Secret should be removed due to decryption failure
      expect(retrieved?.oauth?.client_secret).toBeUndefined();
    });

    it('should handle getAll with mixed valid and corrupted secrets', async () => {
      // Create servers with valid secrets
      const config1 = createSSEConfig('Valid Secret Server', 'Test', {
        client_id: 'client-1',
        client_secret: 'valid-secret',
      });
      const config2 = createSSEConfig('Corrupted Secret Server', 'Test', {
        client_id: 'client-2',
        client_secret: 'will-be-corrupted',
      });
      const created1 = await serverConfigsDB.add('temp1', config1, userId);
      const created2 = await serverConfigsDB.add('temp2', config2, userId);

      // Corrupt the second server's secret
      const MCPServer = mongoose.models.MCPServer;
      await MCPServer.updateOne(
        { serverName: created2.serverName },
        { $set: { 'config.oauth.client_secret': 'invalid:corrupted:data' } },
      );

      // GetAll should still return both servers
      const result = await serverConfigsDB.getAll(userId);

      expect(Object.keys(result)).toHaveLength(2);
      // First server should have decrypted secret
      expect(result[created1.serverName]?.oauth?.client_secret).toBe('valid-secret');
      // Second server should have secret removed due to decryption failure
      expect(result[created2.serverName]?.oauth?.client_id).toBe('client-2');
      expect(result[created2.serverName]?.oauth?.client_secret).toBeUndefined();
    });

    it('should return config without apiKey.key when decryption fails (graceful degradation)', async () => {
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'API Key Decryption Failure Test',
        apiKey: {
          source: 'admin',
          authorization_type: 'bearer',
          key: 'test-api-key',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      // Directly corrupt the encrypted key in the database to simulate decryption failure
      const MCPServer = mongoose.models.MCPServer;
      await MCPServer.updateOne(
        { serverName: created.serverName },
        { $set: { 'config.apiKey.key': 'invalid:corrupted:encrypted:value' } },
      );

      // Get should return config without the key (graceful degradation)
      const retrieved = await serverConfigsDB.get(created.serverName, userId);

      expect(retrieved).toBeDefined();
      expect(retrieved?.title).toBe('API Key Decryption Failure Test');
      expect(retrieved?.apiKey?.source).toBe('admin');
      expect(retrieved?.apiKey?.authorization_type).toBe('bearer');
      // Key should be removed due to decryption failure
      expect(retrieved?.apiKey?.key).toBeUndefined();
    });
  });

  describe('DB layer returns decrypted secrets (redaction is at controller layer)', () => {
    it('should return decrypted apiKey.key to VIEW-only user via get()', async () => {
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Secret API Key Server',
        apiKey: {
          source: 'admin',
          authorization_type: 'bearer',
          key: 'admin-secret-api-key',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      const role = await mongoose.models.AccessRole.findOne({
        accessRoleId: AccessRoleIds.MCPSERVER_VIEWER,
      });
      await mongoose.models.AclEntry.create({
        principalType: PrincipalType.USER,
        principalModel: PrincipalModel.USER,
        principalId: new mongoose.Types.ObjectId(userId2),
        resourceType: ResourceType.MCPSERVER,
        resourceId: new mongoose.Types.ObjectId(created.config.dbId!),
        permBits: PermissionBits.VIEW,
        roleId: role!._id,
        grantedBy: new mongoose.Types.ObjectId(userId),
      });

      const result = await serverConfigsDB.get(created.serverName, userId2);
      expect(result).toBeDefined();
      expect(result?.apiKey?.key).toBe('admin-secret-api-key');
    });

    it('should return decrypted oauth.client_secret to VIEW-only user via get()', async () => {
      const config = createSSEConfig('Secret OAuth Server', 'Test', {
        client_id: 'my-client-id',
        client_secret: 'admin-oauth-secret',
      });
      const created = await serverConfigsDB.add('temp-name', config, userId);

      const role = await mongoose.models.AccessRole.findOne({
        accessRoleId: AccessRoleIds.MCPSERVER_VIEWER,
      });
      await mongoose.models.AclEntry.create({
        principalType: PrincipalType.USER,
        principalModel: PrincipalModel.USER,
        principalId: new mongoose.Types.ObjectId(userId2),
        resourceType: ResourceType.MCPSERVER,
        resourceId: new mongoose.Types.ObjectId(created.config.dbId!),
        permBits: PermissionBits.VIEW,
        roleId: role!._id,
        grantedBy: new mongoose.Types.ObjectId(userId),
      });

      const result = await serverConfigsDB.get(created.serverName, userId2);
      expect(result).toBeDefined();
      expect(result?.oauth?.client_secret).toBe('admin-oauth-secret');
    });

    it('should return decrypted secrets to VIEW-only user via getAll()', async () => {
      const config: ParsedServerConfig = {
        type: 'sse',
        url: 'https://example.com/mcp',
        title: 'Shared Secret Server',
        apiKey: {
          source: 'admin',
          authorization_type: 'bearer',
          key: 'shared-api-key',
        },
        oauth: {
          client_id: 'shared-client',
          client_secret: 'shared-oauth-secret',
        },
      };
      const created = await serverConfigsDB.add('temp-name', config, userId);

      const role = await mongoose.models.AccessRole.findOne({
        accessRoleId: AccessRoleIds.MCPSERVER_VIEWER,
      });
      await mongoose.models.AclEntry.create({
        principalType: PrincipalType.USER,
        principalModel: PrincipalModel.USER,
        principalId: new mongoose.Types.ObjectId(userId2),
        resourceType: ResourceType.MCPSERVER,
        resourceId: new mongoose.Types.ObjectId(created.config.dbId!),
        permBits: PermissionBits.VIEW,
        roleId: role!._id,
        grantedBy: new mongoose.Types.ObjectId(userId),
      });

      const result = await serverConfigsDB.getAll(userId2);
      const serverConfig = result[created.serverName];
      expect(serverConfig).toBeDefined();
      expect(serverConfig?.apiKey?.key).toBe('shared-api-key');
      expect(serverConfig?.oauth?.client_secret).toBe('shared-oauth-secret');
    });
  });
});