mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-21 07:23:11 +00:00
* fix: Route Delete-User CLI Through the Shared Account Erasure Cascade The operator CLI ran raw deleteMany calls that dropped File metadata while leaving storage objects, skipped skills, MCP servers and agent checkpoints, and used the wrong field for agent API keys. Account self-deletion and the CLI now share eraseUserData in packages/api, so both remove stored file objects before metadata, open checkpoint deletion around conversations, and clear skills, MCP servers and shared links with ACL cleanup. * fix: Erase Favorites, Projects, Queued Turns and Refresh Bridges With the Account Account erasure left tool favorites, chat projects, queued agent turns and their sequences, and OpenID refresh token bridges behind. The shared eraseUserData cascade now clears them, adding deleteUserToolFavorites and deleteUserChatProjects where no delete-by-user method existed. * fix: Move MCP Server Erasure Queries Into Data Methods and Propagate Their Failures * test: Cover Delete-User CLI and Self-Service Erasure Scenarios * fix: Delete Stored Files When Account Deletion Arrives Without a Body * fix: Delete Stored Files Before User Keys and Keep Provider Failures Best Effort * fix: Propagate Agent and Prompt Erasure Failures Before Deleting the User * fix: Delete Erasure Retry Anchors Last When Removing User-Owned Resources * fix: Retire Session Hint From the Shared Erasure Cascade After Sessions Are Revoked * fix: Propagate Skill and Agent Reference Cleanup Failures Before Deleting the User * fix: Scope CLI Account Erasure to the Deleted User's Tenant and Legacy Refresh Bridges * fix: Clean Shared-User MCP OAuth State When Account Erasure Removes a Server * fix: Keep CLI Erasure System-Scoped Except ID-Keyed Cleanup and Await Shared-Link ACL Cleanup * fix: Scope CLI MCP OAuth Lookups to the Tenant and Fail Erasure When Shared-User Cleanup Fails * fix: Run CLI MCP OAuth Teardown and Allowlist Resolution Per User in the Tenant * fix: Tear Down Shared-User MCP OAuth State Before Removing the Server Retry Anchors * fix: Pin Agent Reference and MCP Token Cleanup to the Deleted User's Own Tenant
366 lines
11 KiB
JavaScript
366 lines
11 KiB
JavaScript
const mockGetMCPManager = jest.fn();
|
|
const mockInvalidateCachedTools = jest.fn();
|
|
|
|
jest.mock('~/config', () => ({
|
|
getMCPManager: (...args) => mockGetMCPManager(...args),
|
|
getFlowStateManager: jest.fn(),
|
|
getMCPServersRegistry: () => ({
|
|
getServerConfig: jest.fn().mockResolvedValue(undefined),
|
|
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();
|
|
});
|
|
|
|
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);
|
|
});
|
|
|
|
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();
|
|
});
|
|
});
|