mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-20 15:02:02 +00:00
Sixth external review round: the remaining P1 interleavings were one structural problem — lease handoffs that were not atomic — resolved as the requested consolidated lifecycle-lease pass. - Quiesce reads leases BEFORE the active-job scan. The admission-lease -> durable -job handoff is only atomic against a reader in the OPPOSITE order of the writer: writers hold the lease strictly until the job is active-set visible, so leases-first shows every interleaving either the lease or the job. Jobs-first allowed a request to create its job after the scan and release its lease before the count — hiding both, cascading, and letting the new generation persist into a deleted account. - The abort acknowledgement is fenced by the owner-lifecycle lease. Redis ACKed the moment the owner's AbortController tripped; the stopping side released its lease on that ACK while the owner's asynchronous abort-catch persistence was still ahead. The transport now awaits a manager-installed pre-ACK hook that registers a DETERMINISTIC owner lease (exactly one owner exists per generation, and determinism is what lets the signal-time registrant and the owner's catch-side release agree across processes) before the acknowledgement is persisted or published; an owned same-replica abort bridges to the same lease before tripping its local controller. Both generation-owner catches (fresh turn, resume) release it once their writes land. - A failed replacement handoff no longer orphans the predecessor. The atomic replacement removes it from active storage, and an unconfirmed handoff terminalizes the replacement too — leaving nothing a quiesce could discover while the predecessor's provider may still be generating. Its owner lease is now retained at the point the receipt fails delivery; the owner replica renews it through the pre-ACK fence when the signal finally lands. - Leases HEARTBEAT while held. The five-minute store TTL only bounds a crashed holder; live persistence — a stalled save, a long deferred title — must never outlive its own fence. holdUserFinalization registers and renews every minute until released; the controllers' completion/error/admission leases all hold. The undelivered-Stop retention moved to a deterministic `stop` lease that every resignal attempt renews and the first successful one clears (no more opaque leases accumulating to TTL), and a THROWN abort transition releases the contender lease instead of leaking it. - The user-document abort-fence mutations now invalidate the auth user-doc cache, matching every other user-doc write. Barrier tests, each verified to fail without its fix: quiesce lease-scan ordering (plus the observed-lease defer), pre-ACK fence ordering at the transport, owned-abort owner-lease bridging, replacement-handoff predecessor retention, held-lease heartbeat past the TTL, and failed-then-successful resignal reaping the retained stop lease.
1108 lines
42 KiB
JavaScript
1108 lines
42 KiB
JavaScript
const mongoose = require('mongoose');
|
|
const {
|
|
logger,
|
|
getTenantId,
|
|
webSearchKeys,
|
|
runAsSystem,
|
|
tenantStorage,
|
|
UNREADABLE_ABORT_FENCE,
|
|
} = require('@librechat/data-schemas');
|
|
const {
|
|
getNewS3URL,
|
|
needsRefresh,
|
|
GenerationJobManager,
|
|
MCPOAuthHandler,
|
|
MCPTokenStorage,
|
|
getAppConfigOptionsFromUser,
|
|
normalizeHttpError,
|
|
extractWebSearchEnvVars,
|
|
deleteAgentCheckpoints,
|
|
deleteAllSharedLinksWithCleanup,
|
|
registerShutdownTask,
|
|
GenerationJobManager,
|
|
} = require('@librechat/api');
|
|
const {
|
|
Tools,
|
|
CacheKeys,
|
|
Constants,
|
|
FileSources,
|
|
ResourceType,
|
|
} = 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, getFlowStateManager, getMCPServersRegistry } = require('~/config');
|
|
const { invalidateCachedTools } = require('~/server/services/Config/getCachedTools');
|
|
const { processDeleteRequest } = require('~/server/services/Files/process');
|
|
const subagentThreadTaskStore = require('~/server/services/Endpoints/agents/subagentThreadStore');
|
|
const {
|
|
drainAgentTriggerDeliveriesForUser,
|
|
prepareAgentTriggerUserPurge,
|
|
cancelAgentTriggerUserPurge,
|
|
purgeAgentTriggerDeliveriesForUser,
|
|
} = require('~/server/services/Agents/triggers');
|
|
const { getAppConfig } = require('~/server/services/Config');
|
|
const { getLogStores } = require('~/cache');
|
|
const db = require('~/models');
|
|
|
|
const PUBLIC_USER_RESPONSE_FIELDS = [
|
|
'_id',
|
|
'id',
|
|
'name',
|
|
'username',
|
|
'email',
|
|
'emailVerified',
|
|
'avatar',
|
|
'provider',
|
|
'role',
|
|
'plugins',
|
|
'twoFactorEnabled',
|
|
'termsAccepted',
|
|
'personalization',
|
|
'favorites',
|
|
'skillStates',
|
|
'createdAt',
|
|
'updatedAt',
|
|
'tenantId',
|
|
];
|
|
|
|
const sanitizeUserForResponse = (user) => {
|
|
const source = user.toObject != null ? user.toObject() : user;
|
|
return PUBLIC_USER_RESPONSE_FIELDS.reduce((userData, field) => {
|
|
if (source[field] !== undefined) {
|
|
userData[field] = source[field];
|
|
}
|
|
return userData;
|
|
}, {});
|
|
};
|
|
|
|
const getUserController = async (req, res) => {
|
|
const appConfig = req.config ?? (await getAppConfig(getAppConfigOptionsFromUser(req.user)));
|
|
/** @type {IUser} */
|
|
const userData = sanitizeUserForResponse(req.user);
|
|
if (appConfig.fileStrategy === FileSources.s3 && userData.avatar) {
|
|
const avatarNeedsRefresh = needsRefresh(userData.avatar, 3600);
|
|
if (!avatarNeedsRefresh) {
|
|
return res.status(200).send(userData);
|
|
}
|
|
const originalAvatar = userData.avatar;
|
|
try {
|
|
userData.avatar = await getNewS3URL(userData.avatar);
|
|
await db.updateUser(userData.id, { avatar: userData.avatar });
|
|
} catch (error) {
|
|
userData.avatar = originalAvatar;
|
|
logger.error('Error getting new S3 URL for avatar:', error);
|
|
}
|
|
}
|
|
res.status(200).send(userData);
|
|
};
|
|
|
|
const getTermsStatusController = async (req, res) => {
|
|
try {
|
|
const user = await db.getUserById(req.user.id, 'termsAccepted termsAcceptedAt');
|
|
if (!user) {
|
|
return res.status(404).json({ message: 'User not found' });
|
|
}
|
|
res.status(200).json({
|
|
termsAccepted: !!user.termsAccepted,
|
|
termsAcceptedAt: user.termsAcceptedAt || null,
|
|
});
|
|
} catch (error) {
|
|
logger.error('Error fetching terms acceptance status:', error);
|
|
res.status(500).json({ message: 'Error fetching terms acceptance status' });
|
|
}
|
|
};
|
|
|
|
const acceptTermsController = async (req, res) => {
|
|
try {
|
|
const user = await db.acceptTerms(req.user.id);
|
|
if (!user) {
|
|
return res.status(404).json({ message: 'User not found' });
|
|
}
|
|
res.status(200).json({
|
|
message: 'Terms accepted successfully',
|
|
termsAcceptedAt: user.termsAcceptedAt,
|
|
});
|
|
} catch (error) {
|
|
logger.error('Error accepting terms:', error);
|
|
res.status(500).json({ message: 'Error accepting terms' });
|
|
}
|
|
};
|
|
|
|
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);
|
|
}
|
|
};
|
|
|
|
const updateUserPluginsController = async (req, res) => {
|
|
const appConfig = req.config ?? (await getAppConfig(getAppConfigOptionsFromUser(req.user)));
|
|
const { user } = req;
|
|
const { pluginKey, action, auth, isEntityTool } = req.body;
|
|
try {
|
|
if (!isEntityTool) {
|
|
await db.updateUserPlugins(user._id, user.plugins, pluginKey, action);
|
|
}
|
|
|
|
if (auth == null) {
|
|
return res.status(200).send();
|
|
}
|
|
|
|
let keys = Object.keys(auth);
|
|
const values = Object.values(auth); // Used in 'install' block
|
|
|
|
const isMCPTool = pluginKey.startsWith('mcp_') || pluginKey.includes(Constants.mcp_delimiter);
|
|
|
|
// Early exit condition:
|
|
// If keys are empty (meaning auth: {} was likely sent for uninstall, or auth was empty for install)
|
|
// AND it's not web_search (which has special key handling to populate `keys` for uninstall)
|
|
// AND it's NOT (an uninstall action FOR an MCP tool - we need to proceed for this case to clear all its auth)
|
|
// THEN return.
|
|
if (
|
|
keys.length === 0 &&
|
|
pluginKey !== Tools.web_search &&
|
|
!(action === 'uninstall' && isMCPTool)
|
|
) {
|
|
return res.status(200).send();
|
|
}
|
|
|
|
/** @type {number} */
|
|
let status = 200;
|
|
/** @type {string} */
|
|
let message;
|
|
/** @type {IPluginAuth | Error} */
|
|
let authService;
|
|
|
|
if (pluginKey === Tools.web_search) {
|
|
/** @type {TCustomConfig['webSearch']} */
|
|
const webSearchConfig = appConfig?.webSearch;
|
|
keys = extractWebSearchEnvVars({
|
|
keys: action === 'install' ? keys : webSearchKeys,
|
|
config: webSearchConfig,
|
|
});
|
|
}
|
|
|
|
if (action === 'install') {
|
|
for (let i = 0; i < keys.length; i++) {
|
|
authService = await updateUserPluginAuth(user.id, keys[i], pluginKey, values[i]);
|
|
if (authService instanceof Error) {
|
|
logger.error('[authService]', authService);
|
|
({ status, message } = normalizeHttpError(authService));
|
|
}
|
|
}
|
|
} else if (action === 'uninstall') {
|
|
// const isMCPTool was defined earlier
|
|
if (isMCPTool && keys.length === 0) {
|
|
// This handles the case where auth: {} is sent for an MCP tool uninstall.
|
|
// It means "delete all credentials associated with this MCP pluginKey".
|
|
authService = await deleteUserPluginAuth(user.id, null, true, pluginKey);
|
|
if (authService instanceof Error) {
|
|
logger.error(
|
|
`[authService] Error deleting all auth for MCP tool ${pluginKey}:`,
|
|
authService,
|
|
);
|
|
({ status, message } = normalizeHttpError(authService));
|
|
}
|
|
try {
|
|
// if the MCP server uses OAuth, perform a full cleanup and token revocation
|
|
await maybeUninstallOAuthMCP(user.id, pluginKey, appConfig);
|
|
} catch (error) {
|
|
logger.error(
|
|
`[updateUserPluginsController] Error uninstalling OAuth MCP for ${pluginKey}:`,
|
|
error,
|
|
);
|
|
}
|
|
} else {
|
|
// This handles:
|
|
// 1. Web_search uninstall (keys will be populated with all webSearchKeys if auth was {}).
|
|
// 2. Other tools uninstall (if keys were provided).
|
|
// 3. MCP tool uninstall if specific keys were provided in `auth` (not current frontend behavior).
|
|
// If keys is empty for non-MCP tools (and not web_search), this loop won't run, and nothing is deleted.
|
|
for (let i = 0; i < keys.length; i++) {
|
|
authService = await deleteUserPluginAuth(user.id, keys[i]); // Deletes by authField name
|
|
if (authService instanceof Error) {
|
|
logger.error('[authService] Error deleting specific auth key:', authService);
|
|
({ status, message } = normalizeHttpError(authService));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (status === 200) {
|
|
// If auth was updated successfully, disconnect MCP sessions as they might use these credentials
|
|
if (pluginKey.startsWith(Constants.mcp_prefix)) {
|
|
try {
|
|
const mcpManager = getMCPManager();
|
|
// Extract server name from pluginKey (format: "mcp_<serverName>")
|
|
const serverName = pluginKey.replace(Constants.mcp_prefix, '');
|
|
if (mcpManager) {
|
|
logger.info(
|
|
`[updateUserPluginsController] Attempting disconnect of MCP server "${serverName}" for user ${user.id} after plugin auth update.`,
|
|
);
|
|
}
|
|
let invalidationError;
|
|
try {
|
|
await invalidateCachedTools({ userId: user.id, serverName });
|
|
} catch (error) {
|
|
invalidationError = error;
|
|
}
|
|
try {
|
|
await mcpManager?.disconnectUserConnection(user.id, serverName);
|
|
} catch (error) {
|
|
logger.error(
|
|
`[updateUserPluginsController] Error disconnecting MCP connection for user ${user.id} after plugin auth update:`,
|
|
error,
|
|
);
|
|
}
|
|
if (invalidationError) {
|
|
throw invalidationError;
|
|
}
|
|
} catch (disconnectError) {
|
|
logger.error(
|
|
`[updateUserPluginsController] Error fencing MCP connection for user ${user.id} after plugin auth update:`,
|
|
disconnectError,
|
|
);
|
|
// A credential mutation is not safely published until the shared generation fence moves.
|
|
throw disconnectError;
|
|
}
|
|
}
|
|
return res.status(status).send();
|
|
}
|
|
|
|
const normalized = normalizeHttpError({ status, message });
|
|
return res.status(normalized.status).send({ message: normalized.message });
|
|
} catch (err) {
|
|
logger.error('[updateUserPluginsController]', err);
|
|
return res.status(500).json({ message: 'Something went wrong.' });
|
|
}
|
|
};
|
|
|
|
const deleteUserController = async (req, res) => {
|
|
const { user } = req;
|
|
let triggerDeletionFence;
|
|
let userDeleted = false;
|
|
|
|
try {
|
|
const existingUser = await db.getUserById(
|
|
user.id,
|
|
'+totpSecret +backupCodes _id twoFactorEnabled',
|
|
);
|
|
if (existingUser && existingUser.twoFactorEnabled) {
|
|
const { token, backupCode } = req.body;
|
|
const result = await verifyOTPOrBackupCode({ user: existingUser, token, backupCode });
|
|
|
|
if (!result.verified) {
|
|
const msg =
|
|
result.message ??
|
|
'TOTP token or backup code is required to delete account with 2FA enabled';
|
|
return res.status(result.status ?? 400).json({ message: msg });
|
|
}
|
|
}
|
|
|
|
// Block new trigger admissions across replicas while preserving the user
|
|
// principal so a transient cleanup failure remains retryable.
|
|
triggerDeletionFence = new Date();
|
|
const fenceState = await db.beginAgentTriggerUserDeletion(user.id, triggerDeletionFence);
|
|
if (fenceState === 'in_progress') {
|
|
triggerDeletionFence = undefined;
|
|
throw new Error('Agent trigger account deletion is already in progress');
|
|
}
|
|
if (fenceState === 'missing') {
|
|
triggerDeletionFence = undefined;
|
|
}
|
|
if (triggerDeletionFence != null) {
|
|
await prepareAgentTriggerUserPurge(user.id, triggerDeletionFence, user.tenantId);
|
|
}
|
|
await drainAgentTriggerDeliveriesForUser(user.id);
|
|
await subagentThreadTaskStore.cancelAndDrainForOwner(user.id, user.tenantId);
|
|
const activeAgentRuns = await GenerationJobManager.getCleanupBlockingJobIdsForUser(
|
|
user.id,
|
|
user.tenantId,
|
|
);
|
|
await Promise.all(
|
|
activeAgentRuns.map((streamId) =>
|
|
GenerationJobManager.abortJob(streamId, { awaitProviderDrain: true }),
|
|
),
|
|
);
|
|
|
|
await db.deleteMessages({ user: user.id });
|
|
await db.deleteAllUserSessions({ userId: 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);
|
|
try {
|
|
const convoDeletion = await db.deleteConvos(user.id);
|
|
// HITL: prune the deleted conversations' durable checkpoints — a paused run's
|
|
// checkpoint would otherwise persist until the Mongo TTL. Never throws.
|
|
const appConfig =
|
|
req.config ??
|
|
(await getAppConfig({
|
|
role: req.user?.role,
|
|
userId: req.user?.id,
|
|
tenantId: req.user?.tenantId,
|
|
}));
|
|
await deleteAgentCheckpoints(
|
|
convoDeletion?.conversationIds,
|
|
appConfig?.endpoints?.agents?.checkpointer,
|
|
);
|
|
} catch (error) {
|
|
logger.error('[deleteUserController] Error deleting user convos, likely no convos', error);
|
|
}
|
|
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 });
|
|
const deleteResult = await db.deleteUserById(user.id);
|
|
if (deleteResult.deletedCount !== 1) {
|
|
throw new Error('User disappeared before account deletion could commit');
|
|
}
|
|
userDeleted = true;
|
|
await purgeAgentTriggerDeliveriesForUser(user.id);
|
|
logger.info(`User deleted account. Email: ${user.email} ID: ${user.id}`);
|
|
res.status(200).send({ message: 'User deleted' });
|
|
} catch (err) {
|
|
if (triggerDeletionFence != null && !userDeleted) {
|
|
try {
|
|
await cancelAgentTriggerUserPurge(user.id, triggerDeletionFence);
|
|
} catch (purgeFenceError) {
|
|
logger.error(
|
|
'[deleteUserController] Failed to disarm trigger purge recovery',
|
|
purgeFenceError,
|
|
);
|
|
}
|
|
try {
|
|
await db.cancelAgentTriggerUserDeletion(user.id, triggerDeletionFence);
|
|
} catch (fenceError) {
|
|
logger.error('[deleteUserController] Failed to release trigger deletion fence', fenceError);
|
|
}
|
|
}
|
|
logger.error('[deleteUserController]', err);
|
|
return res.status(500).json({ message: 'Something went wrong.' });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Interactive-generation quiesce: aborts the user's active interactive jobs and
|
|
* reports whether the cascade may proceed. Settlement is NOT provable within the
|
|
* pass that aborts — a job leaves the active set the moment the abort CAS lands,
|
|
* BEFORE the generation owner's asynchronous message/usage/balance writes drain —
|
|
* so ANY discovered job (and any unreadable store: fail closed) defers the cascade
|
|
* to a later pass. By the next pass the aborted owners have long unwound, and the
|
|
* auth barrier guarantees nothing new started in between; an empty enumeration is
|
|
* then a real settlement signal, not a race. Cross-replica delivery of the abort
|
|
* remains unconfirmed by design (see FOLLOWUPS) — the deferral bounds that window
|
|
* to the sweep interval instead of racing the cascade against it.
|
|
*/
|
|
/**
|
|
* Settlement attempt for one durable abort fence — a deletion-side abort whose signal
|
|
* provably never left the aborting replica. The shared job went terminal at the abort
|
|
* CAS, so the peer OWNER may still be generating with nothing in the active set to
|
|
* show for it; the fence is the evidence, and it clears only on an acknowledgeable
|
|
* outcome: the publish finally leaves this replica (delivered or republished), or the
|
|
* job is gone/reassigned (the owner finished and cleaned up, so its writes are done).
|
|
* Anything else keeps the fence and defers.
|
|
*/
|
|
const settleAbortFence = async (user, streamId) => {
|
|
if (streamId === UNREADABLE_ABORT_FENCE) {
|
|
return false;
|
|
}
|
|
let job;
|
|
try {
|
|
job = await GenerationJobManager.getJob(streamId);
|
|
} catch (error) {
|
|
logger.warn(`[quiesceInteractiveGenerations] Could not read job ${streamId}`, error);
|
|
return false;
|
|
}
|
|
// OWNERSHIP from the facade's metadata, not the top level: getJob returns a
|
|
// GenerationJob whose owner lives at `metadata.userId`, so comparing `job.userId`
|
|
// read undefined and cleared every fence as "reassigned" without ever re-signalling.
|
|
const ownerId = job?.metadata?.userId;
|
|
const ownerTenantId = job?.metadata?.tenantId;
|
|
if (
|
|
job == null ||
|
|
ownerId !== user.id ||
|
|
(ownerTenantId ?? undefined) !== (user.tenantId ?? undefined)
|
|
) {
|
|
await db.clearUserAbortFence(user.id, streamId).catch((err) => {
|
|
logger.warn(`[quiesceInteractiveGenerations] Failed to clear fence ${streamId}`, err);
|
|
});
|
|
return false;
|
|
}
|
|
// EVERY status whose owner is still persisting is unsettled — complete, error,
|
|
// AND aborted (the Stop route's checkpoint prune / partial save run behind the
|
|
// abort CAS), plus a barrier-held pause. Keep the fence and defer: the owner
|
|
// clears the flag when its writes land, and stale-owner recovery bounds the wait.
|
|
if (job.terminalPersistencePending === true) {
|
|
return false;
|
|
}
|
|
if (job.status === 'running' || job.status === 'requires_action') {
|
|
// Live again despite terminal-at-CAS bookkeeping: re-abort and keep the fence.
|
|
await GenerationJobManager.abortJob(streamId).catch(() => undefined);
|
|
return false;
|
|
}
|
|
if (job.status === 'complete' || job.status === 'error') {
|
|
// The generation reached its OWN terminal — the run ended by its own means, so
|
|
// there is no stop left to deliver and re-signalling (aborted-only) could never
|
|
// clear this fence; it would sit permanent, deferring deletion forever. Any
|
|
// post-terminal billed work is what the owner-finalization markers above fence.
|
|
await db.clearUserAbortFence(user.id, streamId).catch((err) => {
|
|
logger.warn(`[quiesceInteractiveGenerations] Failed to clear fence ${streamId}`, err);
|
|
});
|
|
return false;
|
|
}
|
|
const resignal = await GenerationJobManager.resignalAbort(streamId, job.createdAt).catch(() => ({
|
|
delivered: false,
|
|
published: false,
|
|
}));
|
|
if (!resignal.delivered && !resignal.published) {
|
|
return false;
|
|
}
|
|
try {
|
|
await db.clearUserAbortFence(user.id, streamId);
|
|
} catch (error) {
|
|
// The signal left, but the fence is still durable: report unsettled so a later
|
|
// pass retries the clear rather than cascading on an unrecorded acknowledgement.
|
|
logger.warn(`[quiesceInteractiveGenerations] Failed to clear fence ${streamId}`, error);
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* Drains the user's in-flight interactive generations before the destructive cascade.
|
|
*
|
|
* SCOPE: this covers work enrolled in GenerationJobManager — the agents chat path and
|
|
* scheduled fires. The remote OpenAI-compatible and Responses controllers run on
|
|
* private per-request abort controllers this quiesce cannot see, so an
|
|
* already-admitted request there (notably Responses `store: true`) can persist
|
|
* conversations/messages/usage after the cascade. That gap predates this barrier
|
|
* (those paths were never drainable) and is tracked as a follow-up (see issue 14594):
|
|
* enrolling them in the job manager so deletion can fence them like everything else.
|
|
*/
|
|
const quiesceInteractiveGenerations = async (user) => {
|
|
// MARKERS BEFORE THE ACTIVE SCAN — the read order is what makes the admission
|
|
// lease -> durable job handoff atomic from this side. Writers hold the lease
|
|
// strictly until the job is active-set visible, so with leases read FIRST, any
|
|
// interleaving either shows the lease here or the job below; jobs-first allowed
|
|
// a request to create its job after this scan and release its lease before the
|
|
// count, hiding both. The count itself gates settlement further down; this early
|
|
// read only has to ORDER before the job scan.
|
|
const earlyPendingOwnerWork = await GenerationJobManager.countUserFinalizations(
|
|
user.id,
|
|
user.tenantId,
|
|
);
|
|
const activeJobIds = await GenerationJobManager.getActiveJobIdsForUser(user.id, user.tenantId);
|
|
for (const streamId of activeJobIds ?? []) {
|
|
// FENCE BEFORE THE CAS. An abort transitions the shared job to terminal, which
|
|
// hides it from every later active-set scan; if the signal then turns out never
|
|
// to have left this replica, the only thing standing between a still-generating
|
|
// peer and the destructive cascade is this record. Stamping it first makes a
|
|
// write failure harmless — nothing has been aborted yet, so refusing simply
|
|
// defers. (Cleared below the moment the abort is acknowledged, so the common
|
|
// case leaves nothing behind.)
|
|
try {
|
|
await db.addUserAbortFence(user.id, streamId);
|
|
} catch (error) {
|
|
logger.warn(
|
|
`[quiesceInteractiveGenerations] Deferring ${user.id}: could not fence abort of ${streamId}`,
|
|
error,
|
|
);
|
|
return false;
|
|
}
|
|
const result = await GenerationJobManager.abortJob(streamId).catch((err) => {
|
|
logger.warn(`[quiesceInteractiveGenerations] Failed to abort active job ${streamId}`, err);
|
|
return null;
|
|
});
|
|
// Clearing requires POSITIVE evidence — a won abort whose signal fields say the
|
|
// stop was delivered or at least left this replica. Everything else is
|
|
// inconclusive: a THROW can land after the terminal CAS (content refresh, required
|
|
// persistence, publication), and a `success: false` result carries NO signal
|
|
// fields at all (job already terminal — e.g. a concurrent Stop whose own publish
|
|
// failed — or a lost CAS), so testing `!== false` read those absent fields as
|
|
// acknowledgement and cleared the one record standing between a still-generating
|
|
// peer and the destructive cascade. Keep the fence: this pass defers on the
|
|
// active-set check below, and `settleAbortFence` re-signals and settles it on a
|
|
// later pass (or in the deferred-deletion sweep) — including clearing it for a
|
|
// run that reached its own complete/error terminal, so fences never go permanent.
|
|
const acknowledged =
|
|
result?.success === true &&
|
|
(result.signalDelivered !== false || result.signalPublished !== false);
|
|
if (acknowledged) {
|
|
await db.clearUserAbortFence(user.id, streamId).catch((err) => {
|
|
logger.warn(`[quiesceInteractiveGenerations] Failed to clear fence ${streamId}`, err);
|
|
});
|
|
} else {
|
|
await GenerationJobManager.resignalAbort(streamId).catch(() => undefined);
|
|
}
|
|
}
|
|
if (activeJobIds?.length) {
|
|
return false;
|
|
}
|
|
// Settlement needs positive evidence, not an empty active set: the success path
|
|
// completes its job fire-and-forget and then runs the deferred title, whose billed
|
|
// balance/transaction writes land AFTER the job left the set, and a deletion-side
|
|
// abort can win its CAS without its signal ever leaving this replica. Two fences
|
|
// cover those: TTL-bounded job-store markers the OWNER clears once its writes land,
|
|
// and durable (TTL-free, so an outage can never read as settlement) abort fences on
|
|
// the user document. Multi-replica deployments require the Redis job store (see
|
|
// isTopologySafeToArm), where the owner markers are cross-replica visible.
|
|
const pendingOwnerWork =
|
|
earlyPendingOwnerWork > 0
|
|
? earlyPendingOwnerWork
|
|
: await GenerationJobManager.countUserFinalizations(user.id, user.tenantId);
|
|
if (pendingOwnerWork > 0) {
|
|
logger.info(
|
|
`[quiesceInteractiveGenerations] ${pendingOwnerWork} owner finalization(s) still landing for ${user.id}`,
|
|
);
|
|
return false;
|
|
}
|
|
const fences = await db.getUserAbortFences(user.id);
|
|
if (fences.length === 0) {
|
|
return true;
|
|
}
|
|
let allSettled = true;
|
|
for (const streamId of fences) {
|
|
const settled = await settleAbortFence(user, streamId);
|
|
allSettled = allSettled && settled;
|
|
}
|
|
if (!allSettled) {
|
|
logger.info(
|
|
`[quiesceInteractiveGenerations] unacknowledged abort(s) still fencing ${user.id}; deferring`,
|
|
);
|
|
}
|
|
return allSettled;
|
|
};
|
|
|
|
/**
|
|
* The destructive account-deletion cascade. Runs only AFTER the durable barrier is up
|
|
* and BOTH quiesces (scheduled runs, interactive generations) confirmed settlement.
|
|
* Shared by the interactive controller and the deferred-deletion sweep: a quiesce that
|
|
* could not confirm defers with the barrier still raised, and authentication is
|
|
* refused behind the barrier, so no client retry can ever arrive — the sweep is the
|
|
* promised retry.
|
|
*/
|
|
const executeUserDeletion = async (user, providedAppConfig) => {
|
|
const appConfig =
|
|
providedAppConfig ??
|
|
(await getAppConfig({
|
|
role: user.role,
|
|
userId: user.id,
|
|
tenantId: user.tenantId,
|
|
}));
|
|
/** Minimal request shim for the file-deletion service (reads user, config, body). */
|
|
const req = { user, config: appConfig, body: {} };
|
|
await db.deleteMessages({ user: user.id });
|
|
await db.deleteAllUserSessions({ userId: 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);
|
|
try {
|
|
const convoDeletion = await db.deleteConvos(user.id);
|
|
// HITL: prune the deleted conversations' durable checkpoints — a paused run's
|
|
// checkpoint would otherwise persist until the Mongo TTL. Never throws.
|
|
await deleteAgentCheckpoints(
|
|
convoDeletion?.conversationIds,
|
|
appConfig?.endpoints?.agents?.checkpointer,
|
|
);
|
|
} catch (error) {
|
|
logger.error('[executeUserDeletion] Error deleting user convos, likely no convos', error);
|
|
}
|
|
await deleteUserPluginAuth(user.id, null, true);
|
|
await db.deleteSchedulesByUser(user.id);
|
|
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 });
|
|
// The user document goes LAST: it is the retry marker. Every step above is an
|
|
// idempotent bulk delete, so an interruption (crash, SIGTERM mid-sweep) leaves the
|
|
// document and its deletion markers in place and the next pass re-runs the whole
|
|
// cascade; deleting the document earlier made everything after it unreachable —
|
|
// getUsersPendingDeletion could no longer rediscover the account, permanently
|
|
// orphaning shared links, files, agents, and the rest. Authentication is refused
|
|
// behind the barrier the whole time, so the surviving document admits nothing.
|
|
await db.deleteUserById(user.id);
|
|
logger.info(`User deleted account. Email: ${user.email} ID: ${user.id}`);
|
|
};
|
|
|
|
/** Deferred deletions retried per sweep pass; small — deferral is a rare race. */
|
|
const PENDING_DELETION_BATCH = 5;
|
|
/** Head start for the interactive request that raised the barrier (or a local-auth
|
|
* retry) before the sweep competes with it. */
|
|
const PENDING_DELETION_MIN_AGE_MS = 60_000;
|
|
|
|
/**
|
|
* Finishes account deletions that deferred on an unconfirmed schedule quiesce. The
|
|
* barrier is durable and blocks authentication, so without this pass a deferred
|
|
* OpenID account stays locked-but-undeleted with no way to issue the promised retry.
|
|
* Every step is idempotent and the window rotates, so concurrent workers are safe.
|
|
*/
|
|
const processPendingUserDeletions = async () => {
|
|
// System context for the cross-tenant scan and stamp; strict tenant isolation
|
|
// would otherwise throw on this timer-driven pass (no request, no ALS context)
|
|
// and every deferred user would stay locked behind the barrier forever.
|
|
const pending = await runAsSystem(() => db.getUsersPendingDeletion(PENDING_DELETION_BATCH));
|
|
const due = pending.filter(
|
|
(user) =>
|
|
user.deletionRequestedAt != null &&
|
|
Date.now() - new Date(user.deletionRequestedAt).getTime() >= PENDING_DELETION_MIN_AGE_MS,
|
|
);
|
|
if (due.length === 0) {
|
|
return;
|
|
}
|
|
await runAsSystem(() =>
|
|
db.markDeletionSweepAttempted(due.map((user) => user._id.toString())),
|
|
).catch((err) => logger.warn('[processPendingUserDeletions] Failed to stamp attempts', err));
|
|
for (const pendingUser of due) {
|
|
const user = { ...pendingUser, id: pendingUser._id.toString() };
|
|
// Each user's quiesce + cascade runs in THEIR tenant context, matching the
|
|
// interactive controller's request-scoped context.
|
|
await tenantStorage.run({ tenantId: user.tenantId, userId: user.id }, async () => {
|
|
try {
|
|
// RE-ESTABLISH the auth-cache fence before cascading. markUserDeleting can
|
|
// stamp Mongo and then throw on its REQUIRED invalidation; the controller
|
|
// 503s, but both markers already exist, so this sweep would otherwise run
|
|
// the cascade behind a fence that was never confirmed — a surviving cached
|
|
// document could admit a generation that outlives the sweep delay. The call
|
|
// is idempotent (monotonic stamp) and fail-closed; a throw defers this user
|
|
// to a later pass with the barrier still up.
|
|
try {
|
|
await db.markUserDeleting(user.id);
|
|
} catch (fenceError) {
|
|
logger.warn(
|
|
`[processPendingUserDeletions] Deferring ${user.id}: auth-cache fence could not be established`,
|
|
fenceError,
|
|
);
|
|
return;
|
|
}
|
|
const quiesced = await quiesceUserSchedules(user.id).catch((error) => {
|
|
logger.error(`[processPendingUserDeletions] Quiesce failed for ${user.id}`, error);
|
|
return false;
|
|
});
|
|
if (!quiesced) {
|
|
logger.warn(
|
|
`[processPendingUserDeletions] Deferring ${user.id} again: scheduled runs did not confirm settlement`,
|
|
);
|
|
return;
|
|
}
|
|
const interactiveSettled = await quiesceInteractiveGenerations(user).catch((error) => {
|
|
logger.error(
|
|
`[processPendingUserDeletions] Interactive quiesce failed for ${user.id}`,
|
|
error,
|
|
);
|
|
return false;
|
|
});
|
|
if (!interactiveSettled) {
|
|
logger.warn(
|
|
`[processPendingUserDeletions] Deferring ${user.id} again: interactive generations are still settling`,
|
|
);
|
|
return;
|
|
}
|
|
await executeUserDeletion(user);
|
|
} catch (error) {
|
|
logger.error(`[processPendingUserDeletions] Cascade failed for ${user.id}`, error);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
const PENDING_DELETION_SWEEP_INTERVAL_MS = 5 * 60_000;
|
|
let pendingDeletionSweepStarted = false;
|
|
let pendingDeletionSweepStopped = false;
|
|
/** The in-flight pass, so graceful shutdown can drain it instead of truncating a
|
|
* cascade mid-write. The user-document-last ordering makes even a hard kill
|
|
* recoverable; this keeps the ORDERLY path from relying on that backstop. */
|
|
let activePendingDeletionPass = null;
|
|
|
|
/** Idempotent per process; safe in every worker (the pass itself is idempotent). */
|
|
const startPendingDeletionSweep = () => {
|
|
if (pendingDeletionSweepStarted) {
|
|
return;
|
|
}
|
|
pendingDeletionSweepStarted = true;
|
|
// Production disables Mongoose autoIndex, so the partial
|
|
// (deletionSweepAt, deletionRequestedAt) index the sweep scans on is never built
|
|
// there by schema declaration alone — build it explicitly, best-effort.
|
|
db.ensureUserDeletionIndexes?.().catch((err) =>
|
|
logger.warn('[startPendingDeletionSweep] Failed to ensure deletion indexes', err),
|
|
);
|
|
const run = () => {
|
|
if (pendingDeletionSweepStopped) {
|
|
return;
|
|
}
|
|
activePendingDeletionPass = processPendingUserDeletions()
|
|
.catch((err) => logger.error('[startPendingDeletionSweep] Sweep pass failed', err))
|
|
.finally(() => {
|
|
activePendingDeletionPass = null;
|
|
});
|
|
};
|
|
const timer = setInterval(run, PENDING_DELETION_SWEEP_INTERVAL_MS);
|
|
timer.unref?.();
|
|
setTimeout(run, PENDING_DELETION_MIN_AGE_MS).unref?.();
|
|
registerShutdownTask('pending deletion sweep', async () => {
|
|
pendingDeletionSweepStopped = true;
|
|
clearInterval(timer);
|
|
if (activePendingDeletionPass) {
|
|
await activePendingDeletionPass;
|
|
}
|
|
});
|
|
};
|
|
|
|
const verifyEmailController = async (req, res) => {
|
|
try {
|
|
const verifyEmailService = await verifyEmail(req);
|
|
if (verifyEmailService instanceof Error) {
|
|
return res.status(400).json({ message: verifyEmailService.message });
|
|
} else {
|
|
return res.status(200).json(verifyEmailService);
|
|
}
|
|
} catch (e) {
|
|
logger.error('[verifyEmailController]', e);
|
|
return res.status(500).json({ message: 'Something went wrong.' });
|
|
}
|
|
};
|
|
|
|
const resendVerificationController = async (req, res) => {
|
|
try {
|
|
const result = await resendVerificationEmail(req);
|
|
if (result instanceof Error) {
|
|
return res.status(400).json({ message: result.message });
|
|
} else {
|
|
return res.status(result.status ?? 200).json({ message: result.message });
|
|
}
|
|
} catch (e) {
|
|
logger.error('[verifyEmailController]', e);
|
|
return res.status(500).json({ message: 'Something went wrong.' });
|
|
}
|
|
};
|
|
|
|
/** Best-effort cleanup of stored MCP OAuth tokens and flow state. */
|
|
const clearStoredMCPOAuthState = async (userId, serverName) => {
|
|
try {
|
|
await MCPTokenStorage.deleteUserTokens({
|
|
userId,
|
|
serverName,
|
|
deleteToken: async (filter) => {
|
|
await db.deleteTokens(filter);
|
|
},
|
|
});
|
|
} catch (error) {
|
|
logger.warn(
|
|
`[clearStoredMCPOAuthState] Failed to delete MCP OAuth tokens for ${serverName}:`,
|
|
error,
|
|
);
|
|
}
|
|
|
|
try {
|
|
const flowsCache = getLogStores(CacheKeys.FLOWS);
|
|
const flowManager = getFlowStateManager(flowsCache);
|
|
const baseFlowId = MCPOAuthHandler.generateFlowId(userId, serverName);
|
|
const tenantId = getTenantId();
|
|
const tokenFlowId = MCPOAuthHandler.generateTokenFlowId(userId, serverName, tenantId);
|
|
const oauthFlowId = MCPOAuthHandler.generateFlowId(userId, serverName, tenantId);
|
|
const flowDeletes = [
|
|
[tokenFlowId, 'mcp_get_tokens'],
|
|
[oauthFlowId, 'mcp_oauth'],
|
|
[baseFlowId, 'mcp_get_tokens'],
|
|
[baseFlowId, 'mcp_oauth'],
|
|
].filter(
|
|
([flowId, type], index, deletes) =>
|
|
deletes.findIndex(([candidateId, candidateType]) => {
|
|
return candidateId === flowId && candidateType === type;
|
|
}) === index,
|
|
);
|
|
const results = await Promise.allSettled(
|
|
flowDeletes.map(([flowId, type]) =>
|
|
type === 'mcp_oauth'
|
|
? MCPOAuthHandler.deleteFlowAndStateMapping(flowId, flowManager)
|
|
: flowManager.deleteFlow(flowId, type),
|
|
),
|
|
);
|
|
for (const result of results) {
|
|
if (result.status === 'rejected') {
|
|
logger.warn(
|
|
`[clearStoredMCPOAuthState] Failed to clear MCP OAuth flow state for ${serverName}:`,
|
|
result.reason,
|
|
);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
logger.warn(
|
|
`[clearStoredMCPOAuthState] Failed to clear MCP OAuth flow state for ${serverName}:`,
|
|
error,
|
|
);
|
|
}
|
|
};
|
|
|
|
/** Revokes MCP OAuth tokens at the provider when possible, then clears local state. */
|
|
const maybeUninstallOAuthMCP = async (userId, pluginKey, appConfig) => {
|
|
if (!pluginKey.startsWith(Constants.mcp_prefix)) {
|
|
// this is not an MCP server, so nothing to do here
|
|
return;
|
|
}
|
|
|
|
const serverName = pluginKey.replace(Constants.mcp_prefix, '');
|
|
const serverConfig =
|
|
(await getMCPServersRegistry().getServerConfig(serverName, userId)) ??
|
|
appConfig?.mcpServers?.[serverName];
|
|
const oauthServers = await getMCPServersRegistry().getOAuthServers(userId);
|
|
if (!oauthServers.has(serverName) || !serverConfig) {
|
|
await clearStoredMCPOAuthState(userId, serverName);
|
|
return;
|
|
}
|
|
|
|
// 1. get client info used for revocation (client id, secret)
|
|
let clientTokenData = null;
|
|
try {
|
|
clientTokenData = await MCPTokenStorage.getClientInfoAndMetadata({
|
|
userId,
|
|
serverName,
|
|
findToken: db.findToken,
|
|
});
|
|
} catch (error) {
|
|
logger.warn(
|
|
`[maybeUninstallOAuthMCP] Unable to load OAuth client metadata for ${serverName}; clearing local MCP OAuth state only.`,
|
|
error,
|
|
);
|
|
await clearStoredMCPOAuthState(userId, serverName);
|
|
return;
|
|
}
|
|
if (clientTokenData == null) {
|
|
logger.info(
|
|
`[maybeUninstallOAuthMCP] Missing OAuth client metadata for ${serverName}; clearing local MCP OAuth state only.`,
|
|
);
|
|
await clearStoredMCPOAuthState(userId, serverName);
|
|
return;
|
|
}
|
|
const { clientInfo, clientMetadata } = clientTokenData;
|
|
const storedServerUrl = clientMetadata.server_url;
|
|
const storedClientSource = clientMetadata.client_source;
|
|
if (
|
|
typeof storedServerUrl !== 'string' ||
|
|
typeof clientMetadata.token_endpoint !== 'string' ||
|
|
typeof clientMetadata.revocation_endpoint !== 'string' ||
|
|
typeof clientMetadata.credential_set_id !== 'string' ||
|
|
(storedClientSource !== 'configured' && storedClientSource !== 'dynamic')
|
|
) {
|
|
logger.warn(
|
|
`[maybeUninstallOAuthMCP] Stored OAuth binding metadata is incomplete for ${serverName}; clearing local MCP OAuth state without remote revocation.`,
|
|
);
|
|
await clearStoredMCPOAuthState(userId, serverName);
|
|
return;
|
|
}
|
|
|
|
// 2. get decrypted tokens before deletion
|
|
let tokens = null;
|
|
try {
|
|
tokens = await MCPTokenStorage.getTokens({
|
|
userId,
|
|
serverName,
|
|
findToken: db.findToken,
|
|
});
|
|
if (tokens) {
|
|
MCPTokenStorage.assertCredentialSetBinding(
|
|
serverName,
|
|
tokens.credential_set_id,
|
|
clientMetadata,
|
|
);
|
|
}
|
|
} catch (error) {
|
|
tokens = null;
|
|
logger.warn(
|
|
`[maybeUninstallOAuthMCP] Unable to load OAuth tokens for ${serverName}; clearing local token state.`,
|
|
error,
|
|
);
|
|
}
|
|
|
|
// 3. revoke OAuth tokens at the provider
|
|
const revocationEndpoint = clientMetadata.revocation_endpoint;
|
|
const revocationEndpointAuthMethodsSupported =
|
|
clientMetadata.revocation_endpoint_auth_methods_supported;
|
|
const oauthHeaders = serverConfig.oauth_headers ?? {};
|
|
// Use the request's merged (tenant/principal-scoped) allowlists so admin-panel mcpSettings
|
|
// overrides are honored for OAuth revocation, consistent with inspection/connection.
|
|
const allowedDomains = appConfig?.mcpSettings?.allowedDomains;
|
|
const allowedAddresses = appConfig?.mcpSettings?.allowedAddresses;
|
|
|
|
if (tokens?.access_token) {
|
|
try {
|
|
await MCPOAuthHandler.revokeOAuthToken(
|
|
serverName,
|
|
tokens.access_token,
|
|
'access',
|
|
{
|
|
serverUrl: storedServerUrl,
|
|
clientId: clientInfo.client_id,
|
|
clientSecret: clientInfo.client_secret ?? '',
|
|
revocationEndpoint,
|
|
revocationEndpointAuthMethodsSupported,
|
|
},
|
|
oauthHeaders,
|
|
allowedDomains,
|
|
allowedAddresses,
|
|
);
|
|
} catch (error) {
|
|
logger.error(
|
|
`[maybeUninstallOAuthMCP] Error revoking OAuth access token for ${serverName}:`,
|
|
error,
|
|
);
|
|
}
|
|
}
|
|
|
|
if (tokens?.refresh_token) {
|
|
try {
|
|
await MCPOAuthHandler.revokeOAuthToken(
|
|
serverName,
|
|
tokens.refresh_token,
|
|
'refresh',
|
|
{
|
|
serverUrl: storedServerUrl,
|
|
clientId: clientInfo.client_id,
|
|
clientSecret: clientInfo.client_secret ?? '',
|
|
revocationEndpoint,
|
|
revocationEndpointAuthMethodsSupported,
|
|
},
|
|
oauthHeaders,
|
|
allowedDomains,
|
|
allowedAddresses,
|
|
);
|
|
} catch (error) {
|
|
logger.error(
|
|
`[maybeUninstallOAuthMCP] Error revoking OAuth refresh token for ${serverName}:`,
|
|
error,
|
|
);
|
|
}
|
|
}
|
|
|
|
// 4. delete tokens from the DB and clear the flow state after revocation attempts
|
|
await clearStoredMCPOAuthState(userId, serverName);
|
|
};
|
|
|
|
module.exports = {
|
|
processPendingUserDeletions,
|
|
startPendingDeletionSweep,
|
|
getUserController,
|
|
getTermsStatusController,
|
|
acceptTermsController,
|
|
deleteUserController,
|
|
verifyEmailController,
|
|
updateUserPluginsController,
|
|
resendVerificationController,
|
|
deleteUserMcpServers,
|
|
maybeUninstallOAuthMCP,
|
|
};
|