Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🗑️ 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.js
index 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.js
index 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.js
index 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,
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.js
index 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.js
index 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.js
index 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.js
index 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 },
+ 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.js
index 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 itself
const 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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')): C
listChatProjects,
updateChatProject,
deleteChatProject,
+ deleteUserChatProjects,
addChatProjectFile,
removeChatProjectFile,
assignConversationToProject,
diff --git a/packages/data-schemas/src/methods/favorite.ts b/packages/data-schemas/src/methods/favorite.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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;
}