Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🗑️ fix: Route Delete-User CLI Through the Shared Account Erasure Cascade (#17033)
Marco Beretta6e2941050b04
diff --git a/api/server/controllers/UserController.js b/api/server/controllers/UserController.jsindex 446b017201..3f4bdb66b6 100644--- a/api/server/controllers/UserController.js+++ b/api/server/controllers/UserController.js@@ -18,15 +18,17 @@ const {isStopConfirmed,waitForGenerationPersistence,deleteAllSharedLinksWithCleanup,+ eraseUserData,+ deleteUserMCPServers,revokeUserCodeEnvironmentWorkers,finalizeMCPAuthorizationMutation,clearSessionHintCookie,} = require('@librechat/api');-const { Tools, Constants, FileSources, ResourceType } = require('librechat-data-provider');+const { Tools, Constants, FileSources } = require('librechat-data-provider');const { updateUserPluginAuth, deleteUserPluginAuth } = require('~/server/services/PluginService');const { verifyOTPOrBackupCode } = require('~/server/services/twoFactorService');const { verifyEmail, resendVerificationEmail } = require('~/server/services/AuthService');-const { getMCPManager } = require('~/config');+const { getMCPManager, getMCPServersRegistry } = require('~/config');const { maybeUninstallOAuthMCP } = require('~/server/services/MCP/oauthCleanup');const { invalidateCachedTools } = require('~/server/services/Config/getCachedTools');const {@@ -155,100 +157,31 @@ const acceptTermsController = async (req, res) => {}};-const deleteUserFiles = async (req) => {- try {- const userFiles = await db.getFiles({ user: req.user.id });- await processDeleteRequest({- req,- files: userFiles,- });- } catch (error) {- logger.error('[deleteUserFiles]', error);- }-};--/**- * Deletes MCP servers solely owned by the user and cleans up their ACLs.- * Disconnects live sessions for deleted servers before removing DB records.- * Servers with other owners are left intact; the caller is responsible for- * removing the user's own ACL principal entries separately.- *- * Also handles legacy (pre-ACL) MCP servers that only have the author field set,- * ensuring they are not orphaned if no permission migration has been run.- * @param {string} userId - The ID of the user.- */-const deleteUserMcpServers = async (userId) => {- try {- const MCPServer = mongoose.models.MCPServer;- const AclEntry = mongoose.models.AclEntry;- if (!MCPServer) {- return;- }-- const userObjectId = new mongoose.Types.ObjectId(userId);- const soleOwnedIds = await db.getSoleOwnedResourceIds(userObjectId, ResourceType.MCPSERVER);-- const authoredServers = await MCPServer.find({ author: userObjectId })- .select('_id serverName')- .lean();-- const migratedEntries =- authoredServers.length > 0- ? await AclEntry.find({- resourceType: ResourceType.MCPSERVER,- resourceId: { $in: authoredServers.map((s) => s._id) },- })- .select('resourceId')- .lean()- : [];- const migratedIds = new Set(migratedEntries.map((e) => e.resourceId.toString()));- const legacyServers = authoredServers.filter((s) => !migratedIds.has(s._id.toString()));- const legacyServerIds = legacyServers.map((s) => s._id);-- const allServerIdsToDelete = [...soleOwnedIds, ...legacyServerIds];-- if (allServerIdsToDelete.length === 0) {- return;- }-- const aclOwnedServers =- soleOwnedIds.length > 0- ? await MCPServer.find({ _id: { $in: soleOwnedIds } })- .select('serverName')- .lean()- : [];- const allServersToDelete = [...aclOwnedServers, ...legacyServers];-- const mcpManager = getMCPManager();- await Promise.allSettled(- allServersToDelete.map(async (s) => {- try {- await invalidateCachedTools({ userId, serverName: s.serverName });- } catch (error) {- logger.warn(- `[deleteUserMcpServers] Failed to invalidate tools for ${s.serverName}:`,- error,- );- } finally {- try {- await mcpManager?.disconnectUserConnection(userId, s.serverName);- } catch (error) {- logger.warn(`[deleteUserMcpServers] Failed to disconnect ${s.serverName}:`, error);- }- }- }),- );-- await AclEntry.deleteMany({- resourceType: ResourceType.MCPSERVER,- resourceId: { $in: allServerIdsToDelete },- });-- await MCPServer.deleteMany({ _id: { $in: allServerIdsToDelete } });- } catch (error) {- logger.error('[deleteUserMcpServers] General error:', error);- }-};+/** Runtime hooks for MCP servers removed with a deleted account. */+const createMCPServerCleanup = (userId) => ({+ findUserErasableMCPServers: db.findUserErasableMCPServers,+ deleteMCPServersWithAcl: db.deleteMCPServersWithAcl,+ invalidateMCPServerTools: (serverName) => invalidateCachedTools({ userId, serverName }),+ disconnectMCPServer: async (serverName) => {+ await getMCPManager()?.disconnectUserConnection(userId, serverName);+ },+ findMCPServerOAuthTokenUserIds: db.findMCPServerOAuthTokenUserIds,+ findMCPServerViewerEntries: db.findMCPServerViewerEntries,+ mcpOAuth: {+ getServerConfig: (serverName) => getMCPServersRegistry().getServerConfig(serverName, userId),+ getUserPrincipals: (candidateId) => db.getUserPrincipals({ userId: candidateId }),+ resolveAllowlists: (candidateId) =>+ getMCPServersRegistry().resolveAllowlists({ userId: candidateId }),+ invalidateUserTools: (candidateId, serverName) =>+ invalidateCachedTools({ userId: candidateId, serverName }),+ disconnectUser: (candidateId, serverName) =>+ getMCPManager()?.disconnectUserConnection(candidateId, serverName),+ uninstallOAuthMCP: maybeUninstallOAuthMCP,+ },+});++const deleteUserMcpServers = (userId) =>+ deleteUserMCPServers(userId, createMCPServerCleanup(userId));const updateUserPluginsController = async (req, res) => {const appConfig = req.config ?? (await getAppConfig(getAppConfigOptionsFromUser(req.user)));@@ -518,50 +451,23 @@ const deleteUserController = async (req, res) => {userId: user.id,tenantId,}));- const checkpointer = appConfig?.endpoints?.agents?.checkpointer;- const checkpointDeletion = await openCheckpointDeletion(- user.id,- tenantId,- undefined,- checkpointer,- );- await db.deleteConvos(- user.id,- {},+ await eraseUserData(+ {+ userId: user.id,+ tenantId,+ checkpointer: appConfig?.endpoints?.agents?.checkpointer,+ },{- allowEmpty: true,- beforeDelete: (ids) => checkpointDeletion.remember(ids),+ ...db,+ openCheckpointDeletion,+ deleteSharedLinks: (id) => deleteAllSharedLinksWithCleanup(id, { awaitCleanup: true }),+ /** The DELETE carries no body without 2FA, and account erasure targets no assistant. */+ deleteStoredFiles: (files) =>+ processDeleteRequest({ req: Object.assign(Object.create(req), { body: {} }), files }),+ ...createMCPServerCleanup(user.id),+ onSessionsDeleted: () => clearSessionHintCookie(res),},);- await checkpointDeletion.cleanup();- await checkpointDeletion.acknowledge();-- await db.deleteMessages({ user: user.id });- await db.deleteAllUserSessions({ userId: user.id });- clearSessionHintCookie(res);- await db.deletePasskeysByUser(user.id);- await db.deleteTransactions({ user: user.id });- await db.deleteUserKey({ userId: user.id, all: true });- await db.deleteBalances({ user: user._id });- await db.deletePresets(user.id);- await deleteUserPluginAuth(user.id, null, true);- await deleteAllSharedLinksWithCleanup(user.id);- await deleteUserFiles(req);- await db.deleteFiles(null, user.id);- await db.deleteToolCalls(user.id);- await db.deleteUserAgents(user.id);- await db.deleteAllAgentApiKeys(user._id);- await db.deleteAssistants({ user: user.id });- await db.deleteConversationTags({ user: user.id });- await db.deleteAllUserMemories(user.id);- await db.deleteUserPrompts(user.id);- await db.deleteUserSkills(user.id);- await deleteUserMcpServers(user.id);- await db.deleteActions({ user: user.id });- await db.deleteTokens({ userId: user.id });- await db.removeUserFromAllGroups(user.id);- await db.deleteAclEntries({ principalId: user._id });- await db.deleteSchedulesByUser(user.id);const deleteResult = await db.deleteUserById(user.id);if (deleteResult.deletedCount !== 1) {throw new Error('User disappeared before account deletion could commit');diff --git a/api/server/controllers/UserController.spec.js b/api/server/controllers/UserController.spec.jsindex db724279a8..c9f242fd33 100644--- a/api/server/controllers/UserController.spec.js+++ b/api/server/controllers/UserController.spec.js@@ -53,9 +53,16 @@ jest.mock('~/models', () => {deleteSchedulesByUser: jest.fn().mockResolvedValue(undefined),deleteTransactions: jest.fn().mockResolvedValue(undefined),deleteAclEntries: jest.fn().mockResolvedValue(undefined),+ deleteUserChatProjects: jest.fn().mockResolvedValue(0),+ deleteUserToolFavorites: jest.fn().mockResolvedValue(0),+ deleteRefreshTokenBridges: jest.fn().mockResolvedValue(undefined),+ deleteAllAgentQueuedTurnsForUser: jest.fn().mockResolvedValue(0),+ findUserErasableMCPServers: jest.fn().mockResolvedValue([]),+ deleteMCPServersWithAcl: jest.fn().mockResolvedValue(0),updateUserPlugins: jest.fn(),deleteAssistants: jest.fn().mockResolvedValue(undefined),deleteUserById: jest.fn().mockResolvedValue({ deletedCount: 1 }),+ deleteAllUserPluginAuths: jest.fn().mockResolvedValue(undefined),beginAgentTriggerUserDeletion: jest.fn().mockResolvedValue('acquired'),cancelAgentTriggerUserDeletion: jest.fn().mockResolvedValue(true),deleteUserPrompts: jest.fn().mockResolvedValue(undefined),diff --git a/api/server/controllers/__tests__/deleteUser.spec.js b/api/server/controllers/__tests__/deleteUser.spec.jsindex dce796d6e8..cbe5dd58ae 100644--- a/api/server/controllers/__tests__/deleteUser.spec.js+++ b/api/server/controllers/__tests__/deleteUser.spec.js@@ -1,3 +1,5 @@+/** Account deletion converts the id for ObjectId-keyed stores, so it must be a valid one. */+const USER_ID = '65f1a2b3c4d5e6f708192a3b';const mockGetUserById = jest.fn();const mockDeleteMessages = jest.fn();const mockDeleteAllUserSessions = jest.fn();@@ -13,7 +15,7 @@ const mockUpdateUserPlugins = jest.fn();const mockUpdateUser = jest.fn();const mockFindToken = jest.fn();const mockVerifyOTPOrBackupCode = jest.fn();-const mockDeleteUserPluginAuth = jest.fn();+const mockDeleteAllUserPluginAuths = jest.fn();const mockProcessDeleteRequest = jest.fn();const mockDeleteToolCalls = jest.fn();const mockDeleteUserAgents = jest.fn();@@ -36,6 +38,11 @@ const mockDeleteSchedulesByUser = jest.fn();const mockRevokeUserCodeEnvironmentWorkers = jest.fn();const mockDeletePasskeysByUser = jest.fn();+jest.mock('../../../../packages/api/src/mcp/oauth/cleanup', () => ({+ cleanupDeletedMCPServerOAuthUsers: jest.fn(),+ prepareMCPServerOAuthDeletion: jest.fn(),+}));+jest.mock('@librechat/data-schemas', () => ({logger: { error: jest.fn(), info: jest.fn() },webSearchKeys: [],@@ -62,6 +69,7 @@ jest.mock('@librechat/api', () => ({needsRefresh: jest.fn(),getNewS3URL: jest.fn(),deleteAllSharedLinksWithCleanup: (...args) => mockDeleteAllSharedLinksWithCleanup(...args),+ eraseUserData: jest.requireActual('../../../../packages/api/src/user/erasure.ts').eraseUserData,revokeUserCodeEnvironmentWorkers: (...args) => mockRevokeUserCodeEnvironmentWorkers(...args),GenerationJobManager: {getAccountCleanupJobIdsForUser: (...args) => mockGetCleanupBlockingJobIdsForUser(...args),@@ -92,6 +100,7 @@ jest.mock('~/models', () => ({deleteAllSharedLinks: (...args) => mockDeleteAllSharedLinks(...args),updateUserPlugins: (...args) => mockUpdateUserPlugins(...args),deleteUserById: (...args) => mockDeleteUserById(...args),+ deleteAllUserPluginAuths: (...args) => mockDeleteAllUserPluginAuths(...args),beginAgentTriggerUserDeletion: (...args) => mockBeginAgentTriggerUserDeletion(...args),cancelAgentTriggerUserDeletion: (...args) => mockCancelAgentTriggerUserDeletion(...args),deleteMessages: (...args) => mockDeleteMessages(...args),@@ -118,13 +127,19 @@ jest.mock('~/models', () => ({deleteTokens: jest.fn(),removeUserFromAllGroups: jest.fn(),deleteAclEntries: jest.fn(),+ deleteUserChatProjects: jest.fn(),+ deleteUserToolFavorites: jest.fn(),+ deleteRefreshTokenBridges: jest.fn(),+ deleteAllAgentQueuedTurnsForUser: jest.fn(),deleteSchedulesByUser: (...args) => mockDeleteSchedulesByUser(...args),getSoleOwnedResourceIds: jest.fn().mockResolvedValue([]),+ findUserErasableMCPServers: jest.fn().mockResolvedValue([]),+ deleteMCPServersWithAcl: jest.fn(),}));jest.mock('~/server/services/PluginService', () => ({updateUserPluginAuth: jest.fn(),- deleteUserPluginAuth: (...args) => mockDeleteUserPluginAuth(...args),+ deleteUserPluginAuth: jest.fn(),}));jest.mock('~/server/services/twoFactorService', () => ({@@ -197,7 +212,7 @@ function stubDeletionMocks() {mockDeleteUserKey.mockResolvedValue();mockDeletePresets.mockResolvedValue();mockDeleteConvos.mockResolvedValue();- mockDeleteUserPluginAuth.mockResolvedValue();+ mockDeleteAllUserPluginAuths.mockResolvedValue();mockDeleteUserById.mockResolvedValue({ deletedCount: 1 });mockDeleteAllSharedLinks.mockResolvedValue();mockDeleteAllSharedLinksWithCleanup.mockResolvedValue({ deletedCount: 0 });@@ -232,14 +247,14 @@ beforeEach(() => {describe('deleteUserController - session hint', () => {it('retires the session hint once sessions are revoked, even when a later cleanup fails', async () => {- const req = { user: { id: 'user1', _id: 'user1', email: '[email protected]' }, body: {} };+ const req = { user: { id: USER_ID, _id: USER_ID, email: '[email protected]' }, body: {} };const res = createRes();- mockGetUserById.mockResolvedValue({ _id: 'user1', twoFactorEnabled: false });+ mockGetUserById.mockResolvedValue({ _id: USER_ID, twoFactorEnabled: false });mockDeletePresets.mockRejectedValue(new Error('preset store unavailable'));await deleteUserController(req, res);- expect(mockDeleteAllUserSessions).toHaveBeenCalledWith({ userId: 'user1' });+ expect(mockDeleteAllUserSessions).toHaveBeenCalledWith({ userId: USER_ID });expect(clearSessionHintCookie).toHaveBeenCalledWith(res);expect(mockDeleteAllUserSessions.mock.invocationCallOrder[0]).toBeLessThan(clearSessionHintCookie.mock.invocationCallOrder[0],@@ -249,24 +264,51 @@ describe('deleteUserController - session hint', () => {});describe('deleteUserController - 2FA enforcement', () => {+ it('deletes stored files when the DELETE arrives without a body', async () => {+ const files = [{ file_id: 'file-1', filepath: '/uploads/a', source: 'local' }];+ const req = { user: { id: USER_ID, _id: USER_ID, email: '[email protected]' } };+ const res = createRes();+ mockGetUserById.mockResolvedValue({ _id: USER_ID, twoFactorEnabled: false });+ mockGetFiles.mockResolvedValue(files);++ await deleteUserController(req, res);++ expect(res.status).toHaveBeenCalledWith(200);+ const [{ req: fileRequest, files: deleted }] = mockProcessDeleteRequest.mock.calls[0];+ expect(deleted).toBe(files);+ expect(fileRequest.body).toEqual({});+ expect(fileRequest.user).toBe(req.user);+ });+it('proceeds with deletion when 2FA is not enabled', async () => {- const req = { user: { id: 'user1', _id: 'user1', email: '[email protected]' }, body: {} };+ const req = { user: { id: USER_ID, _id: USER_ID, email: '[email protected]' }, body: {} };const res = createRes();- mockGetUserById.mockResolvedValue({ _id: 'user1', twoFactorEnabled: false });+ mockGetUserById.mockResolvedValue({ _id: USER_ID, twoFactorEnabled: false });await deleteUserController(req, res);expect(res.status).toHaveBeenCalledWith(200);expect(res.send).toHaveBeenCalledWith({ message: 'User deleted' });expect(mockDeleteMessages).toHaveBeenCalled();- expect(mockDeleteUserAgents).toHaveBeenCalledWith('user1');- expect(mockDeleteUserPrompts).toHaveBeenCalledWith('user1');- expect(mockDeleteUserSkills).toHaveBeenCalledWith('user1');+ expect(mockDeleteUserAgents).toHaveBeenCalledWith(USER_ID);+ expect(mockDeleteUserPrompts).toHaveBeenCalledWith(USER_ID);+ expect(mockDeleteUserSkills).toHaveBeenCalledWith(USER_ID);expect(mockInvalidateCodeEnvironmentConfigCache).toHaveBeenCalledWith(undefined);expect(mockRevokeUserCodeEnvironmentWorkers).toHaveBeenCalledWith(- expect.objectContaining({ userId: 'user1' }),+ expect.objectContaining({ userId: USER_ID }),+ );+ expect(mockDeletePasskeysByUser).toHaveBeenCalledWith(USER_ID);+ expect(mockDeleteAllUserPluginAuths).toHaveBeenCalledWith(USER_ID);+ expect(mockDeleteAllSharedLinksWithCleanup).toHaveBeenCalledWith(USER_ID, {+ awaitCleanup: true,+ });+ expect(mockProcessDeleteRequest).toHaveBeenCalledWith({+ req: expect.objectContaining({ user: req.user, body: {} }),+ files: [],+ });+ expect(mockProcessDeleteRequest.mock.invocationCallOrder[0]).toBeLessThan(+ mockDeleteFiles.mock.invocationCallOrder[0],);- expect(mockDeletePasskeysByUser).toHaveBeenCalledWith('user1');expect(mockVerifyOTPOrBackupCode).not.toHaveBeenCalled();expect(mockBeginAgentTriggerUserDeletion.mock.invocationCallOrder[0]).toBeLessThan(mockPrepareAgentTriggerUserPurge.mock.invocationCallOrder[0],@@ -294,11 +336,11 @@ describe('deleteUserController - 2FA enforcement', () => {const { logger } = require('@librechat/data-schemas');logger.info.mockClear();const req = {- user: { id: 'user1', _id: 'user1', email: '[email protected]', tenantId: 'tenant-1' },+ user: { id: USER_ID, _id: USER_ID, email: '[email protected]', tenantId: 'tenant-1' },body: {},};mockGetUserById.mockResolvedValue({- _id: 'user1',+ _id: USER_ID,email: '[email protected]',tenantId: 'tenant-1',twoFactorEnabled: false,@@ -307,27 +349,27 @@ describe('deleteUserController - 2FA enforcement', () => {await deleteUserController(req, createRes());const lines = logger.info.mock.calls.map(([line]) => String(line));- expect(lines).toContain('User deleted account. ID: user1 Tenant: tenant-1');+ expect(lines).toContain(`User deleted account. ID: ${USER_ID} Tenant: tenant-1`);expect(JSON.stringify(logger.info.mock.calls)).not.toContain('[email protected]');});it('aborts active generation jobs before deleting account-owned records', async () => {const req = {- user: { id: 'user1', _id: 'user1', email: '[email protected]', tenantId: 'tenant-1' },+ user: { id: USER_ID, _id: USER_ID, email: '[email protected]', tenantId: 'tenant-1' },body: {},};const res = createRes();- mockGetUserById.mockResolvedValue({ _id: 'user1', twoFactorEnabled: false });+ mockGetUserById.mockResolvedValue({ _id: USER_ID, twoFactorEnabled: false });mockGetCleanupBlockingJobIdsForUser.mockResolvedValueOnce(['stream-1']);mockGetAgentJob.mockResolvedValueOnce({- metadata: { userId: 'user1', tenantId: 'tenant-1' },+ metadata: { userId: USER_ID, tenantId: 'tenant-1' },createdAt: 123,});mockAbortJob.mockResolvedValueOnce({ success: true });await deleteUserController(req, res);- expect(mockGetCleanupBlockingJobIdsForUser).toHaveBeenCalledWith('user1', 'tenant-1');+ expect(mockGetCleanupBlockingJobIdsForUser).toHaveBeenCalledWith(USER_ID, 'tenant-1');expect(mockAbortJob).toHaveBeenCalledWith('stream-1', {expectedCreatedAt: 123,awaitProviderDrain: true,@@ -339,16 +381,16 @@ describe('deleteUserController - 2FA enforcement', () => {it('deletes owner checkpoints before erasing the account after job records expire', async () => {const req = {- user: { id: 'user1', _id: 'user1', email: '[email protected]', tenantId: 'tenant-1' },+ user: { id: USER_ID, _id: USER_ID, email: '[email protected]', tenantId: 'tenant-1' },body: {},config: { endpoints: { agents: { checkpointer: { ttl: 60 } } } },};const res = createRes();- mockGetUserById.mockResolvedValue({ _id: 'user1', twoFactorEnabled: false });+ mockGetUserById.mockResolvedValue({ _id: USER_ID, twoFactorEnabled: false });await deleteUserController(req, res);- expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith('user1', 'tenant-1', undefined, {+ expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith(USER_ID, 'tenant-1', undefined, {ttl: 60,});expect(deleteOwnedAgentCheckpoints.mock.invocationCallOrder[0]).toBeLessThan(@@ -357,9 +399,9 @@ describe('deleteUserController - 2FA enforcement', () => {});it('preserves code environment records when revocation marking fails after deletion', async () => {- const req = { user: { id: 'user1', _id: 'user1', email: '[email protected]' }, body: {} };+ const req = { user: { id: USER_ID, _id: USER_ID, email: '[email protected]' }, body: {} };const res = createRes();- mockGetUserById.mockResolvedValue({ _id: 'user1', twoFactorEnabled: false });+ mockGetUserById.mockResolvedValue({ _id: USER_ID, twoFactorEnabled: false });mockRevokeUserCodeEnvironmentWorkers.mockRejectedValueOnce(new Error('worker unavailable'));await deleteUserController(req, res);@@ -367,14 +409,14 @@ describe('deleteUserController - 2FA enforcement', () => {expect(res.status).toHaveBeenCalledWith(200);expect(mockBeginAgentTriggerUserDeletion).toHaveBeenCalledTimes(1);expect(mockDeleteMessages).toHaveBeenCalled();- expect(mockDeleteUserById).toHaveBeenCalledWith('user1');+ expect(mockDeleteUserById).toHaveBeenCalledWith(USER_ID);expect(mockDeleteUserCodeEnvironments).not.toHaveBeenCalled();expect(mockCancelAgentTriggerUserPurge).not.toHaveBeenCalled();expect(mockCancelAgentTriggerUserDeletion).not.toHaveBeenCalled();});it('proceeds with deletion when user has no 2FA record', async () => {- const req = { user: { id: 'user1', _id: 'user1', email: '[email protected]' }, body: {} };+ const req = { user: { id: USER_ID, _id: USER_ID, email: '[email protected]' }, body: {} };const res = createRes();mockGetUserById.mockResolvedValue(null);mockBeginAgentTriggerUserDeletion.mockResolvedValueOnce('missing');@@ -386,10 +428,10 @@ describe('deleteUserController - 2FA enforcement', () => {});it('returns error when 2FA is enabled and verification fails with 400', async () => {- const req = { user: { id: 'user1', _id: 'user1' }, body: {} };+ const req = { user: { id: USER_ID, _id: USER_ID }, body: {} };const res = createRes();mockGetUserById.mockResolvedValue({- _id: 'user1',+ _id: USER_ID,twoFactorEnabled: true,totpSecret: 'enc-secret',});@@ -403,11 +445,11 @@ describe('deleteUserController - 2FA enforcement', () => {it('returns 401 when 2FA is enabled and invalid TOTP token provided', async () => {const existingUser = {- _id: 'user1',+ _id: USER_ID,twoFactorEnabled: true,totpSecret: 'enc-secret',};- const req = { user: { id: 'user1', _id: 'user1' }, body: { token: 'wrong' } };+ const req = { user: { id: USER_ID, _id: USER_ID }, body: { token: 'wrong' } };const res = createRes();mockGetUserById.mockResolvedValue(existingUser);mockVerifyOTPOrBackupCode.mockResolvedValue({@@ -430,12 +472,12 @@ describe('deleteUserController - 2FA enforcement', () => {it('returns 401 when 2FA is enabled and invalid backup code provided', async () => {const existingUser = {- _id: 'user1',+ _id: USER_ID,twoFactorEnabled: true,totpSecret: 'enc-secret',backupCodes: [],};- const req = { user: { id: 'user1', _id: 'user1' }, body: { backupCode: 'bad-code' } };+ const req = { user: { id: USER_ID, _id: USER_ID }, body: { backupCode: 'bad-code' } };const res = createRes();mockGetUserById.mockResolvedValue(existingUser);mockVerifyOTPOrBackupCode.mockResolvedValue({@@ -457,12 +499,12 @@ describe('deleteUserController - 2FA enforcement', () => {it('deletes account when valid TOTP token provided with 2FA enabled', async () => {const existingUser = {- _id: 'user1',+ _id: USER_ID,twoFactorEnabled: true,totpSecret: 'enc-secret',};const req = {- user: { id: 'user1', _id: 'user1', email: '[email protected]' },+ user: { id: USER_ID, _id: USER_ID, email: '[email protected]' },body: { token: '123456' },};const res = createRes();@@ -483,13 +525,13 @@ describe('deleteUserController - 2FA enforcement', () => {it('deletes account when valid backup code provided with 2FA enabled', async () => {const existingUser = {- _id: 'user1',+ _id: USER_ID,twoFactorEnabled: true,totpSecret: 'enc-secret',backupCodes: [{ codeHash: 'h1', used: false }],};const req = {- user: { id: 'user1', _id: 'user1', email: '[email protected]' },+ user: { id: USER_ID, _id: USER_ID, email: '[email protected]' },body: { backupCode: 'valid-code' },};const res = createRes();diff --git a/api/server/controllers/__tests__/deleteUserMcpServers.spec.js b/api/server/controllers/__tests__/deleteUserMcpServers.spec.jsindex 195de09538..c2a17ea11a 100644--- a/api/server/controllers/__tests__/deleteUserMcpServers.spec.js+++ b/api/server/controllers/__tests__/deleteUserMcpServers.spec.js@@ -4,7 +4,14 @@ const mockInvalidateCachedTools = jest.fn();jest.mock('~/config', () => ({getMCPManager: (...args) => mockGetMCPManager(...args),getFlowStateManager: jest.fn(),- getMCPServersRegistry: 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', () => ({diff --git a/api/server/controllers/__tests__/deleteUserResourceCoverage.spec.js b/api/server/controllers/__tests__/deleteUserResourceCoverage.spec.jsindex a0806d6e3c..ac7d6636bf 100644--- a/api/server/controllers/__tests__/deleteUserResourceCoverage.spec.js+++ b/api/server/controllers/__tests__/deleteUserResourceCoverage.spec.js@@ -15,7 +15,7 @@ const HANDLED_RESOURCE_TYPES = {[ResourceType.CODE_ENVIRONMENT]: 'deleteUserCodeEnvironments',[ResourceType.REMOTE_AGENT]: 'deleteUserAgents',[ResourceType.PROMPTGROUP]: 'deleteUserPrompts',- [ResourceType.MCPSERVER]: 'deleteUserMcpServers',+ [ResourceType.MCPSERVER]: 'deleteUserMCPServers',[ResourceType.SKILL]: 'deleteUserSkills',[ResourceType.SHARED_LINK]: 'deleteAllSharedLinksWithCleanup',};@@ -33,7 +33,13 @@ describe('deleteUserController - resource type coverage guard', () => {let controllerSource;beforeAll(() => {- controllerSource = fs.readFileSync(path.resolve(__dirname, '../UserController.js'), 'utf-8');+ /** The controller delegates the data cascade to the shared erasure service. */+ controllerSource = [+ path.resolve(__dirname, '../UserController.js'),+ path.resolve(__dirname, '../../../../packages/api/src/user/erasure.ts'),+ ]+ .map((file) => fs.readFileSync(file, 'utf-8'))+ .join('\n');});test('every ResourceType must have a documented cleanup handler or explicit exclusion', () => {diff --git a/api/server/controllers/__tests__/maybeUninstallOAuthMCP.spec.js b/api/server/controllers/__tests__/maybeUninstallOAuthMCP.spec.jsindex 53c36b7719..2ec6075d18 100644--- a/api/server/controllers/__tests__/maybeUninstallOAuthMCP.spec.js+++ b/api/server/controllers/__tests__/maybeUninstallOAuthMCP.spec.js@@ -157,6 +157,8 @@ jest.mock('~/models', () => ({removeUserFromAllGroups: jest.fn(),deleteAclEntries: jest.fn(),getSoleOwnedResourceIds: jest.fn().mockResolvedValue([]),+ findUserErasableMCPServers: jest.fn().mockResolvedValue([]),+ deleteMCPServersWithAcl: jest.fn(),}));const { maybeUninstallOAuthMCP } = require('~/server/controllers/UserController');diff --git a/config/__tests__/delete-user.spec.js b/config/__tests__/delete-user.spec.jsindex 3ea21b63e8..92cb7f04eb 100644--- a/config/__tests__/delete-user.spec.js+++ b/config/__tests__/delete-user.spec.js@@ -1,3 +1,6 @@+const { AsyncLocalStorage } = require('async_hooks');++const mockTenantStorage = new AsyncLocalStorage();const mockModelRegistry = {};const mockModelFor = (name) => {if (!mockModelRegistry[name]) {@@ -31,6 +34,12 @@ const mockSilentExit = jest.fn();const mockAskQuestion = jest.fn();const mockGetAppConfig = jest.fn();const mockRevokeUserCodeEnvironmentWorkers = jest.fn();+const mockEraseUserData = jest.fn();+const mockProcessDeleteRequest = jest.fn();+const mockInvalidateCachedTools = jest.fn();+const mockInitializeFileStorage = jest.fn();+const mockOpenCheckpointDeletion = jest.fn();+const mockDeleteAllSharedLinksWithCleanup = jest.fn();jest.mock('../connect', () => jest.fn(async () => undefined));jest.mock('mongoose', () => ({ disconnect: jest.fn(async () => undefined) }));@@ -38,6 +47,7 @@ jest.mock('@librechat/data-schemas', () => ({createModels: () => new Proxy({}, { get: (_target, prop) => mockModelFor(prop) }),createMethods: () => mockMethods,runAsSystem: (operation) => operation(),+ tenantStorage: mockTenantStorage,}));jest.mock('@librechat/api', () => ({waitForKeyvRedisClient: jest.fn(async () => undefined),@@ -50,11 +60,21 @@ jest.mock('@librechat/api', () => ({destroy: (...args) => mockDestroy(...args),},revokeUserCodeEnvironmentWorkers: (...args) => mockRevokeUserCodeEnvironmentWorkers(...args),+ eraseUserData: (...args) => mockEraseUserData(...args),+ initializeFileStorage: (...args) => mockInitializeFileStorage(...args),+ openCheckpointDeletion: mockOpenCheckpointDeletion,+ deleteAllSharedLinksWithCleanup: mockDeleteAllSharedLinksWithCleanup,}));jest.mock('~/cache/getLogStores', () => jest.fn());jest.mock('~/server/services/Config', () => ({getAppConfig: (...args) => mockGetAppConfig(...args),}));+jest.mock('~/server/services/Files/process', () => ({+ processDeleteRequest: (...args) => mockProcessDeleteRequest(...args),+}));+jest.mock('~/server/services/Config/getCachedTools', () => ({+ invalidateCachedTools: (...args) => mockInvalidateCachedTools(...args),+}));jest.mock('../helpers', () => ({...jest.requireActual('../helpers'),askQuestion: mockAskQuestion,@@ -94,6 +114,7 @@ describe('Delete user CLI', () => {mockModelFor('User').findOne.mockResolvedValue({_id: { toString: () => USER_ID },email: '[email protected]',+ role: 'USER',tenantId: 'tenant-1',});mockMethods.beginAgentTriggerUserDeletion.mockReset().mockResolvedValue('acquired');@@ -113,6 +134,10 @@ describe('Delete user CLI', () => {mockDestroy.mockReset().mockResolvedValue(undefined);mockGetAppConfig.mockReset().mockResolvedValue({});mockRevokeUserCodeEnvironmentWorkers.mockReset().mockResolvedValue(0);+ mockEraseUserData.mockReset().mockResolvedValue(undefined);+ mockProcessDeleteRequest.mockReset().mockResolvedValue({ deletedFileIds: [] });+ mockInvalidateCachedTools.mockReset().mockResolvedValue(undefined);+ mockInitializeFileStorage.mockReset();mockAskQuestion.mockReset().mockResolvedValueOnce('y').mockResolvedValueOnce('n');});@@ -160,10 +185,9 @@ describe('Delete user CLI', () => {expect(mockGetCleanupBlockingJobIdsForUser).toHaveBeenCalledWith(USER_ID, 'tenant-1');expect(mockAbortJob).toHaveBeenCalledWith('stream-1', { awaitProviderDrain: true });expect(mockAbortJob.mock.invocationCallOrder[0]).toBeLessThan(- mockModelFor('Message').deleteMany.mock.invocationCallOrder[0],+ mockEraseUserData.mock.invocationCallOrder[0],);- expect(mockMethods.deleteSchedulesByUser).toHaveBeenCalledWith(USER_ID);- expect(mockMethods.deleteSchedulesByUser.mock.invocationCallOrder[0]).toBeLessThan(+ expect(mockEraseUserData.mock.invocationCallOrder[0]).toBeLessThan(mockMethods.deleteUserById.mock.invocationCallOrder[0],);});@@ -175,7 +199,7 @@ describe('Delete user CLI', () => {expect(await runCli()).toBe(1);- expect(mockModelFor('Message').deleteMany).not.toHaveBeenCalled();+ expect(mockEraseUserData).not.toHaveBeenCalled();expect(mockMethods.deleteSchedulesByUser).not.toHaveBeenCalled();expect(mockMethods.deleteUserById).not.toHaveBeenCalled();const deletionFence = mockMethods.beginAgentTriggerUserDeletion.mock.calls[0][1];@@ -206,7 +230,7 @@ describe('Delete user CLI', () => {it('never restores schedules after a committed deletion', async () => {expect(await runCli()).toBe(0);- expect(mockMethods.deleteSchedulesByUser).toHaveBeenCalledWith(USER_ID);+ expect(mockEraseUserData).toHaveBeenCalled();expect(mockMethods.restoreUserSchedulesFromDeletion).not.toHaveBeenCalled();});@@ -234,13 +258,144 @@ describe('Delete user CLI', () => {expect(mockMethods.deleteUserCodeEnvironments).not.toHaveBeenCalled();});+ it('erases account data through the shared cascade before committing the user', async () => {+ const userConfig = { endpoints: { agents: { checkpointer: { ttl: 60 } } } };+ mockGetAppConfig.mockImplementation(async (options) => (options?.baseOnly ? {} : userConfig));++ expect(await runCli()).toBe(0);++ expect(mockGetAppConfig).toHaveBeenCalledWith({+ role: 'USER',+ userId: USER_ID,+ tenantId: 'tenant-1',+ });+ expect(mockInitializeFileStorage).toHaveBeenCalledWith(userConfig);+ expect(mockEraseUserData).toHaveBeenCalledTimes(1);+ const [params, deps] = mockEraseUserData.mock.calls[0];+ expect(params).toEqual({+ userId: USER_ID,+ tenantId: 'tenant-1',+ checkpointer: { ttl: 60 },+ keepTransactions: true,+ });+ expect(deps).toEqual(+ expect.objectContaining({+ ...mockMethods,+ openCheckpointDeletion: mockOpenCheckpointDeletion,+ deleteSharedLinks: expect.any(Function),+ }),+ );+ await deps.deleteSharedLinks(USER_ID);+ expect(mockDeleteAllSharedLinksWithCleanup).toHaveBeenCalledWith(USER_ID, {+ awaitCleanup: true,+ });++ const files = [{ file_id: 'file-1' }];+ await deps.deleteStoredFiles(files);+ expect(mockProcessDeleteRequest).toHaveBeenCalledWith({+ req: expect.objectContaining({+ user: expect.objectContaining({ id: USER_ID, tenantId: 'tenant-1' }),+ body: {},+ config: userConfig,+ }),+ files,+ });+ await deps.invalidateMCPServerTools('server-1');+ expect(mockInvalidateCachedTools).toHaveBeenCalledWith({+ userId: USER_ID,+ serverName: 'server-1',+ });++ expect(mockEraseUserData.mock.invocationCallOrder[0]).toBeLessThan(+ mockMethods.deleteUserById.mock.invocationCallOrder[0],+ );+ });++ it('keeps file and MCP id-keyed cleanup in the deleted user tenant scope', async () => {+ const scopes = {};+ mockMethods.findMCPServerOAuthTokenUserIds = jest.fn(async () => {+ scopes.tokens = mockTenantStorage.getStore();+ return [];+ });+ mockProcessDeleteRequest.mockImplementation(async () => {+ scopes.files = mockTenantStorage.getStore();+ });+ mockEraseUserData.mockImplementation(async (_params, deps) => {+ scopes.cascade = mockTenantStorage.getStore();+ await deps.findMCPServerOAuthTokenUserIds('server-1', 'tenant-1');+ await deps.deleteStoredFiles([{ file_id: 'file-1' }]);+ });++ expect(await runCli()).toBe(0);++ expect(scopes.cascade).toBeUndefined();+ expect(scopes.files).toEqual({ tenantId: 'tenant-1', userId: USER_ID });+ expect(scopes.tokens).toEqual({ tenantId: 'tenant-1', userId: USER_ID });+ expect(mockMethods.findMCPServerOAuthTokenUserIds).toHaveBeenCalledWith('server-1', 'tenant-1');+ });++ it('supplies shared-user MCP OAuth cleanup to the cascade', async () => {+ expect(await runCli()).toBe(0);++ const [, deps] = mockEraseUserData.mock.calls[0];+ expect(deps.mcpOAuth).toEqual({+ getServerConfig: expect.any(Function),+ getUserPrincipals: expect.any(Function),+ resolveAllowlists: expect.any(Function),+ invalidateUserTools: expect.any(Function),+ uninstallOAuthMCP: expect.any(Function),+ });+ mockMethods.findMCPServerByObjectId = jest.fn(async () => ({ config: { type: 'sse' } }));+ expect(await deps.mcpOAuth.getServerConfig('server-1', 'server-id-1')).toEqual({ type: 'sse' });+ expect(mockMethods.findMCPServerByObjectId).toHaveBeenCalledWith('server-id-1');+ mockMethods.getUserById = jest.fn(async () => ({ role: 'VIEWER' }));+ mockGetAppConfig.mockImplementation(async (options) =>+ options?.userId === 'viewer-1' ? { mcpSettings: { allowedDomains: ['viewer.example'] } } : {},+ );+ expect(await deps.mcpOAuth.resolveAllowlists('viewer-1')).toEqual({+ allowedDomains: ['viewer.example'],+ allowedAddresses: undefined,+ });+ expect(mockGetAppConfig).toHaveBeenCalledWith({+ role: 'VIEWER',+ userId: 'viewer-1',+ tenantId: 'tenant-1',+ });+ await deps.mcpOAuth.invalidateUserTools('viewer-1', 'server-1');+ expect(mockInvalidateCachedTools).toHaveBeenCalledWith({+ userId: 'viewer-1',+ serverName: 'server-1',+ });+ });++ it('erases the transaction ledger when the operator confirms it', async () => {+ mockAskQuestion.mockReset().mockResolvedValueOnce('y').mockResolvedValueOnce('y');++ expect(await runCli()).toBe(0);++ expect(mockEraseUserData.mock.calls[0][0]).toEqual(+ expect.objectContaining({ keepTransactions: false }),+ );+ });++ it('keeps the user and releases both fences when the cascade fails', async () => {+ mockEraseUserData.mockRejectedValueOnce(new Error('storage unavailable'));++ expect(await runCli()).toBe(1);++ expect(mockMethods.deleteUserById).not.toHaveBeenCalled();+ const deletionFence = mockMethods.beginAgentTriggerUserDeletion.mock.calls[0][1];+ expect(mockMethods.restoreUserSchedulesFromDeletion).toHaveBeenCalled();+ expect(mockMethods.cancelAgentTriggerUserDeletion).toHaveBeenCalledWith(USER_ID, deletionFence);+ });+it('deletes nothing and releases both fences when provider drain fails', async () => {mockGetCleanupBlockingJobIdsForUser.mockResolvedValueOnce(['stream-1']);mockAbortJob.mockRejectedValueOnce(new Error('provider drain failed'));expect(await runCli()).toBe(1);- expect(mockModelFor('Message').deleteMany).not.toHaveBeenCalled();+ expect(mockEraseUserData).not.toHaveBeenCalled();expect(mockMethods.deleteSchedulesByUser).not.toHaveBeenCalled();expect(mockMethods.deleteUserById).not.toHaveBeenCalled();const deletionFence = mockMethods.beginAgentTriggerUserDeletion.mock.calls[0][1];diff --git a/config/delete-user.js b/config/delete-user.jsindex 5c678b8f25..e7e161e00c 100644--- a/config/delete-user.js+++ b/config/delete-user.js@@ -4,42 +4,33 @@const path = require('path');const mongoose = require('mongoose');const { randomUUID } = require('node:crypto');-const { createModels, createMethods, runAsSystem } = require('@librechat/data-schemas');const {- Key,- User,- File,- Agent,- Token,- Group,- Action,- Preset,- Prompt,- Balance,- Message,- Session,- Passkey,- AclEntry,- ToolCall,- Assistant,- SharedLink,- PluginAuth,- MemoryEntry,- PromptGroup,- AgentApiKey,- Transaction,- Conversation,- ConversationTag,-} = createModels(mongoose);+ createModels,+ createMethods,+ runAsSystem,+ tenantStorage,+} = require('@librechat/data-schemas');+const { User } = createModels(mongoose);require('module-alias')({ base: path.resolve(__dirname, '..', 'api') });const {+ eraseUserData,GenerationJobManager,createStreamServices,- revokeUserCodeEnvironmentWorkers,+ initializeFileStorage,+ openCheckpointDeletion,waitForKeyvRedisClient,+ MCPOAuthHandler,+ MCPTokenStorage,+ cleanupMCPServerOAuth,+ revokeUserCodeEnvironmentWorkers,+ deleteAllSharedLinksWithCleanup,} = require('@librechat/api');+const { CacheKeys } = require('librechat-data-provider');+const { getFlowStateManager } = require('~/config');const getLogStores = require('~/cache/getLogStores');const { getAppConfig } = require('~/server/services/Config');+const { processDeleteRequest } = require('~/server/services/Files/process');+const { invalidateCachedTools } = require('~/server/services/Config/getCachedTools');const { askQuestion, silentExit } = require('./helpers');const connect = require('./connect');@@ -199,42 +190,96 @@ async function gracefulExit(code = 0) {const deletionAppConfig = await getAppConfig({ baseOnly: true });- // 5) Build and run deletion tasks- const tasks = [- Action.deleteMany({ user: uid }),- Agent.deleteMany({ author: uid }),- AgentApiKey.deleteMany({ user: uid }),- Assistant.deleteMany({ user: uid }),- Balance.deleteMany({ user: uid }),- ConversationTag.deleteMany({ user: uid }),- Conversation.deleteMany({ user: uid }),- Message.deleteMany({ user: uid }),- File.deleteMany({ user: uid }),- Key.deleteMany({ userId: uid }),- MemoryEntry.deleteMany({ userId: uid }),- PluginAuth.deleteMany({ userId: uid }),- Prompt.deleteMany({ author: uid }),- PromptGroup.deleteMany({ author: uid }),- Preset.deleteMany({ user: uid }),- Session.deleteMany({ user: uid }),- Passkey.deleteMany({ user: uid }),- SharedLink.deleteMany({ user: uid }),- ToolCall.deleteMany({ user: uid }),- Token.deleteMany({ userId: uid }),- AclEntry.deleteMany({ principalId: user._id }),- ];-- if (deleteTx) {- tasks.push(Transaction.deleteMany({ user: uid }));- }-- await Promise.all(tasks);- await runAsSystem(() => methods.deleteSchedulesByUser(uid));-- // 6) Remove user from all groups- await Group.updateMany({ memberIds: uid }, { $pullAll: { memberIds: [uid] } });+ // 5) Erase account-owned data through the same cascade as account self-deletion+ const userAppConfig = await getAppConfig({+ role: user.role,+ userId: uid,+ tenantId: user.tenantId,+ });+ initializeFileStorage(userAppConfig);+ const fileRequest = {+ user: { id: uid, _id: user._id, role: user.role, tenantId: user.tenantId },+ /** Assistants client setup reads these Express request fields. */+ baseUrl: '',+ query: {},+ body: {},+ config: userAppConfig,+ };+ /** ID-keyed cleanup (file metadata, MCP lookups) stays in the deleted user's tenant. */+ const runInUserTenant = (operation) =>+ user.tenantId+ ? tenantStorage.run({ tenantId: user.tenantId, userId: uid }, operation)+ : operation();+ await runAsSystem(() =>+ eraseUserData(+ {+ userId: uid,+ tenantId: user.tenantId,+ checkpointer: userAppConfig?.endpoints?.agents?.checkpointer,+ keepTransactions: !deleteTx,+ },+ {+ ...methods,+ openCheckpointDeletion,+ deleteSharedLinks: (id) => deleteAllSharedLinksWithCleanup(id, { awaitCleanup: true }),+ deleteStoredFiles: (files) =>+ runInUserTenant(async () => processDeleteRequest({ req: fileRequest, files })),+ /** Server names are unique per tenant, so these lookups stay in the deleted user's tenant. */+ findMCPServerOAuthTokenUserIds: (serverName, tenantId) =>+ runInUserTenant(async () =>+ methods.findMCPServerOAuthTokenUserIds(serverName, tenantId),+ ),+ findMCPServerViewerEntries: (serverId) =>+ runInUserTenant(async () => methods.findMCPServerViewerEntries(serverId)),+ invalidateMCPServerTools: (serverName) =>+ invalidateCachedTools({ userId: uid, serverName }),+ /** The CLI has no MCP registry or live connections, so shared users get local token and cache cleanup. */+ mcpOAuth: {+ getUserPrincipals: (candidateId) => methods.getUserPrincipals({ userId: candidateId }),+ /** Looked up by its unique object id, so a server stamped before tenancy is still found. */+ getServerConfig: async (_serverName, serverId) =>+ (await methods.findMCPServerByObjectId(serverId))?.config,+ resolveAllowlists: (candidateId) =>+ runInUserTenant(async () => {+ const candidate = await methods.getUserById(candidateId, 'role');+ const candidateConfig = await getAppConfig({+ role: candidate?.role,+ userId: candidateId,+ tenantId: user.tenantId,+ });+ return {+ allowedDomains: candidateConfig?.mcpSettings?.allowedDomains,+ allowedAddresses: candidateConfig?.mcpSettings?.allowedAddresses,+ };+ }),+ invalidateUserTools: (candidateId, serverName) =>+ runInUserTenant(async () =>+ invalidateCachedTools({ userId: candidateId, serverName }),+ ),+ uninstallOAuthMCP: (candidateId, pluginKey, cleanupConfig, serverConfig) =>+ runInUserTenant(async () =>+ cleanupMCPServerOAuth({+ userId: candidateId,+ pluginKey,+ appConfig: cleanupConfig,+ serverConfigOverride: serverConfig,+ dependencies: {+ flowManager: getFlowStateManager(getLogStores(CacheKeys.FLOWS)),+ oauthHandler: MCPOAuthHandler,+ tokenStorage: MCPTokenStorage,+ findToken: methods.findToken,+ deleteTokens: methods.deleteTokens,+ getServerConfig: async () => undefined,+ isRegisteredOAuthServer: async () => false,+ },+ }),+ ),+ },+ },+ ),+ );- // 7) Finally delete the user document itself+ // 6) Finally delete the user document itselfconst deletedUser = await runAsSystem(() => methods.deleteUserById(uid));if (deletedUser.deletedCount !== 1) {throw new Error('User disappeared before account deletion could commit');diff --git a/e2e/specs/mock/scenarios/delete-user-cli.spec.ts b/e2e/specs/mock/scenarios/delete-user-cli.spec.tsnew file mode 100644index 0000000000..9282f5b86c--- /dev/null+++ b/e2e/specs/mock/scenarios/delete-user-cli.spec.ts@@ -0,0 +1,261 @@+import fs from 'fs';+import path from 'path';+import { ObjectId } from 'mongodb';+import { expect, test } from '@playwright/test';+import { spawn } from 'node:child_process';+import { randomInt, randomUUID } from 'node:crypto';+import type { APIRequestContext } from '@playwright/test';+import type { Db } from 'mongodb';+import { withMongo } from '../db';++const PASSWORD = 'Erasure-Scenario-1!';+const REPO_ROOT = path.resolve(__dirname, '../../../..');+const NO_AUTO_INDEX = path.join(__dirname, 'no-auto-index.cjs');++function getMongoUri(): string {+ const runtimeEnvPath =+ process.env.E2E_RUNTIME_ENV_PATH ??+ path.resolve(__dirname, '../../.test-results/runtime-env.json');+ try {+ const env = JSON.parse(fs.readFileSync(runtimeEnvPath, 'utf8')) as { MONGO_URI?: string };+ if (env.MONGO_URI) {+ return env.MONGO_URI;+ }+ } catch {+ /* fall through to env */+ }+ return process.env.MONGO_URI ?? 'mongodb://127.0.0.1:27017/LibreChat-e2e';+}++/** A seeded account and the upload it owns on local storage. */+interface Seeded {+ userId: string;+ uploadPath: string;+}++async function register(request: APIRequestContext, prefix: string): Promise<string> {+ const email = `${prefix}-${randomUUID().slice(0, 8)}@example.com`;+ const response = await request.post('/api/auth/register', {+ data: { email, name: 'Erasure Scenario', password: PASSWORD, confirm_password: PASSWORD },+ });+ expect(response.ok()).toBeTruthy();+ return email;+}++async function seedOwnedData(email: string): Promise<Seeded> {+ return withMongo(async (db) => {+ const user = await db.collection('users').findOne({ email });+ if (!user) {+ throw new Error(`seed: user ${email} not found`);+ }+ const userObjectId = user._id as ObjectId;+ const userId = userObjectId.toString();+ const fileName = `${randomUUID()}.txt`;+ const uploadDir = path.join(REPO_ROOT, 'uploads', userId);+ fs.mkdirSync(uploadDir, { recursive: true });+ const uploadPath = path.join(uploadDir, fileName);+ fs.writeFileSync(uploadPath, 'erasure scenario upload');++ await Promise.all([+ db.collection('files').insertOne({+ user: userObjectId,+ file_id: randomUUID(),+ filename: fileName,+ filepath: `/uploads/${userId}/${fileName}`,+ source: 'local',+ type: 'text/plain',+ bytes: 23,+ object: 'file',+ usage: 0,+ }),+ db.collection('agentapikeys').insertOne({+ userId: userObjectId,+ name: 'scenario key',+ keyHash: randomUUID(),+ keyPrefix: 'sk-scn',+ }),+ db.collection('mcpservers').insertOne({+ serverName: `erasure-${userId}`,+ author: userObjectId,+ config: { type: 'streamable-http', url: 'https://mcp.example.com/mcp' },+ }),+ db+ .collection('toolfavorites')+ .insertOne({ user: userObjectId, itemType: 'tool', itemId: 'web' }),+ db.collection('chatprojects').insertOne({ user: userId, name: `project-${userId}` }),+ db+ .collection('transactions')+ .insertOne({ user: userObjectId, tokenType: 'prompt', rawAmount: -1 }),+ ]);+ return { userId, uploadPath };+ });+}++/** Removes the bystander's upload directory so local storage does not grow across runs. */+function removeUploads(seeded: Seeded | undefined) {+ if (seeded) {+ fs.rmSync(path.dirname(seeded.uploadPath), { recursive: true, force: true });+ }+}++async function countOwned(db: Db, userId: string): Promise<Record<string, number>> {+ const userObjectId = new ObjectId(userId);+ const [users, files, agentApiKeys, mcpServers, toolFavorites, chatProjects, transactions] =+ await Promise.all([+ db.collection('users').countDocuments({ _id: userObjectId }),+ db.collection('files').countDocuments({ user: userObjectId }),+ db.collection('agentapikeys').countDocuments({ userId: userObjectId }),+ db.collection('mcpservers').countDocuments({ author: userObjectId }),+ db.collection('toolfavorites').countDocuments({ user: userObjectId }),+ db.collection('chatprojects').countDocuments({ user: userId }),+ db.collection('transactions').countDocuments({ user: userObjectId }),+ ]);+ return { users, files, agentApiKeys, mcpServers, toolFavorites, chatProjects, transactions };+}++const ERASED = {+ users: 0,+ files: 0,+ agentApiKeys: 0,+ mcpServers: 0,+ toolFavorites: 0,+ chatProjects: 0,+};+const KEPT = {+ users: 1,+ files: 1,+ agentApiKeys: 1,+ mcpServers: 1,+ toolFavorites: 1,+ chatProjects: 1,+ transactions: 1,+};++/**+ * Drives the interactive delete CLI the way an operator would: every confirmation is answered+ * "y" except the transaction-history prompt, which takes `deleteTransactions`.+ */+function runDeleteCli(+ email: string,+ deleteTransactions: boolean,+): Promise<{ code: number | null; stdout: string; stderr: string }> {+ const child = spawn(process.execPath, [path.join(REPO_ROOT, 'config/delete-user.js'), email], {+ cwd: REPO_ROOT,+ env: {+ ...process.env,+ MONGO_URI: getMongoUri(),+ /** The harness server already built the indexes; skip the module-scope rebuild. */+ NODE_OPTIONS: process.env.NODE_OPTIONS+ ? `${process.env.NODE_OPTIONS} --require ${NO_AUTO_INDEX}`+ : `--require ${NO_AUTO_INDEX}`,+ },+ stdio: ['pipe', 'pipe', 'pipe'],+ });+ let stdout = '';+ let answered = 0;+ child.stdout?.on('data', (chunk: Buffer) => {+ stdout += chunk.toString();+ const prompts = stdout.split('(y/N)').length - 1;+ while (answered < prompts) {+ const preceding = stdout.split('(y/N)')[answered];+ const isLedgerPrompt = preceding.includes('transaction history');+ child.stdin?.write(isLedgerPrompt && !deleteTransactions ? 'n\n' : 'y\n');+ answered += 1;+ }+ });+ let stderr = '';+ child.stderr?.on('data', (chunk: Buffer) => (stderr += chunk.toString()));+ return new Promise((resolve, reject) => {+ const timer = setTimeout(() => {+ child.kill('SIGKILL');+ reject(new Error(`delete CLI timed out; stdout: ${stdout.slice(-400)}`));+ }, 90_000);+ child.on('error', (error) => {+ clearTimeout(timer);+ reject(error);+ });+ child.on('close', (code) => {+ clearTimeout(timer);+ child.stdin?.end();+ resolve({ code, stdout, stderr });+ });+ });+}++test.describe('account erasure', () => {+ test.describe.configure({ mode: 'serial' });++ for (const [deleteTransactions, scenario] of [+ [true, '@scenario:cli-delete-user-erases-owned-data'],+ [false, '@scenario:cli-delete-user-keeps-declined-ledger'],+ ] as const) {+ test(`the delete-user CLI erases the account's data ${deleteTransactions ? 'and' : 'but keeps'} its ledger ${scenario}`, async ({+ playwright,+ baseURL,+ }) => {+ test.setTimeout(150_000);+ const request = await playwright.request.newContext({ baseURL });+ let kept: Seeded | undefined;+ try {+ const email = await register(request, 'cli-erase');+ const bystander = await register(request, 'cli-keep');+ const target = await seedOwnedData(email);+ kept = await seedOwnedData(bystander);++ const result = await runDeleteCli(email, deleteTransactions);+ expect(result.code, result.stderr.slice(-800)).toBe(0);+ expect(result.stdout).toContain('Successfully deleted user');++ await withMongo(async (db) => {+ expect(await countOwned(db, target.userId)).toEqual({+ ...ERASED,+ transactions: deleteTransactions ? 0 : 1,+ });+ expect(await countOwned(db, kept.userId)).toEqual(KEPT);+ });+ expect(fs.existsSync(target.uploadPath)).toBe(false);+ expect(fs.existsSync(kept.uploadPath)).toBe(true);+ } finally {+ removeUploads(kept);+ await request.dispose();+ }+ });+ }++ test('self-service deletion erases the same stores as the CLI @scenario:self-delete-erases-owned-data', async ({+ playwright,+ baseURL,+ }) => {+ const request = await playwright.request.newContext({+ baseURL,+ extraHTTPHeaders: {+ 'X-Forwarded-For': `127.${randomInt(1, 255)}.${randomInt(1, 255)}.${randomInt(1, 255)}`,+ },+ });+ let kept: Seeded | undefined;+ try {+ const email = await register(request, 'self-erase');+ const bystander = await register(request, 'self-keep');+ const target = await seedOwnedData(email);+ kept = await seedOwnedData(bystander);+ const login = await request.post('/api/auth/login', { data: { email, password: PASSWORD } });+ expect(login.ok()).toBeTruthy();+ const { token } = (await login.json()) as { token: string };++ const deletion = await request.delete('/api/user/delete', {+ headers: { Authorization: `Bearer ${token}` },+ });+ expect(deletion.status()).toBe(200);++ await withMongo(async (db) => {+ expect(await countOwned(db, target.userId)).toEqual({ ...ERASED, transactions: 0 });+ expect(await countOwned(db, kept.userId)).toEqual(KEPT);+ });+ expect(fs.existsSync(target.uploadPath)).toBe(false);+ expect(fs.existsSync(kept.uploadPath)).toBe(true);+ } finally {+ removeUploads(kept);+ await request.dispose();+ }+ });+});diff --git a/packages/api/src/mcp/oauth/cleanup.ts b/packages/api/src/mcp/oauth/cleanup.tsindex a3e1c18e67..45de6c0984 100644--- a/packages/api/src/mcp/oauth/cleanup.ts+++ b/packages/api/src/mcp/oauth/cleanup.ts@@ -25,7 +25,7 @@ interface CleanupConfig {mcpServers?: Record<string, MCPOptions>;}-interface OAuthAclSubject {+export interface OAuthAclSubject {principalType: string;principalId?: { toString(): string } | string | null;}@@ -51,7 +51,7 @@ export async function prepareMCPServerOAuthDeletion({interface CleanupDeletedUsersParams {ownerUserId: string;serverName: string;- serverConfig: MCPOptions;+ serverConfig?: MCPOptions;snapshot: MCPServerOAuthDeletionSnapshot;getTokenUserIds: () => Promise<Array<{ toString(): string } | string>>;getUserPrincipals: (userId: string) => Promise<OAuthAclSubject[]>;@@ -63,7 +63,7 @@ interface CleanupDeletedUsersParams {userId: string,pluginKey: string,appConfig: CleanupConfig,- serverConfig: MCPOptions,+ serverConfig?: MCPOptions,) => Promise<void>;}diff --git a/packages/api/src/shared-links/service.test.ts b/packages/api/src/shared-links/service.test.tsindex 30f425c3c0..e6050465eb 100644--- a/packages/api/src/shared-links/service.test.ts+++ b/packages/api/src/shared-links/service.test.ts@@ -390,4 +390,21 @@ describe('deleteAllSharedLinksWithCleanup', () => {}).lean();expect(aclAfter).toHaveLength(0);});++ test('awaits ACL cleanup and keeps the links when it fails', async () => {+ const link = await createTestLink({ conversationId: 'c1' });+ await grantCreationPermissions(link._id, userId, true);+ const failure = jest.spyOn(AclEntry, 'deleteMany').mockRejectedValueOnce(new Error('acl down'));++ await expect(deleteAllSharedLinksWithCleanup(userId, { awaitCleanup: true })).rejects.toThrow(+ 'acl down',+ );+ failure.mockRestore();++ expect(await SharedLink.countDocuments({ _id: link._id })).toBe(1);++ const result = await deleteAllSharedLinksWithCleanup(userId, { awaitCleanup: true });+ expect(result.deletedCount).toBe(1);+ expect(await AclEntry.countDocuments({ resourceId: link._id })).toBe(0);+ });});diff --git a/packages/api/src/shared-links/service.ts b/packages/api/src/shared-links/service.tsindex 66bf873ab2..2dae3613c5 100644--- a/packages/api/src/shared-links/service.ts+++ b/packages/api/src/shared-links/service.ts@@ -320,13 +320,18 @@ export async function deleteConvoSharedLinksWithCleanup(export async function deleteAllSharedLinksWithCleanup(user: string,+ options: { awaitCleanup?: boolean } = {},): Promise<{ message: string; deletedCount: number }> {const SharedLink = mongoose.models.SharedLink as Model<ISharedLink>;const links = await SharedLink.find({ user }).select('_id').lean();const ids = links.map((l) => l._id);+ if (options.awaitCleanup && ids.length > 0) {+ /** The links identify the ACL resources, so they must outlive a failed cleanup for a retry. */+ await cleanupBulkSharedLinkPermissions(ids);+ }const result = await SharedLink.deleteMany({ user });- if (ids.length > 0) {+ if (!options.awaitCleanup && ids.length > 0) {cleanupBulkSharedLinkPermissions(ids).catch((err) => {logger.error('[deleteAllSharedLinksWithCleanup] ACL cleanup failed', {user,diff --git a/packages/api/src/user/erasure.spec.ts b/packages/api/src/user/erasure.spec.tsnew file mode 100644index 0000000000..9384cf9932--- /dev/null+++ b/packages/api/src/user/erasure.spec.ts@@ -0,0 +1,447 @@+import mongoose from 'mongoose';+import { MongoMemoryServer } from 'mongodb-memory-server';+import { ResourceType, PrincipalType } from 'librechat-data-provider';+import { createModels, createMethods, tenantStorage } from '@librechat/data-schemas';+import type { CheckpointDeletion } from '~/agents/checkpoints/deletion';+import type { UserErasureDeps } from './erasure';+import { deleteAllSharedLinksWithCleanup } from '~/shared-links/service';+import { eraseUserData } from './erasure';++const OWNER_BITS = 15;++let mongo: MongoMemoryServer;+let methods: ReturnType<typeof createMethods>;++beforeAll(async () => {+ mongo = await MongoMemoryServer.create();+ createModels(mongoose);+ await mongoose.connect(mongo.getUri());+ methods = createMethods(mongoose);+});++afterAll(async () => {+ await mongoose.disconnect();+ await mongo.stop();+});++afterEach(async () => {+ await mongoose.connection.db?.dropDatabase();+});++const model = (name: string) => mongoose.models[name].collection;+const count = (name: string, filter: Record<string, unknown>) => model(name).countDocuments(filter);++async function seedUser(userId: mongoose.Types.ObjectId) {+ const user = userId.toString();+ const skillId = new mongoose.Types.ObjectId();+ const mcpServerId = new mongoose.Types.ObjectId();+ const legacyServerId = new mongoose.Types.ObjectId();++ await model('Skill').insertOne({ _id: skillId, name: `skill-${user}`, author: userId });+ await model('SkillFile').insertOne({ skillId, relativePath: 'notes.md', author: userId });+ await methods.grantPermission(+ PrincipalType.USER,+ userId,+ ResourceType.SKILL,+ skillId,+ OWNER_BITS,+ userId,+ );+ await model('MCPServer').insertMany([+ { _id: mcpServerId, serverName: `acl-${user}`, author: userId },+ { _id: legacyServerId, serverName: `legacy-${user}`, author: userId },+ ]);+ await methods.grantPermission(+ PrincipalType.USER,+ userId,+ ResourceType.MCPSERVER,+ mcpServerId,+ OWNER_BITS,+ userId,+ );+ await model('SharedLink').insertOne({ user, conversationId: `convo-${user}`, shareId: user });+ await model('File').insertMany([+ { user: userId, file_id: `file-a-${user}`, filepath: '/uploads/a', source: 'local' },+ { user: userId, file_id: `file-b-${user}`, filepath: '/uploads/b', source: 's3' },+ ]);+ await model('Conversation').insertOne({ user, conversationId: `convo-${user}` });+ await model('Transaction').insertOne({ user: userId, tokenType: 'prompt', rawAmount: -1 });+ await model('ToolFavorite').insertOne({ user: userId, itemType: 'tool', itemId: 'web' });+ await model('ChatProject').insertOne({ user, name: `project-${user}` });+ await model('AgentQueuedTurn').insertOne({ user: userId, conversationId: `convo-${user}` });+ await model('AgentQueuedTurnSequence').insertOne({+ user: userId,+ conversationId: `convo-${user}`,+ });+ await model('RefreshTokenBridge').insertOne({+ userId: user,+ tenantId: 'tenant-1',+ oldRefreshTokenHash: `hash-${user}`,+ encryptedNewRefreshToken: 'encrypted',+ });+ return { skillId, mcpServerId, legacyServerId };+}++function createDeps() {+ const order: string[] = [];+ const checkpointDeletion: CheckpointDeletion = {+ conversationIds: () => [],+ remember: jest.fn(async () => {+ order.push('remember');+ }),+ cleanup: jest.fn(async () => {+ order.push('cleanup');+ }),+ acknowledge: jest.fn(async () => {+ order.push('acknowledge');+ }),+ };+ const deps: UserErasureDeps = {+ ...methods,+ openCheckpointDeletion: jest.fn(async () => checkpointDeletion),+ deleteSharedLinks: deleteAllSharedLinksWithCleanup,+ deleteStoredFiles: jest.fn(async () => {+ order.push('deleteStoredFiles');+ }),+ invalidateMCPServerTools: jest.fn(async () => undefined),+ disconnectMCPServer: jest.fn(async () => undefined),+ };+ return { deps, checkpointDeletion, order };+}++describe('eraseUserData', () => {+ it('clears skills, MCP servers, shared links, file objects and checkpoints', async () => {+ const userId = new mongoose.Types.ObjectId();+ const otherId = new mongoose.Types.ObjectId();+ const user = userId.toString();+ const { skillId } = await seedUser(userId);+ const other = await seedUser(otherId);+ const { deps, checkpointDeletion, order } = createDeps();++ await eraseUserData({ userId: user, tenantId: 'tenant-1', checkpointer: { ttl: 60 } }, deps);++ expect(deps.openCheckpointDeletion).toHaveBeenCalledWith(user, 'tenant-1', undefined, {+ ttl: 60,+ });+ expect(checkpointDeletion.remember).toHaveBeenCalledWith([`convo-${user}`]);+ expect(order.slice(0, 3)).toEqual(['remember', 'cleanup', 'acknowledge']);+ expect(await count('Conversation', { user })).toBe(0);++ expect(deps.deleteStoredFiles).toHaveBeenCalledTimes(1);+ const storedFiles = (deps.deleteStoredFiles as jest.Mock).mock.calls[0][0];+ expect(storedFiles.map((file: { file_id: string }) => file.file_id).sort()).toEqual([+ `file-a-${user}`,+ `file-b-${user}`,+ ]);+ expect(await count('File', { user: userId })).toBe(0);++ expect(await count('Skill', { _id: skillId })).toBe(0);+ expect(await count('SkillFile', { skillId })).toBe(0);+ expect(await count('MCPServer', { author: userId })).toBe(0);+ expect(deps.invalidateMCPServerTools).toHaveBeenCalledWith(`acl-${user}`);+ expect(deps.invalidateMCPServerTools).toHaveBeenCalledWith(`legacy-${user}`);+ expect(deps.disconnectMCPServer).toHaveBeenCalledWith(`acl-${user}`);+ expect(deps.disconnectMCPServer).toHaveBeenCalledWith(`legacy-${user}`);+ expect(await count('SharedLink', { user })).toBe(0);+ expect(await count('AclEntry', { principalId: userId })).toBe(0);+ expect(await count('Transaction', { user: userId })).toBe(0);+ expect(await count('ToolFavorite', { user: userId })).toBe(0);+ expect(await count('ChatProject', { user })).toBe(0);+ expect(await count('AgentQueuedTurn', { user: userId })).toBe(0);+ expect(await count('AgentQueuedTurnSequence', { user: userId })).toBe(0);+ expect(await count('RefreshTokenBridge', { userId: user })).toBe(0);++ expect(await count('Skill', { _id: other.skillId })).toBe(1);+ expect(await count('MCPServer', { author: otherId })).toBe(2);+ expect(await count('SharedLink', { user: otherId.toString() })).toBe(1);+ expect(await count('File', { user: otherId })).toBe(2);+ expect(await count('Conversation', { user: otherId.toString() })).toBe(1);+ expect(await count('ToolFavorite', { user: otherId })).toBe(1);+ expect(await count('ChatProject', { user: otherId.toString() })).toBe(1);+ expect(await count('AgentQueuedTurn', { user: otherId })).toBe(1);+ expect(await count('AgentQueuedTurnSequence', { user: otherId })).toBe(1);+ expect(await count('RefreshTokenBridge', { userId: otherId.toString() })).toBe(1);+ });++ it('keeps the transaction ledger when the operator retains it', async () => {+ const userId = new mongoose.Types.ObjectId();+ await seedUser(userId);+ const { deps } = createDeps();++ await eraseUserData({ userId: userId.toString(), keepTransactions: true }, deps);++ expect(await count('Transaction', { user: userId })).toBe(1);+ expect(await count('Conversation', { user: userId.toString() })).toBe(0);+ });++ it('deletes pre-tenancy refresh bridges while running in the active tenant context', async () => {+ const userId = new mongoose.Types.ObjectId();+ await seedUser(userId);+ await model('RefreshTokenBridge').insertOne({+ userId: userId.toString(),+ oldRefreshTokenHash: 'legacy-hash',+ encryptedNewRefreshToken: 'encrypted',+ });+ const { deps } = createDeps();++ await tenantStorage.run({ tenantId: 'tenant-1' }, async () =>+ eraseUserData({ userId: userId.toString(), tenantId: 'tenant-1' }, deps),+ );++ expect(await count('RefreshTokenBridge', { userId: userId.toString() })).toBe(0);+ });++ it('removes refresh bridges written before tenancy for a tenant user', async () => {+ const userId = new mongoose.Types.ObjectId();+ await seedUser(userId);+ const { deps } = createDeps();+ const calls: unknown[] = [];+ (deps as { deleteRefreshTokenBridges: unknown }).deleteRefreshTokenBridges = jest.fn(+ async (data: unknown) => {+ calls.push(data);+ return { acknowledged: true, deletedCount: 0 };+ },+ );++ await eraseUserData({ userId: userId.toString(), tenantId: 'tenant-1' }, deps);++ expect(calls).toEqual([+ { userId: userId.toString(), tenantId: 'tenant-1' },+ { userId: userId.toString() },+ ]);+ });++ it('cleans OAuth state of users a removed MCP server was shared with', async () => {+ const userId = new mongoose.Types.ObjectId();+ const viewerId = new mongoose.Types.ObjectId();+ const strangerId = new mongoose.Types.ObjectId();+ const { mcpServerId } = await seedUser(userId);+ await methods.grantPermission(+ PrincipalType.USER,+ viewerId,+ ResourceType.MCPSERVER,+ mcpServerId,+ 1,+ userId,+ );+ const serverName = `acl-${userId}`;+ await model('Token').insertMany(+ [viewerId, strangerId].map((tokenUser) => ({+ userId: tokenUser,+ type: 'mcp_oauth',+ identifier: `mcp:${serverName}`,+ token: 'encrypted',+ expiresAt: new Date(Date.now() + 60_000),+ })),+ );+ const { deps } = createDeps();+ const fenced: string[] = [];+ const uninstalled: Array<[string, string]> = [];+ deps.mcpOAuth = {+ getServerConfig: jest.fn(async () => undefined),+ getUserPrincipals: jest.fn(async (candidate: string) =>+ candidate === viewerId.toString()+ ? [{ principalType: PrincipalType.USER, principalId: candidate }]+ : [],+ ),+ resolveAllowlists: jest.fn(async () => ({})),+ invalidateUserTools: jest.fn(async (candidate: string, fencedServer: string) => {+ if (fencedServer === serverName) {+ fenced.push(candidate);+ }+ }),+ uninstallOAuthMCP: jest.fn(async (candidate: string, pluginKey: string) => {+ if (pluginKey === `mcp_${serverName}`) {+ uninstalled.push([candidate, pluginKey]);+ }+ }),+ };++ await eraseUserData({ userId: userId.toString() }, deps);++ const expected = [userId.toString(), viewerId.toString()].sort();+ expect([...fenced].sort()).toEqual(expected);+ expect(uninstalled.map(([candidate]) => candidate).sort()).toEqual(expected);+ expect(uninstalled.every(([, key]) => key === `mcp_${serverName}`)).toBe(true);+ expect(await count('MCPServer', { author: userId })).toBe(0);+ });++ it('never treats token holders of a same-named server in another tenant as shared users', async () => {+ const userId = new mongoose.Types.ObjectId();+ const foreignId = new mongoose.Types.ObjectId();+ await seedUser(userId);+ const serverName = `acl-${userId}`;+ await model('Token').insertOne({+ userId: foreignId,+ tenantId: 'tenant-2',+ type: 'mcp_oauth',+ identifier: `mcp:${serverName}`,+ token: 'encrypted',+ expiresAt: new Date(Date.now() + 60_000),+ });+ const { deps } = createDeps();+ const touched: string[] = [];+ deps.mcpOAuth = {+ getUserPrincipals: jest.fn(async (candidate: string) => {+ touched.push(candidate);+ return [];+ }),+ resolveAllowlists: jest.fn(async () => ({})),+ uninstallOAuthMCP: jest.fn(async () => undefined),+ };++ await eraseUserData({ userId: userId.toString() }, deps);++ expect(touched).not.toContain(foreignId.toString());+ expect(await count('Token', { userId: foreignId })).toBe(1);+ });++ it('keeps the server and its ACLs when shared-user OAuth cleanup fails, so a retry finishes it', async () => {+ const userId = new mongoose.Types.ObjectId();+ const viewerId = new mongoose.Types.ObjectId();+ const { mcpServerId } = await seedUser(userId);+ await methods.grantPermission(+ PrincipalType.USER,+ viewerId,+ ResourceType.MCPSERVER,+ mcpServerId,+ 1,+ userId,+ );+ const serverName = `acl-${userId}`;+ await model('Token').insertOne({+ userId: viewerId,+ type: 'mcp_oauth',+ identifier: `mcp:${serverName}`,+ token: 'encrypted',+ expiresAt: new Date(Date.now() + 60_000),+ });+ const { deps } = createDeps();+ const uninstalled: string[] = [];+ let outage = true;+ deps.mcpOAuth = {+ getUserPrincipals: jest.fn(async (candidate: string) =>+ candidate === viewerId.toString()+ ? [{ principalType: PrincipalType.USER, principalId: candidate }]+ : [],+ ),+ resolveAllowlists: jest.fn(async () => ({})),+ uninstallOAuthMCP: jest.fn(async (candidate: string, pluginKey: string) => {+ if (outage) {+ throw new Error('redis down');+ }+ if (pluginKey === `mcp_${serverName}`) {+ uninstalled.push(candidate);+ }+ }),+ };++ await expect(eraseUserData({ userId: userId.toString() }, deps)).rejects.toThrow(+ 'MCP OAuth cleanup failed',+ );+ expect(await count('MCPServer', { _id: mcpServerId })).toBe(1);+ expect(await count('AclEntry', { resourceId: mcpServerId })).toBe(2);++ outage = false;+ await eraseUserData({ userId: userId.toString() }, deps);++ expect(uninstalled).toContain(viewerId.toString());+ expect(await count('MCPServer', { _id: mcpServerId })).toBe(0);+ });++ it('signals session revocation even when a later step fails', async () => {+ const userId = new mongoose.Types.ObjectId();+ await seedUser(userId);+ const { deps } = createDeps();+ const onSessionsDeleted = jest.fn();+ (deps.deletePresets as jest.Mock) = jest.fn().mockRejectedValue(new Error('presets down'));++ await expect(+ eraseUserData({ userId: userId.toString() }, { ...deps, onSessionsDeleted }),+ ).rejects.toThrow('presets down');++ expect(onSessionsDeleted).toHaveBeenCalledTimes(1);+ });++ it('erases nothing past conversations when checkpoint capture fails', async () => {+ const userId = new mongoose.Types.ObjectId();+ await seedUser(userId);+ const { deps, checkpointDeletion } = createDeps();+ (checkpointDeletion.cleanup as jest.Mock).mockRejectedValueOnce(new Error('store down'));++ await expect(eraseUserData({ userId: userId.toString() }, deps)).rejects.toThrow('store down');++ expect(checkpointDeletion.acknowledge).not.toHaveBeenCalled();+ expect(deps.deleteStoredFiles).not.toHaveBeenCalled();+ expect(await count('File', { user: userId })).toBe(2);+ expect(await count('Skill', { author: userId })).toBe(1);+ });++ it('stops before group and ACL cleanup when the MCP server lookup fails', async () => {+ const userId = new mongoose.Types.ObjectId();+ await seedUser(userId);+ const { deps } = createDeps();+ const failingDeps: UserErasureDeps = {+ ...deps,+ findUserErasableMCPServers: jest.fn().mockRejectedValue(new Error('mongo down')),+ };++ await expect(eraseUserData({ userId: userId.toString() }, failingDeps)).rejects.toThrow(+ 'mongo down',+ );++ expect(await count('MCPServer', { author: userId })).toBe(2);+ expect(await count('AclEntry', { principalId: userId })).toBeGreaterThan(0);+ });++ it('removes stored files while the user keys their provider clients need still exist', async () => {+ const userId = new mongoose.Types.ObjectId();+ await seedUser(userId);+ const { deps, order } = createDeps();+ const deleteUserKey = deps.deleteUserKey;+ const orderedDeps: UserErasureDeps = {+ ...deps,+ deleteUserKey: jest.fn(async (params) => {+ order.push('deleteUserKey');+ return deleteUserKey(params);+ }),+ };++ await eraseUserData({ userId: userId.toString() }, orderedDeps);++ expect(order.indexOf('deleteStoredFiles')).toBeLessThan(order.indexOf('deleteUserKey'));+ });++ it('still erases the account when the storage provider fails', async () => {+ const userId = new mongoose.Types.ObjectId();+ await seedUser(userId);+ const { deps } = createDeps();+ (deps.deleteStoredFiles as jest.Mock).mockRejectedValueOnce(new Error('provider down'));++ await eraseUserData({ userId: userId.toString() }, deps);++ expect(await count('File', { user: userId })).toBe(0);+ expect(await count('Skill', { author: userId })).toBe(0);+ });++ for (const modelName of ['Agent', 'PromptGroup']) {+ it(`keeps the account erasable when the ${modelName} lookup fails`, async () => {+ const userId = new mongoose.Types.ObjectId();+ await seedUser(userId);+ const { deps } = createDeps();+ const find = jest.spyOn(mongoose.models[modelName], 'find').mockImplementationOnce(() => {+ throw new Error(`${modelName} store down`);+ });++ try {+ await expect(eraseUserData({ userId: userId.toString() }, deps)).rejects.toThrow(+ `${modelName} store down`,+ );+ } finally {+ find.mockRestore();+ }++ expect(await count('MCPServer', { author: userId })).toBe(2);+ });+ }+});diff --git a/packages/api/src/user/erasure.ts b/packages/api/src/user/erasure.tsnew file mode 100644index 0000000000..beb2366ff4--- /dev/null+++ b/packages/api/src/user/erasure.ts@@ -0,0 +1,270 @@+import mongoose from 'mongoose';+import { logger } from '@librechat/data-schemas';+import type { TCheckpointerConfig, MCPOptions } from 'librechat-data-provider';+import type { AllMethods, IMongoFile } from '@librechat/data-schemas';+import type { CheckpointDeletion } from '~/agents/checkpoints/deletion';+import type { OAuthAclSubject } from '../mcp/oauth/cleanup';+import {+ cleanupDeletedMCPServerOAuthUsers,+ prepareMCPServerOAuthDeletion,+} from '../mcp/oauth/cleanup';++type ErasureMethods = Pick<+ AllMethods,+ | 'deleteConvos'+ | 'deleteMessages'+ | 'deleteAllUserSessions'+ | 'deletePasskeysByUser'+ | 'deleteTransactions'+ | 'deleteUserKey'+ | 'deleteBalances'+ | 'deletePresets'+ | 'deleteAllUserPluginAuths'+ | 'getFiles'+ | 'deleteFiles'+ | 'deleteToolCalls'+ | 'deleteUserAgents'+ | 'deleteAllAgentApiKeys'+ | 'deleteAssistants'+ | 'deleteConversationTags'+ | 'deleteAllUserMemories'+ | 'deleteUserPrompts'+ | 'deleteUserSkills'+ | 'findUserErasableMCPServers'+ | 'deleteMCPServersWithAcl'+ | 'findMCPServerOAuthTokenUserIds'+ | 'findMCPServerViewerEntries'+ | 'deleteActions'+ | 'deleteTokens'+ | 'removeUserFromAllGroups'+ | 'deleteAclEntries'+ | 'deleteSchedulesByUser'+ | 'deleteUserChatProjects'+ | 'deleteUserToolFavorites'+ | 'deleteRefreshTokenBridges'+ | 'deleteAllAgentQueuedTurnsForUser'+>;++export interface UserErasureDeps extends ErasureMethods {+ openCheckpointDeletion: (+ userId: string,+ tenantId: string | undefined,+ rootConversationId: string | undefined,+ cfg?: TCheckpointerConfig,+ ) => Promise<CheckpointDeletion>;+ deleteSharedLinks: (userId: string) => Promise<unknown>;+ /** Removes stored file objects (local disk, S3, Firebase, vector store) before their metadata. */+ deleteStoredFiles: (files: IMongoFile[]) => Promise<unknown>;+ /** Runtime cleanup for a removed MCP server; each hook is best effort. */+ invalidateMCPServerTools?: (serverName: string) => Promise<unknown>;+ disconnectMCPServer?: (serverName: string) => Promise<unknown>;+ /**+ * Cleans OAuth credentials, cached catalogs and connections of every user a removed MCP server+ * was shared with. Omitted when the host has no OAuth runtime; the owner hooks above still run.+ */+ mcpOAuth?: MCPOAuthErasureHooks;+ /** Runs once the user's sessions are revoked, before the rest of the cascade can fail. */+ onSessionsDeleted?: () => void;+}++export interface MCPOAuthErasureHooks {+ /** Config of the server before it is removed, so stored tokens can still be revoked. */+ getServerConfig?: (serverName: string, serverId: string) => Promise<MCPOptions | undefined>;+ getUserPrincipals: (userId: string) => Promise<OAuthAclSubject[]>;+ resolveAllowlists: (+ userId: string,+ ) => Promise<{ allowedDomains?: string[] | null; allowedAddresses?: string[] | null }>;+ /** Bumps the user's cached catalog generation for the server so loaded tools stop working. */+ invalidateUserTools?: (userId: string, serverName: string) => Promise<unknown>;+ /** Closes the user's live connection to the server, where the host holds connections. */+ disconnectUser?: (userId: string, serverName: string) => Promise<unknown>;+ uninstallOAuthMCP: (+ userId: string,+ pluginKey: string,+ appConfig: {+ mcpSettings?: { allowedDomains?: string[] | null; allowedAddresses?: string[] | null };+ },+ serverConfig?: MCPOptions,+ ) => Promise<void>;+}++export interface UserErasureParams {+ userId: string;+ tenantId?: string;+ checkpointer?: TCheckpointerConfig;+ /** Operator option to keep the transaction ledger; account self-deletion always erases it. */+ keepTransactions?: boolean;+}++export type MCPServerCleanupDeps = Pick<+ UserErasureDeps,+ | 'findUserErasableMCPServers'+ | 'deleteMCPServersWithAcl'+ | 'invalidateMCPServerTools'+ | 'disconnectMCPServer'+ | 'findMCPServerOAuthTokenUserIds'+ | 'findMCPServerViewerEntries'+ | 'mcpOAuth'+>;++/**+ * Deletes MCP servers solely owned by the user, plus legacy (pre-ACL) servers that only carry+ * the author field, and their ACL entries. Servers with other owners are left intact; the+ * user's own principal ACL entries are removed separately by the cascade. Runtime hooks are+ * best effort; a database failure propagates so the caller keeps the account and can retry.+ */+export async function deleteUserMCPServers(+ userId: string,+ deps: MCPServerCleanupDeps,+ tenantId?: string,+): Promise<void> {+ const servers = await deps.findUserErasableMCPServers(userId);+ if (servers.length === 0) {+ return;+ }++ await Promise.allSettled(+ servers.map(async ({ serverName }) => {+ if (!serverName) {+ return;+ }+ try {+ await deps.invalidateMCPServerTools?.(serverName);+ } catch (error) {+ logger.warn(`[eraseUserData] Failed to invalidate tools for ${serverName}`, error);+ } finally {+ try {+ await deps.disconnectMCPServer?.(serverName);+ } catch (error) {+ logger.warn(`[eraseUserData] Failed to disconnect ${serverName}`, error);+ }+ }+ }),+ );++ const oauth = deps.mcpOAuth;+ const named = servers.filter((server) => server.serverName);+ /** Shared users are discovered from the ACLs and tokens, which the delete removes. */+ const prepared = oauth+ ? await Promise.all(+ named.map(async ({ id, serverName }) => ({+ serverName,+ serverConfig: await oauth.getServerConfig?.(serverName, id),+ snapshot: await prepareMCPServerOAuthDeletion({+ getTokenUserIds: () => deps.findMCPServerOAuthTokenUserIds(serverName, tenantId),+ getAclEntries: () => deps.findMCPServerViewerEntries(id),+ }),+ })),+ )+ : [];++ const cleanupSharedUsers = async (removed: typeof prepared): Promise<number> => {+ if (!oauth) {+ return 0;+ }+ const results = await Promise.allSettled(+ removed.map(({ serverName, serverConfig, snapshot }) =>+ cleanupDeletedMCPServerOAuthUsers({+ ownerUserId: userId,+ serverName,+ serverConfig,+ snapshot,+ getTokenUserIds: () => deps.findMCPServerOAuthTokenUserIds(serverName, tenantId),+ getUserPrincipals: oauth.getUserPrincipals,+ resolveAllowlists: oauth.resolveAllowlists,+ fenceAndDisconnectUser: async (candidateId) => {+ await oauth.invalidateUserTools?.(candidateId, serverName);+ await oauth.disconnectUser?.(candidateId, serverName);+ },+ uninstallOAuthMCP: oauth.uninstallOAuthMCP,+ }),+ ),+ );+ const failures = results.filter((result) => result.status === 'rejected');+ for (const failure of failures) {+ logger.error(`[eraseUserData] MCP OAuth cleanup failed for user ${userId}`, failure.reason);+ }+ return failures.length;+ };++ /** The server and its ACLs are the retry anchors, so they outlive a failed teardown. */+ if ((await cleanupSharedUsers(prepared)) > 0) {+ throw new Error('MCP OAuth cleanup failed for users of a server being removed');+ }+ await deps.deleteMCPServersWithAcl(servers.map((s) => s.id));+}++/**+ * The user-owned data cascade shared by account self-deletion and the operator CLI.+ *+ * Callers own everything around it: deletion fences, schedule suspension, generation aborts,+ * the final user document delete, and code environment cleanup after that commit. The cascade+ * is idempotent, so a failed attempt can be retried after the caller restores its fences.+ */+export async function eraseUserData(+ params: UserErasureParams,+ deps: UserErasureDeps,+): Promise<void> {+ const { userId, tenantId, checkpointer, keepTransactions = false } = params;+ const userObjectId = new mongoose.Types.ObjectId(userId);++ const checkpointDeletion = await deps.openCheckpointDeletion(+ userId,+ tenantId,+ undefined,+ checkpointer,+ );+ await deps.deleteConvos(+ userId,+ {},+ {+ allowEmpty: true,+ beforeDelete: (ids) => checkpointDeletion.remember(ids),+ },+ );+ await checkpointDeletion.cleanup();+ await checkpointDeletion.acknowledge();++ await deps.deleteUserChatProjects(userId);+ await deps.deleteMessages({ user: userId });+ await deps.deleteAllAgentQueuedTurnsForUser({ user: userObjectId });+ /** Before user keys: provider-stored files need the user's own assistants credentials. */+ const files = await deps.getFiles({ user: userId });+ try {+ await deps.deleteStoredFiles(files ?? []);+ } catch (error) {+ logger.error(`[eraseUserData] Failed to delete stored files for user ${userId}`, error);+ }+ await deps.deleteFiles([], userId);+ await deps.deleteAllUserSessions({ userId });+ deps.onSessionsDeleted?.();+ await deps.deleteRefreshTokenBridges({ userId, tenantId });+ if (tenantId) {+ /** Bridges written before tenancy carry no tenantId, and the user id is globally unique. */+ await deps.deleteRefreshTokenBridges({ userId });+ }+ await deps.deletePasskeysByUser(userId);+ if (!keepTransactions) {+ await deps.deleteTransactions({ user: userId });+ }+ await deps.deleteUserKey({ userId, all: true });+ await deps.deleteBalances({ user: userObjectId });+ await deps.deletePresets(userId);+ await deps.deleteAllUserPluginAuths(userId);+ await deps.deleteSharedLinks(userId);+ await deps.deleteToolCalls(userId);+ await deps.deleteUserAgents(userId);+ await deps.deleteAllAgentApiKeys(userObjectId);+ await deps.deleteAssistants({ user: userId });+ await deps.deleteConversationTags({ user: userId });+ await deps.deleteUserToolFavorites(userId);+ await deps.deleteAllUserMemories(userId);+ await deps.deleteUserPrompts(userId);+ await deps.deleteUserSkills(userId);+ await deleteUserMCPServers(userId, deps, tenantId);+ await deps.deleteActions({ user: userId });+ await deps.deleteTokens({ userId });+ await deps.removeUserFromAllGroups(userId);+ await deps.deleteAclEntries({ principalId: userObjectId });+ await deps.deleteSchedulesByUser(userId);+}diff --git a/packages/api/src/user/index.ts b/packages/api/src/user/index.tsindex a17a3da115..1945a8f316 100644--- a/packages/api/src/user/index.ts+++ b/packages/api/src/user/index.ts@@ -1 +1,2 @@export * from './preferences';+export * from './erasure';diff --git a/packages/data-schemas/src/methods/agent.spec.ts b/packages/data-schemas/src/methods/agent.spec.tsindex 720562b32e..cab240cb60 100644--- a/packages/data-schemas/src/methods/agent.spec.ts+++ b/packages/data-schemas/src/methods/agent.spec.ts@@ -1340,6 +1340,116 @@ describe('Agent Methods', () => {]);});+ test('keeps a sole-owned agent discoverable when the agent delete fails, so a retry erases it', async () => {+ const ownerId = new mongoose.Types.ObjectId();+ const authorId = new mongoose.Types.ObjectId();+ const agent = await createAgent({+ id: `agent_${uuidv4()}`,+ name: 'Owned But Authored Elsewhere',+ provider: 'test',+ model: 'test-model',+ author: authorId,+ });+ await AclEntry.create({+ principalType: PrincipalType.USER,+ principalId: ownerId,+ principalModel: PrincipalModel.USER,+ resourceType: ResourceType.AGENT,+ resourceId: agent._id,+ permBits:+ PermissionBits.VIEW | PermissionBits.EDIT | PermissionBits.DELETE | PermissionBits.SHARE,+ grantedBy: ownerId,+ });++ const failure = jest+ .spyOn(mongoose.models.Agent, 'deleteMany')+ .mockRejectedValueOnce(new Error('transient outage'));+ await expect(deleteUserAgents(ownerId.toString())).rejects.toThrow('transient outage');+ failure.mockRestore();++ expect(await AclEntry.countDocuments({ resourceId: agent._id })).toBe(1);++ await deleteUserAgents(ownerId.toString());++ expect(await getAgent({ id: agent.id })).toBeNull();+ expect(await AclEntry.countDocuments({ resourceId: agent._id })).toBe(0);+ });++ test('keeps the agent when reference cleanup fails, so a retry erases it', async () => {+ const ownerId = new mongoose.Types.ObjectId();+ const agent = await createAgent({+ id: `agent_${uuidv4()}`,+ name: 'Owned',+ provider: 'test',+ model: 'test-model',+ author: ownerId,+ });+ await AclEntry.create({+ principalType: PrincipalType.USER,+ principalId: ownerId,+ principalModel: PrincipalModel.USER,+ resourceType: ResourceType.AGENT,+ resourceId: agent._id,+ permBits:+ PermissionBits.VIEW | PermissionBits.EDIT | PermissionBits.DELETE | PermissionBits.SHARE,+ grantedBy: ownerId,+ });++ const failure = jest+ .spyOn(mongoose.models.User, 'updateMany')+ .mockRejectedValueOnce(new Error('favorites outage'));+ await expect(deleteUserAgents(ownerId.toString())).rejects.toThrow('favorites outage');+ failure.mockRestore();++ expect(await getAgent({ id: agent.id })).not.toBeNull();++ await deleteUserAgents(ownerId.toString());++ expect(await getAgent({ id: agent.id })).toBeNull();+ });++ test('does not touch same-id references in another tenant when the author is tenantless', async () => {+ const authorId = new mongoose.Types.ObjectId();+ const sharedAgentId = `agent_${uuidv4()}`;+ const otherGraphId = `agent_${uuidv4()}`;+ const otherTargetId = `agent_${uuidv4()}`;+ await createAgent({+ id: sharedAgentId,+ name: 'Tenantless Agent',+ provider: 'test',+ model: 'test-model',+ author: authorId,+ });+ const Agent = mongoose.models.Agent;+ await Agent.collection.insertOne({+ id: otherGraphId,+ name: 'Other Tenant Graph',+ provider: 'test',+ model: 'test-model',+ author: new mongoose.Types.ObjectId(),+ tenantId: 'tenant-2',+ edges: [+ { from: otherGraphId, to: sharedAgentId, edgeType: 'handoff' },+ { from: otherGraphId, to: otherTargetId, edgeType: 'handoff' },+ ],+ });+ await mongoose.models.User.collection.insertOne({+ email: '[email protected]',+ tenantId: 'tenant-2',+ favorites: [{ agentId: sharedAgentId }],+ });++ await deleteUserAgents(authorId.toString());++ expect(await getAgent({ id: sharedAgentId })).toBeNull();+ const graph = await Agent.collection.findOne({ id: otherGraphId });+ expect(graph?.edges).toHaveLength(2);+ const otherUser = await mongoose.models.User.collection.findOne({+ email: '[email protected]',+ });+ expect(otherUser?.favorites).toEqual([{ agentId: sharedAgentId }]);+ });+test('keeps an edge added to the graph while the cleanup was running', async () => {const authorId = new mongoose.Types.ObjectId();const deletedAgentId = `agent_${uuidv4()}`;diff --git a/packages/data-schemas/src/methods/agent.ts b/packages/data-schemas/src/methods/agent.tsindex 714f7c5339..5badb56376 100644--- a/packages/data-schemas/src/methods/agent.ts+++ b/packages/data-schemas/src/methods/agent.ts@@ -591,12 +591,13 @@ interface GraphEdges {async function removeAgentIdsFromEdges(Agent: Model<IAgent>,agentIds: string[],- tenantId?: string,+ tenantId?: string | null,): Promise<void> {if (agentIds.length === 0) {return;}const filter: FilterQuery<IAgent> = {+ /** `null` pins the cleanup to tenantless graphs (matches a missing field). */...(tenantId !== undefined ? { tenantId } : {}),$or: [{ 'edges.from': { $in: agentIds } }, { 'edges.to': { $in: agentIds } }],};@@ -1923,7 +1924,9 @@ export function createAgentMethods(ResourceType.REMOTE_AGENT,]);- const authoredAgents = await Agent.find({ author: userObjectId }).select('id _id').lean();+ const authoredAgents = await Agent.find({ author: userObjectId })+ .select('id _id tenantId')+ .lean();const migratedEntries =authoredAgents.length > 0@@ -1940,42 +1943,48 @@ export function createAgentMethods(const soleOwnedAgents =soleOwnedObjectIds.length > 0? await Agent.find({ _id: { $in: soleOwnedObjectIds } })- .select('id _id')+ .select('id _id tenantId').lean(): [];const allAgents = [...soleOwnedAgents, ...legacyAgents];+ /** Sole-owned ids whose agent is already gone: ACLs left by an interrupted earlier attempt. */+ const aclResourceIds = [...soleOwnedObjectIds, ...legacyAgents.map((a) => a._id)];- if (allAgents.length === 0) {+ if (aclResourceIds.length === 0) {return;}- const agentIds = allAgents.map((agent) => agent.id);const agentObjectIds = allAgents.map((agent) => agent._id);-- await AclEntry.deleteMany({- resourceType: { $in: [ResourceType.AGENT, ResourceType.REMOTE_AGENT] },- resourceId: { $in: agentObjectIds },- });-- try {- await removeAgentIdsFromEdges(Agent, agentIds);- } catch (error) {- logger.error('[deleteUserAgents] Error removing agents from handoff edges', error);+ /** Agent ids are unique per tenant only, so reference cleanup runs once per agent tenant. */+ const idsByTenant = new Map<string | null, string[]>();+ for (const agent of allAgents) {+ const tenant = agent.tenantId ?? null;+ const bucket = idsByTenant.get(tenant);+ if (bucket) {+ bucket.push(agent.id);+ } else {+ idsByTenant.set(tenant, [agent.id]);+ }}-- try {+ /** Reference cleanup precedes the irreversible delete, so a failure keeps the agent discoverable for retry. */+ for (const [tenant, tenantAgentIds] of idsByTenant) {+ await removeAgentIdsFromEdges(Agent, tenantAgentIds, tenant);await User.updateMany(- { 'favorites.agentId': { $in: agentIds } },- { $pull: { favorites: { agentId: { $in: agentIds } } } },+ { tenantId: tenant, 'favorites.agentId': { $in: tenantAgentIds } },+ { $pull: { favorites: { agentId: { $in: tenantAgentIds } } } },);- } catch (error) {- logger.error('[deleteUserAgents] Error removing agents from user favorites', error);}await Agent.deleteMany({ _id: { $in: agentObjectIds } });+ /** ACL entries are the retry discovery key for sole-owned agents, so they go last. */+ await AclEntry.deleteMany({+ resourceType: { $in: [ResourceType.AGENT, ResourceType.REMOTE_AGENT] },+ resourceId: { $in: aclResourceIds },+ });} catch (error) {logger.error('[deleteUserAgents] General error:', error);+ throw error;}}diff --git a/packages/data-schemas/src/methods/chatProject.ts b/packages/data-schemas/src/methods/chatProject.tsindex 4a2504bc43..815c9d4716 100644--- a/packages/data-schemas/src/methods/chatProject.ts+++ b/packages/data-schemas/src/methods/chatProject.ts@@ -70,6 +70,7 @@ export interface ChatProjectMethods {limits?: Partial<ChatProjectLimits>,): Promise<IChatProject | null>;deleteChatProject(user: string, projectId: string): Promise<DeleteChatProjectResult>;+ deleteUserChatProjects(user: string): Promise<number>;addChatProjectFile(user: string,projectId: string,@@ -687,6 +688,13 @@ export function createChatProjectMethods(mongoose: typeof import('mongoose')): C};}+ /** Account erasure: the user's conversations are deleted first, so no chat keeps a pointer. */+ async function deleteUserChatProjects(user: string): Promise<number> {+ const ChatProject = mongoose.models.ChatProject as Model<IChatProjectDocument>;+ const result = await ChatProject.deleteMany({ user });+ return result.deletedCount ?? 0;+ }+async function assignConversationToProject(user: string,conversationId: string,@@ -757,6 +765,7 @@ export function createChatProjectMethods(mongoose: typeof import('mongoose')): ClistChatProjects,updateChatProject,deleteChatProject,+ deleteUserChatProjects,addChatProjectFile,removeChatProjectFile,assignConversationToProject,diff --git a/packages/data-schemas/src/methods/favorite.ts b/packages/data-schemas/src/methods/favorite.tsindex 10e1544f20..da78591713 100644--- a/packages/data-schemas/src/methods/favorite.ts+++ b/packages/data-schemas/src/methods/favorite.ts@@ -23,6 +23,7 @@ export function createToolFavoriteMethods(mongoose: typeof import('mongoose')):getToolFavorites: (userId: string) => Promise<t.IToolFavoriteLean[]>;addToolFavorite: (params: t.ToolFavoriteParams) => Promise<t.AddToolFavoriteResult>;removeToolFavorite: (params: t.ToolFavoriteParams) => Promise<t.RemoveToolFavoriteResult>;+ deleteUserToolFavorites: (userId: string) => Promise<number>;} {async function getToolFavorites(userId: string): Promise<t.IToolFavoriteLean[]> {const ToolFavorite = mongoose.models.ToolFavorite;@@ -80,10 +81,18 @@ export function createToolFavoriteMethods(mongoose: typeof import('mongoose')):return { ok: true, removed: result.deletedCount > 0 };}+ /** Account erasure: removes every favorite the user saved. */+ async function deleteUserToolFavorites(userId: string): Promise<number> {+ const ToolFavorite = mongoose.models.ToolFavorite;+ const result = await ToolFavorite.deleteMany({ user: userId });+ return result.deletedCount;+ }+return {getToolFavorites,addToolFavorite,removeToolFavorite,+ deleteUserToolFavorites,};}diff --git a/packages/data-schemas/src/methods/index.ts b/packages/data-schemas/src/methods/index.tsindex 0f5752dd45..49c4df8e59 100644--- a/packages/data-schemas/src/methods/index.ts+++ b/packages/data-schemas/src/methods/index.ts@@ -503,7 +503,9 @@ export function createMethods(...createToolFavoriteMethods(mongoose),...createAgentCategoryMethods(mongoose),...createAgentApiKeyMethods(mongoose),- ...createMCPServerMethods(mongoose),+ ...createMCPServerMethods(mongoose, {+ getSoleOwnedResourceIds: aclEntryMethods.getSoleOwnedResourceIds,+ }),...createCodeEnvironmentMethods(mongoose),...createAccessRoleMethods(mongoose),...userGroupMethods,diff --git a/packages/data-schemas/src/methods/mcpServer.spec.ts b/packages/data-schemas/src/methods/mcpServer.spec.tsindex 9d5f915bfd..29f1a0aa64 100644--- a/packages/data-schemas/src/methods/mcpServer.spec.ts+++ b/packages/data-schemas/src/methods/mcpServer.spec.ts@@ -1,9 +1,17 @@import mongoose from 'mongoose';import { MongoMemoryServer } from 'mongodb-memory-server';+import {+ PrincipalType,+ PrincipalModel,+ ResourceType,+ PermissionBits,+} from 'librechat-data-provider';import type { MCPOptions } from 'librechat-data-provider';import type * as t from '~/types';import { createMCPServerMethods } from './mcpServer';+import { createAclEntryMethods } from './aclEntry';import mcpServerSchema from '~/schema/mcpServer';+import aclEntrySchema from '~/schema/aclEntry';let mongoServer: MongoMemoryServer;let MCPServer: mongoose.Model<t.MCPServerDocument>;@@ -13,7 +21,12 @@ beforeAll(async () => {mongoServer = await MongoMemoryServer.create();const mongoUri = mongoServer.getUri();MCPServer = mongoose.models.MCPServer || mongoose.model('MCPServer', mcpServerSchema);- methods = createMCPServerMethods(mongoose);+ if (!mongoose.models.AclEntry) {+ mongoose.model('AclEntry', aclEntrySchema);+ }+ methods = createMCPServerMethods(mongoose, {+ getSoleOwnedResourceIds: createAclEntryMethods(mongoose).getSoleOwnedResourceIds,+ });await mongoose.connect(mongoUri);});@@ -674,6 +687,41 @@ describe('MCPServer Model Tests', () => {});});+ describe('deleteMCPServersWithAcl', () => {+ test('keeps the owner ACL until the server is gone so a failed delete can be retried', async () => {+ const ownerId = new mongoose.Types.ObjectId();+ const created = await methods.createMCPServer({+ config: createSSEConfig('Erase Retry'),+ author: authorId,+ });+ await mongoose.model('AclEntry').create({+ principalType: PrincipalType.USER,+ principalId: ownerId,+ principalModel: PrincipalModel.USER,+ resourceType: ResourceType.MCPSERVER,+ resourceId: created._id,+ permBits:+ PermissionBits.VIEW | PermissionBits.EDIT | PermissionBits.DELETE | PermissionBits.SHARE,+ grantedBy: ownerId,+ });++ const failure = jest+ .spyOn(MCPServer, 'deleteMany')+ .mockRejectedValueOnce(new Error('transient outage'));+ await expect(methods.deleteMCPServersWithAcl([created._id.toString()])).rejects.toThrow(+ 'transient outage',+ );+ failure.mockRestore();++ const found = await methods.findUserErasableMCPServers(ownerId.toString());+ expect(found.map((s) => s.id)).toEqual([created._id.toString()]);++ await methods.deleteMCPServersWithAcl(found.map((s) => s.id));+ expect(await methods.findMCPServerByServerName(created.serverName)).toBeNull();+ expect(await methods.findUserErasableMCPServers(ownerId.toString())).toEqual([]);+ });+ });+describe('getListMCPServersByNames', () => {test('should return empty data for empty names array', async () => {const result = await methods.getListMCPServersByNames({ names: [] });diff --git a/packages/data-schemas/src/methods/mcpServer.ts b/packages/data-schemas/src/methods/mcpServer.tsindex 3b3986e853..051bc665d1 100644--- a/packages/data-schemas/src/methods/mcpServer.ts+++ b/packages/data-schemas/src/methods/mcpServer.ts@@ -1,8 +1,9 @@import { nanoid } from 'nanoid';-import { normalizeServerName } from 'librechat-data-provider';+import { ResourceType, PermissionBits, normalizeServerName } from 'librechat-data-provider';import type { Model, RootFilterQuery, Types } from 'mongoose';import type { MCPOptions } from 'librechat-data-provider';import type { MCPServerDocument } from '../types';+import { permissionBitSupersets } from './aclEntry';import logger from '~/config/winston';const NORMALIZED_LIMIT_DEFAULT = 20;@@ -45,7 +46,29 @@ function generateServerNameFromTitle(title: string): string {return slug || 'mcp-server'; // Fallback if empty}-export function createMCPServerMethods(mongoose: typeof import('mongoose')): {+export interface MCPServerDeps {+ /** Returns resource IDs solely owned by the given user. From createAclEntryMethods. */+ getSoleOwnedResourceIds: (+ userObjectId: Types.ObjectId,+ resourceTypes: string | string[],+ ) => Promise<Types.ObjectId[]>;+}++/** An MCP server removed with its owner's account. */+export interface MCPServerViewerEntry {+ principalType: string;+ principalId?: string;+}++export interface ErasableMCPServer {+ id: string;+ serverName: string;+}++export function createMCPServerMethods(+ mongoose: typeof import('mongoose'),+ deps: MCPServerDeps,+): {createMCPServer: (data: {config: MCPOptions;author: string | Types.ObjectId;@@ -77,6 +100,10 @@ export function createMCPServerMethods(mongoose: typeof import('mongoose')): {updateData: { config?: MCPOptions },) => Promise<MCPServerDocument | null>;deleteMCPServer: (serverName: string) => Promise<MCPServerDocument | null>;+ findUserErasableMCPServers: (userId: string) => Promise<ErasableMCPServer[]>;+ deleteMCPServersWithAcl: (ids: string[]) => Promise<number>;+ findMCPServerOAuthTokenUserIds: (serverName: string, tenantId?: string) => Promise<string[]>;+ findMCPServerViewerEntries: (serverId: string) => Promise<MCPServerViewerEntry[]>;} {/*** Finds the next available server name by checking DB and reserved-name collisions.@@ -362,7 +389,107 @@ export function createMCPServerMethods(mongoose: typeof import('mongoose')): {return { data: servers };}+ /**+ * Account erasure: servers solely owned by the user, plus legacy (pre-ACL) servers that only+ * carry the author field. Servers shared with another owner are not returned.+ */+ async function findUserErasableMCPServers(userId: string): Promise<ErasableMCPServer[]> {+ const MCPServer = mongoose.models.MCPServer as Model<MCPServerDocument> | undefined;+ const AclEntry = mongoose.models.AclEntry;+ if (!MCPServer || !AclEntry) {+ return [];+ }++ const userObjectId = new mongoose.Types.ObjectId(userId);+ const soleOwnedIds = await deps.getSoleOwnedResourceIds(userObjectId, ResourceType.MCPSERVER);+ const authoredServers = await MCPServer.find({ author: userObjectId })+ .select('_id serverName')+ .lean<Array<{ _id: Types.ObjectId; serverName: string }>>();+ const migratedEntries =+ authoredServers.length > 0+ ? await AclEntry.find({+ resourceType: ResourceType.MCPSERVER,+ resourceId: { $in: authoredServers.map((s) => s._id) },+ })+ .select('resourceId')+ .lean<Array<{ resourceId: Types.ObjectId }>>()+ : [];+ const migratedIds = new Set(migratedEntries.map((e) => e.resourceId.toString()));+ const legacyServers = authoredServers.filter((s) => !migratedIds.has(s._id.toString()));+ const aclOwnedServers =+ soleOwnedIds.length > 0+ ? await MCPServer.find({ _id: { $in: soleOwnedIds } })+ .select('_id serverName')+ .lean<Array<{ _id: Types.ObjectId; serverName: string }>>()+ : [];+ const found = new Set(aclOwnedServers.map((s) => s._id.toString()));+ /** Sole-owned ids whose server is already gone keep an empty name so the ACLs still get cleaned. */+ const residual = soleOwnedIds+ .filter((id) => !found.has(id.toString()))+ .map((id) => ({ id: id.toString(), serverName: '' }));+ return [+ ...[...aclOwnedServers, ...legacyServers].map((s) => ({+ id: s._id.toString(),+ serverName: s.serverName,+ })),+ ...residual,+ ];+ }++ /** Users holding an OAuth credential record for the server, used to fence them on removal. */+ async function findMCPServerOAuthTokenUserIds(+ serverName: string,+ tenantId?: string,+ ): Promise<string[]> {+ const Token = mongoose.models.Token;+ if (!Token) {+ return [];+ }+ const identifier = `mcp:${serverName}`;+ /** Server names are unique per tenant, so a tenantless owner only matches tenantless tokens. */+ const userIds = await Token.distinct('userId', {+ tenantId: tenantId ?? null,+ identifier: { $in: [identifier, `${identifier}:client`, `${identifier}:refresh`] },+ });+ return userIds.map(String);+ }++ /** Principals holding view access on the server, used to find users it was shared with. */+ async function findMCPServerViewerEntries(serverId: string): Promise<MCPServerViewerEntry[]> {+ const entries = await mongoose.models.AclEntry.find({+ resourceType: ResourceType.MCPSERVER,+ resourceId: new mongoose.Types.ObjectId(serverId),+ permBits: { $in: permissionBitSupersets(PermissionBits.VIEW) },+ })+ .select('principalType principalId')+ .lean<Array<{ principalType: string; principalId?: Types.ObjectId | string }>>();+ return entries.map((entry) => ({+ principalType: entry.principalType,+ principalId: entry.principalId?.toString(),+ }));+ }++ /** Deletes MCP servers by id together with every ACL entry on them. */+ async function deleteMCPServersWithAcl(ids: string[]): Promise<number> {+ if (ids.length === 0) {+ return 0;+ }+ const MCPServer = mongoose.models.MCPServer as Model<MCPServerDocument>;+ const objectIds = ids.map((id) => new mongoose.Types.ObjectId(id));+ const result = await MCPServer.deleteMany({ _id: { $in: objectIds } });+ /** ACL entries are the retry discovery key for sole-owned servers, so they go last. */+ await mongoose.models.AclEntry.deleteMany({+ resourceType: ResourceType.MCPSERVER,+ resourceId: { $in: objectIds },+ });+ return result.deletedCount ?? 0;+ }+return {+ findUserErasableMCPServers,+ deleteMCPServersWithAcl,+ findMCPServerOAuthTokenUserIds,+ findMCPServerViewerEntries,createMCPServer,findMCPServerByServerName,findMCPServerByObjectId,diff --git a/packages/data-schemas/src/methods/prompt.spec.ts b/packages/data-schemas/src/methods/prompt.spec.tsindex 6334e6b229..c9e0b3f342 100644--- a/packages/data-schemas/src/methods/prompt.spec.ts+++ b/packages/data-schemas/src/methods/prompt.spec.ts@@ -766,6 +766,26 @@ describe('Prompt method failure contracts', () => {const all = await methods.getListPromptGroupsByAccess({ accessibleIds });expect(all.data).toHaveLength(2);});++ it('keeps a sole-owned group discoverable when the prompt delete fails, so a retry erases it', async () => {+ const { groupId, promptId } = await createGroupWithPrompt('erase retry');+ await grantPermission({+ principalType: PrincipalType.USER,+ principalId: testUsers.owner._id,+ resourceType: ResourceType.PROMPTGROUP,+ resourceId: groupId,+ accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,+ grantedBy: testUsers.owner._id,+ });++ jest.spyOn(Prompt, 'deleteMany').mockRejectedValueOnce(dbError);+ await expect(methods.deleteUserPrompts(String(testUsers.owner._id))).rejects.toBe(dbError);++ await methods.deleteUserPrompts(String(testUsers.owner._id));+ expect(await Prompt.findById(promptId)).toBeNull();+ expect(await PromptGroup.findById(groupId)).toBeNull();+ expect(await AclEntry.countDocuments({ resourceId: new ObjectId(groupId) })).toBe(0);+ });});describe('Prompt group list projections include `command`', () => {diff --git a/packages/data-schemas/src/methods/prompt.ts b/packages/data-schemas/src/methods/prompt.tsindex 8848f76d5c..f4b6ccc018 100644--- a/packages/data-schemas/src/methods/prompt.ts+++ b/packages/data-schemas/src/methods/prompt.ts@@ -1051,16 +1051,17 @@ export function createPromptMethods(return;}+ /** ACL entries are the retry discovery key for sole-owned groups, so they go last. */+ await Prompt.deleteMany({ groupId: { $in: allGroupIdsToDelete } });+ await PromptGroup.deleteMany({ _id: { $in: allGroupIdsToDelete } });await AclEntry.deleteMany({resourceType: ResourceType.PROMPTGROUP,resourceId: { $in: allGroupIdsToDelete },});-- await PromptGroup.deleteMany({ _id: { $in: allGroupIdsToDelete } });- await Prompt.deleteMany({ groupId: { $in: allGroupIdsToDelete } });await invalidatePromptGroupAccessContext();} catch (error) {logger.error('[deleteUserPrompts] General error:', error);+ throw error;}}diff --git a/packages/data-schemas/src/methods/skill.spec.ts b/packages/data-schemas/src/methods/skill.spec.tsindex 5e81e6531a..a326c7cad9 100644--- a/packages/data-schemas/src/methods/skill.spec.ts+++ b/packages/data-schemas/src/methods/skill.spec.ts@@ -2454,4 +2454,23 @@ describe('deleteUserSkills', () => {expect(agentAfter?.skills).toEqual([]);expect(agentAfter?.skills_enabled).toBe(false);});++ it('fails and keeps the retry anchor when agent allowlist cleanup fails', async () => {+ const { skill: mine } = await methods.createSkill(makeSkillInput({ name: 'mine' }));+ await grantOwner(mine._id);+ const Agent = mongoose.models.Agent;+ const agent = await Agent.create(makeAgentDoc([mine._id.toString(), 'keep-me']));++ const failure = jest+ .spyOn(Agent, 'updateMany')+ .mockRejectedValueOnce(new Error('transient outage'));+ await expect(methods.deleteUserSkills(owner._id as mongoose.Types.ObjectId)).rejects.toThrow(+ 'Agent skill allowlists could not be cleaned up',+ );+ failure.mockRestore();++ await methods.deleteUserSkills(owner._id as mongoose.Types.ObjectId);+ const agentAfter = (await Agent.findById(agent._id).lean()) as { skills?: string[] } | null;+ expect(agentAfter?.skills).toEqual(['keep-me']);+ });});diff --git a/packages/data-schemas/src/methods/skill.ts b/packages/data-schemas/src/methods/skill.tsindex 30b046e02e..c02ecd6714 100644--- a/packages/data-schemas/src/methods/skill.ts+++ b/packages/data-schemas/src/methods/skill.ts@@ -1772,19 +1772,25 @@ export function createSkillMethods(const SkillFile = mongoose.models.SkillFile as Model<ISkillFileDocument>;await SkillFile.deleteMany({ skillId: { $in: soleOwned } });const res = await Skill.deleteMany({ _id: { $in: soleOwned } });- await removeSkillsFromAgentAllowlists(soleOwned.map((rid) => rid.toString()));- await Promise.allSettled(+ if (!(await removeSkillsFromAgentAllowlists(soleOwned.map((rid) => rid.toString())))) {+ throw new Error('Agent skill allowlists could not be cleaned up');+ }+ /** Permission entries are the retry discovery key for sole-owned skills, so a failure keeps them. */+ const permissionResults = await Promise.allSettled(soleOwned.map((rid) =>- deps- .removeAllPermissions({- resourceType: ResourceType.SKILL,- resourceId: rid.toString(),- })- .catch((error) =>- logger.error(`[deleteUserSkills] Error removing permissions for ${rid}:`, error),- ),+ deps.removeAllPermissions({+ resourceType: ResourceType.SKILL,+ resourceId: rid.toString(),+ }),),);+ const failedPermission = permissionResults.find(+ (result): result is PromiseRejectedResult => result.status === 'rejected',+ );+ if (failedPermission) {+ logger.error('[deleteUserSkills] Error removing permissions:', failedPermission.reason);+ throw failedPermission.reason;+ }return res.deletedCount ?? 0;}