mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-17 13:33:45 +00:00
* 🙈 feat: Let Config Profiles Hide librechat.yaml MCP Servers and Remove Their Fields Config profiles are the `__base__`, role, group and user documents written through `/api/admin/config`. A profile can tombstone `mcpServers.<name>`, and the merge then removes that server from the principal's resolved `mcpConfig`. * 🛡️ fix: Apply MCP Hiding to Server Instructions, Failed Removals and the Startup Audit - Server instructions bound for the model now leave out librechat.yaml servers hidden from the acting user, including one a model spec pins. `applyContextToAgent` passes the request user through `formatInstructionsForContext`, which drops the user's hidden set from the user-less catalog it reads. - A config-tier candidate that removes a librechat.yaml value (a field, or a key of a record such as `headers`) and fails inspection now stands as a failed config-source entry instead of falling back to the librechat.yaml base that still carries the removed value. A failed change that removes nothing still falls back, and an entry with no transport (fields written over a hidden server) keeps the documented librechat.yaml fallback. - The startup tombstone report reads every tenant's profiles in the system tenant scope, so it also runs from entry points without an outer system scope under strict tenant isolation, and names each profile's tenant. * 🗂️ fix: Project the Startup MCP Tombstone Report Query and Run It Alongside Connections * 🔑 fix: Keep Removed OAuth Headers Out of the MCP OAuth Callback * 📝 docs: Note That Removed OAuth Headers Stay Out of MCP Sign-In * 🔐 fix: Recheck the MCP OAuth Flow's Server Before Initiation Redirects OAuth initiation redirected to a flow's stored authorization URL, or started a new authorization from the flow's stored server URL, without resolving the server again, so a principal whose profile hid the server after the flow was created could still be sent to its authorization endpoint. The callback's active-server check and its OAuth header fallback lived in the CJS route. resolveMCPOAuthTarget (packages/api/src/mcp/oauth/target.ts) now owns both: it resolves the server in the principal's current config with a strict read, refuses a flow admitted for another server, a server the principal can no longer use, or a redefined one, and selects the headers the flow sends (the initiation snapshot, else the principal's config). Initiation calls it before either redirect (404 or 400); the callback calls it before the exchange and from the token-store fence. * 📝 docs: Note That a Hidden MCP Server Ends OAuth Sign-Ins Already Started * 🚩 feat: Publish the yamlMcpHide Admin Config Meta Flag Profiles can hide librechat.yaml MCP servers and a hidden server is an access boundary, so GET /api/admin/config/meta now reports features.yamlMcpHide for the admin panel to gate its hide UI on. The meta.spec probe checks the behaviour itself: the admin API stores an mcpServers.<name> tombstone, the merged config drops the server, the registry withholds it from principal lookups and checkout but not from app-level lookups, process-backed servers stay, and an unreadable principal config withholds every hideable server. * 🧪 test: Align MCP Tombstone Specs With the Portable Config Store The admin config handlers now write whole documents through writeConfigDocument, so the end-to-end tombstone spec wires it in place of the removed upsertConfig/patchConfigFields deps. A reset of a whole MCP record now also prunes the parents it leaves empty.
376 lines
12 KiB
JavaScript
376 lines
12 KiB
JavaScript
const mockGetMCPManager = jest.fn();
|
|
const mockInvalidateCachedTools = jest.fn();
|
|
const mockGetServerConfig = jest.fn();
|
|
|
|
jest.mock('~/config', () => ({
|
|
getMCPManager: (...args) => mockGetMCPManager(...args),
|
|
getFlowStateManager: jest.fn(),
|
|
getMCPServersRegistry: () => ({
|
|
getServerConfig: (...args) => mockGetServerConfig(...args),
|
|
resolveAllowlists: jest.fn().mockResolvedValue({}),
|
|
}),
|
|
}));
|
|
|
|
jest.mock('~/server/services/MCP/oauthCleanup', () => ({
|
|
maybeUninstallOAuthMCP: jest.fn().mockResolvedValue(undefined),
|
|
}));
|
|
|
|
jest.mock('~/server/services/Config/getCachedTools', () => ({
|
|
invalidateCachedTools: (...args) => mockInvalidateCachedTools(...args),
|
|
}));
|
|
|
|
jest.mock('~/server/services/Config', () => ({
|
|
getAppConfig: jest.fn(),
|
|
getMCPServerTools: jest.fn(),
|
|
}));
|
|
|
|
const mongoose = require('mongoose');
|
|
const { mcpServerSchema } = require('@librechat/data-schemas');
|
|
const { MongoMemoryServer } = require('mongodb-memory-server');
|
|
const {
|
|
ResourceType,
|
|
AccessRoleIds,
|
|
PrincipalType,
|
|
PermissionBits,
|
|
} = require('librechat-data-provider');
|
|
const permissionService = require('~/server/services/PermissionService');
|
|
const { deleteUserMcpServers } = require('~/server/controllers/UserController');
|
|
const { AclEntry, AccessRole } = require('~/db/models');
|
|
|
|
let MCPServer;
|
|
|
|
describe('deleteUserMcpServers', () => {
|
|
let mongoServer;
|
|
|
|
beforeAll(async () => {
|
|
mongoServer = await MongoMemoryServer.create();
|
|
const mongoUri = mongoServer.getUri();
|
|
MCPServer = mongoose.models.MCPServer || mongoose.model('MCPServer', mcpServerSchema);
|
|
await mongoose.connect(mongoUri);
|
|
|
|
await AccessRole.create({
|
|
accessRoleId: AccessRoleIds.MCPSERVER_OWNER,
|
|
name: 'MCP Server Owner',
|
|
resourceType: ResourceType.MCPSERVER,
|
|
permBits:
|
|
PermissionBits.VIEW | PermissionBits.EDIT | PermissionBits.DELETE | PermissionBits.SHARE,
|
|
});
|
|
|
|
await AccessRole.create({
|
|
accessRoleId: AccessRoleIds.MCPSERVER_VIEWER,
|
|
name: 'MCP Server Viewer',
|
|
resourceType: ResourceType.MCPSERVER,
|
|
permBits: PermissionBits.VIEW,
|
|
});
|
|
}, 20000);
|
|
|
|
afterAll(async () => {
|
|
await mongoose.disconnect();
|
|
await mongoServer.stop();
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
await MCPServer.deleteMany({});
|
|
await AclEntry.deleteMany({});
|
|
jest.clearAllMocks();
|
|
mockGetServerConfig.mockResolvedValue(undefined);
|
|
});
|
|
|
|
test('should delete solely-owned MCP servers and their ACL entries', async () => {
|
|
const userId = new mongoose.Types.ObjectId();
|
|
|
|
const server = await MCPServer.create({
|
|
serverName: 'sole-owned-server',
|
|
config: { title: 'Test Server' },
|
|
author: userId,
|
|
});
|
|
|
|
await permissionService.grantPermission({
|
|
principalType: PrincipalType.USER,
|
|
principalId: userId,
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: server._id,
|
|
accessRoleId: AccessRoleIds.MCPSERVER_OWNER,
|
|
grantedBy: userId,
|
|
});
|
|
|
|
mockGetMCPManager.mockReturnValue({
|
|
disconnectUserConnection: jest.fn().mockResolvedValue(undefined),
|
|
});
|
|
|
|
await deleteUserMcpServers(userId.toString());
|
|
|
|
expect(await MCPServer.findById(server._id)).toBeNull();
|
|
|
|
const aclEntries = await AclEntry.find({
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: server._id,
|
|
});
|
|
expect(aclEntries).toHaveLength(0);
|
|
/** Credential cleanup must reach a server even when a profile hides it from the account. */
|
|
expect(mockGetServerConfig).toHaveBeenCalledWith(
|
|
'sole-owned-server',
|
|
userId.toString(),
|
|
undefined,
|
|
undefined,
|
|
{ includeHidden: true },
|
|
);
|
|
});
|
|
|
|
test('should disconnect MCP sessions and invalidate tool cache before deletion', async () => {
|
|
const userId = new mongoose.Types.ObjectId();
|
|
const mockDisconnect = jest.fn().mockResolvedValue(undefined);
|
|
|
|
const server = await MCPServer.create({
|
|
serverName: 'session-server',
|
|
config: { title: 'Session Server' },
|
|
author: userId,
|
|
});
|
|
|
|
await permissionService.grantPermission({
|
|
principalType: PrincipalType.USER,
|
|
principalId: userId,
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: server._id,
|
|
accessRoleId: AccessRoleIds.MCPSERVER_OWNER,
|
|
grantedBy: userId,
|
|
});
|
|
|
|
mockGetMCPManager.mockReturnValue({ disconnectUserConnection: mockDisconnect });
|
|
|
|
await deleteUserMcpServers(userId.toString());
|
|
|
|
expect(mockDisconnect).toHaveBeenCalledWith(userId.toString(), 'session-server');
|
|
expect(mockInvalidateCachedTools).toHaveBeenCalledWith({
|
|
userId: userId.toString(),
|
|
serverName: 'session-server',
|
|
});
|
|
});
|
|
|
|
test('should delete owned servers when cache invalidation fails', async () => {
|
|
const userId = new mongoose.Types.ObjectId();
|
|
const server = await MCPServer.create({
|
|
serverName: 'cache-failure-server',
|
|
config: { title: 'Cache Failure Server' },
|
|
author: userId,
|
|
});
|
|
|
|
await permissionService.grantPermission({
|
|
principalType: PrincipalType.USER,
|
|
principalId: userId,
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: server._id,
|
|
accessRoleId: AccessRoleIds.MCPSERVER_OWNER,
|
|
grantedBy: userId,
|
|
});
|
|
|
|
const disconnectUserConnection = jest.fn().mockResolvedValue(undefined);
|
|
mockGetMCPManager.mockReturnValue({ disconnectUserConnection });
|
|
mockInvalidateCachedTools.mockRejectedValueOnce(new Error('Redis unavailable'));
|
|
|
|
await deleteUserMcpServers(userId.toString());
|
|
|
|
expect(disconnectUserConnection).toHaveBeenCalledWith(
|
|
userId.toString(),
|
|
'cache-failure-server',
|
|
);
|
|
expect(await MCPServer.findById(server._id)).toBeNull();
|
|
await expect(
|
|
AclEntry.countDocuments({
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: server._id,
|
|
}),
|
|
).resolves.toBe(0);
|
|
});
|
|
|
|
test('should preserve multi-owned MCP servers', async () => {
|
|
const deletingUserId = new mongoose.Types.ObjectId();
|
|
const otherOwnerId = new mongoose.Types.ObjectId();
|
|
|
|
const soleServer = await MCPServer.create({
|
|
serverName: 'sole-server',
|
|
config: { title: 'Sole Server' },
|
|
author: deletingUserId,
|
|
});
|
|
|
|
const multiServer = await MCPServer.create({
|
|
serverName: 'multi-server',
|
|
config: { title: 'Multi Server' },
|
|
author: deletingUserId,
|
|
});
|
|
|
|
await permissionService.grantPermission({
|
|
principalType: PrincipalType.USER,
|
|
principalId: deletingUserId,
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: soleServer._id,
|
|
accessRoleId: AccessRoleIds.MCPSERVER_OWNER,
|
|
grantedBy: deletingUserId,
|
|
});
|
|
|
|
await permissionService.grantPermission({
|
|
principalType: PrincipalType.USER,
|
|
principalId: deletingUserId,
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: multiServer._id,
|
|
accessRoleId: AccessRoleIds.MCPSERVER_OWNER,
|
|
grantedBy: deletingUserId,
|
|
});
|
|
await permissionService.grantPermission({
|
|
principalType: PrincipalType.USER,
|
|
principalId: otherOwnerId,
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: multiServer._id,
|
|
accessRoleId: AccessRoleIds.MCPSERVER_OWNER,
|
|
grantedBy: otherOwnerId,
|
|
});
|
|
|
|
mockGetMCPManager.mockReturnValue({
|
|
disconnectUserConnection: jest.fn().mockResolvedValue(undefined),
|
|
});
|
|
|
|
await deleteUserMcpServers(deletingUserId.toString());
|
|
|
|
expect(await MCPServer.findById(soleServer._id)).toBeNull();
|
|
expect(await MCPServer.findById(multiServer._id)).not.toBeNull();
|
|
|
|
const soleAcl = await AclEntry.find({
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: soleServer._id,
|
|
});
|
|
expect(soleAcl).toHaveLength(0);
|
|
|
|
const multiAclOther = await AclEntry.find({
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: multiServer._id,
|
|
principalId: otherOwnerId,
|
|
});
|
|
expect(multiAclOther).toHaveLength(1);
|
|
expect(multiAclOther[0].permBits & PermissionBits.DELETE).toBeTruthy();
|
|
|
|
const multiAclDeleting = await AclEntry.find({
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: multiServer._id,
|
|
principalId: deletingUserId,
|
|
});
|
|
expect(multiAclDeleting).toHaveLength(1);
|
|
});
|
|
|
|
test('should be a no-op when user has no owned MCP servers', async () => {
|
|
const userId = new mongoose.Types.ObjectId();
|
|
|
|
const otherUserId = new mongoose.Types.ObjectId();
|
|
const server = await MCPServer.create({
|
|
serverName: 'other-server',
|
|
config: { title: 'Other Server' },
|
|
author: otherUserId,
|
|
});
|
|
|
|
await permissionService.grantPermission({
|
|
principalType: PrincipalType.USER,
|
|
principalId: otherUserId,
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: server._id,
|
|
accessRoleId: AccessRoleIds.MCPSERVER_OWNER,
|
|
grantedBy: otherUserId,
|
|
});
|
|
|
|
await deleteUserMcpServers(userId.toString());
|
|
|
|
expect(await MCPServer.findById(server._id)).not.toBeNull();
|
|
expect(mockGetMCPManager).not.toHaveBeenCalled();
|
|
});
|
|
|
|
test('should handle gracefully when MCPServer model is not registered', async () => {
|
|
const originalModel = mongoose.models.MCPServer;
|
|
delete mongoose.models.MCPServer;
|
|
|
|
try {
|
|
const userId = new mongoose.Types.ObjectId();
|
|
await expect(deleteUserMcpServers(userId.toString())).resolves.toBeUndefined();
|
|
} finally {
|
|
mongoose.models.MCPServer = originalModel;
|
|
}
|
|
});
|
|
|
|
test('should handle gracefully when MCPManager is not available', async () => {
|
|
const userId = new mongoose.Types.ObjectId();
|
|
|
|
const server = await MCPServer.create({
|
|
serverName: 'no-manager-server',
|
|
config: { title: 'No Manager Server' },
|
|
author: userId,
|
|
});
|
|
|
|
await permissionService.grantPermission({
|
|
principalType: PrincipalType.USER,
|
|
principalId: userId,
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: server._id,
|
|
accessRoleId: AccessRoleIds.MCPSERVER_OWNER,
|
|
grantedBy: userId,
|
|
});
|
|
|
|
mockGetMCPManager.mockReturnValue(null);
|
|
|
|
await deleteUserMcpServers(userId.toString());
|
|
|
|
expect(await MCPServer.findById(server._id)).toBeNull();
|
|
expect(mockInvalidateCachedTools).toHaveBeenCalledWith({
|
|
userId: userId.toString(),
|
|
serverName: 'no-manager-server',
|
|
});
|
|
});
|
|
|
|
test('should delete legacy MCP servers that have author but no ACL entries', async () => {
|
|
const legacyUserId = new mongoose.Types.ObjectId();
|
|
|
|
const legacyServer = await MCPServer.create({
|
|
serverName: 'legacy-server',
|
|
config: { title: 'Legacy Server' },
|
|
author: legacyUserId,
|
|
});
|
|
|
|
mockGetMCPManager.mockReturnValue({
|
|
disconnectUserConnection: jest.fn().mockResolvedValue(undefined),
|
|
});
|
|
|
|
await deleteUserMcpServers(legacyUserId.toString());
|
|
|
|
expect(await MCPServer.findById(legacyServer._id)).toBeNull();
|
|
});
|
|
|
|
test('should delete both ACL-owned and legacy servers in one call', async () => {
|
|
const userId = new mongoose.Types.ObjectId();
|
|
|
|
const aclServer = await MCPServer.create({
|
|
serverName: 'acl-server',
|
|
config: { title: 'ACL Server' },
|
|
author: userId,
|
|
});
|
|
|
|
await permissionService.grantPermission({
|
|
principalType: PrincipalType.USER,
|
|
principalId: userId,
|
|
resourceType: ResourceType.MCPSERVER,
|
|
resourceId: aclServer._id,
|
|
accessRoleId: AccessRoleIds.MCPSERVER_OWNER,
|
|
grantedBy: userId,
|
|
});
|
|
|
|
const legacyServer = await MCPServer.create({
|
|
serverName: 'legacy-mixed-server',
|
|
config: { title: 'Legacy Mixed' },
|
|
author: userId,
|
|
});
|
|
|
|
mockGetMCPManager.mockReturnValue({
|
|
disconnectUserConnection: jest.fn().mockResolvedValue(undefined),
|
|
});
|
|
|
|
await deleteUserMcpServers(userId.toString());
|
|
|
|
expect(await MCPServer.findById(aclServer._id)).toBeNull();
|
|
expect(await MCPServer.findById(legacyServer._id)).toBeNull();
|
|
});
|
|
});
|