Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
⚙️ feat: Make the Per-User Passkey Cap Configurable (#16259)
Marco Berettaeefeb2a7f9f0
diff --git a/.env.example b/.env.exampleindex 5fb11aa22b..19e0e6155a 100644--- a/.env.example+++ b/.env.example@@ -948,6 +948,9 @@ APPLE_CALLBACK_URL=/oauth/apple/callback# Passkeys (WebAuthn)# Requires HTTPS in production; localhost is exempt.ALLOW_PASSKEY_LOGIN=false+# Optional. Passkeys each account may enroll (1-100). A librechat.yaml+# `passkeys.perUserMax` overrides this; both default to 20.+# MAX_PASSKEYS_PER_USER=20# Optional. Defaults to the hostname of DOMAIN_CLIENT. Pin this if DOMAIN_CLIENT# may change: existing passkeys stop working when the RP ID changes.# PASSKEY_RP_ID=diff --git a/api/server/controllers/auth/PasskeyController.js b/api/server/controllers/auth/PasskeyController.jsindex dd6c830755..be868be15a 100644--- a/api/server/controllers/auth/PasskeyController.js+++ b/api/server/controllers/auth/PasskeyController.js@@ -3,12 +3,14 @@ const { CacheKeys } = require('librechat-data-provider');const { createPasskeyHandlers } = require('@librechat/api');const { checkBan } = require('~/server/middleware');const { getLogStores } = require('~/cache');+const { getAppConfig } = require('~/server/services/Config/app');const db = require('~/models');module.exports = createPasskeyHandlers({checkBan,compare: bcrypt.compare,getChallengeCache: () => getLogStores(CacheKeys.PASSKEY_CHALLENGE),+ getAppConfig,getUserById: db.getUserById,updateUser: db.updateUser,createPasskey: db.createPasskey,diff --git a/api/server/controllers/auth/PasskeyController.spec.js b/api/server/controllers/auth/PasskeyController.spec.jsindex ee7b317e84..2c3c89b030 100644--- a/api/server/controllers/auth/PasskeyController.spec.js+++ b/api/server/controllers/auth/PasskeyController.spec.js@@ -1,5 +1,7 @@const mockCheckBan = jest.fn();const mockGetLogStores = jest.fn();+const mockGetAppConfig = jest.fn();+jest.mock('~/server/services/Config/app', () => ({ getAppConfig: mockGetAppConfig }));const mockModels = {getUserById: jest.fn(),updateUser: jest.fn(),@@ -69,6 +71,7 @@ describe('PasskeyController wiring', () => {it('hands the model methods, bcrypt and the ban check to the handler factory', () => {expect(deps.compare).toBe(bcrypt.compare);+ expect(deps.getAppConfig).toBe(mockGetAppConfig);for (const name of Object.keys(mockModels)) {expect(deps[name]).toBe(mockModels[name]);}diff --git a/api/server/routes/__tests__/config.spec.js b/api/server/routes/__tests__/config.spec.jsindex 42848ffb4a..df9d4eda5b 100644--- a/api/server/routes/__tests__/config.spec.js+++ b/api/server/routes/__tests__/config.spec.js@@ -1082,3 +1082,22 @@ describe('GET /api/config', () => {});});});++describe('passkey enrollment cap', () => {+ it('publishes the cap normalized from YAML only after authentication', async () => {+ const { AppService } = require('@librechat/data-schemas');+ const appConfig = await AppService({ config: { passkeys: { perUserMax: 2 } } });+ mockGetAppConfig.mockResolvedValue(appConfig);++ const authenticated = await request(createApp(mockUser)).get('/api/config');+ expect(authenticated.status).toBe(200);+ expect(authenticated.body.maxPasskeysPerUser).toBe(2);+ expect(mockGetAppConfig).toHaveBeenCalledWith(+ expect.objectContaining({ userId: mockUser.id, role: mockUser.role }),+ );++ const anonymous = await request(createApp()).get('/api/config');+ expect(anonymous.status).toBe(200);+ expect(anonymous.body).not.toHaveProperty('maxPasskeysPerUser');+ });+});diff --git a/api/server/routes/config.js b/api/server/routes/config.jsindex f0e5b456a2..1648edd6cf 100644--- a/api/server/routes/config.js+++ b/api/server/routes/config.js@@ -18,6 +18,7 @@ const {resolveCodeEnvironmentMoveVersion,isPasskeyEnabled,buildPreLoginInterface,+ resolveMaxPasskeysPerUser,} = require('@librechat/api');const {DEFAULT_MCP_APP_CSP_LIMITS,@@ -159,6 +160,7 @@ function buildPostLoginPayload(appConfig) {process.env.ALLOW_ACCOUNT_DELETION === undefined ||isEnabled(process.env.ALLOW_ACCOUNT_DELETION),allowEmailChange: resolveEmailChangeSettings(appConfig?.emailChange).enabled,+ maxPasskeysPerUser: resolveMaxPasskeysPerUser(appConfig?.passkeys),};return payload;diff --git a/client/src/components/Nav/SettingsTabs/Account/Passkeys/Passkeys.tsx b/client/src/components/Nav/SettingsTabs/Account/Passkeys/Passkeys.tsxindex d05b8d5d3a..0643721d05 100644--- a/client/src/components/Nav/SettingsTabs/Account/Passkeys/Passkeys.tsx+++ b/client/src/components/Nav/SettingsTabs/Account/Passkeys/Passkeys.tsx@@ -22,6 +22,7 @@ import {import type { PasskeyRemovalResult } from './PasskeyItem';import {useDeletePasskeyMutation,+ useGetStartupConfig,usePasskeysQuery,useRenamePasskeyMutation,} from '~/data-provider';@@ -48,13 +49,16 @@ function Passkeys() {const renameAfterCloseRef = useRef<string | null>(null);const { data, isLoading, isError } = usePasskeysQuery({ enabled: isDialogOpen });+ const { data: startupConfig, refetch: refetchStartupConfig } = useGetStartupConfig();const { registerPasskey, isRegistering, passwordErrorKey, clearPasswordError } =usePasskeyRegistration();const { mutate: renameMutate } = useRenamePasskeyMutation();const { mutateAsync: deleteMutate } = useDeletePasskeyMutation();const passkeys = data?.passkeys ?? [];- const atLimit = passkeys.length >= MAX_PASSKEYS_PER_USER;+ /** Falls back to the documented default while the startup config is still loading. */+ const maxPasskeys = startupConfig?.maxPasskeysPerUser ?? MAX_PASSKEYS_PER_USER;+ const atLimit = passkeys.length >= maxPasskeys;/*** Removing a passkey is password-confirmed, but an account provisioned by an* identity provider has no password to confirm with. The server waives the@@ -161,6 +165,7 @@ function Passkeys() {(open: boolean) => {setDialogOpen(open);if (open) {+ void refetchStartupConfig();return;}setPassword('');@@ -169,7 +174,7 @@ function Passkeys() {renameAfterCloseRef.current = null;clearPasswordError();},- [clearPasswordError],+ [clearPasswordError, refetchStartupConfig],);return (diff --git a/client/src/components/Nav/SettingsTabs/Account/Passkeys/__tests__/Passkeys.spec.tsx b/client/src/components/Nav/SettingsTabs/Account/Passkeys/__tests__/Passkeys.spec.tsxindex f868033238..387ab663c7 100644--- a/client/src/components/Nav/SettingsTabs/Account/Passkeys/__tests__/Passkeys.spec.tsx+++ b/client/src/components/Nav/SettingsTabs/Account/Passkeys/__tests__/Passkeys.spec.tsx@@ -5,8 +5,13 @@ import Passkeys from '../Passkeys';const mockClearPasswordError = jest.fn();const mockRegisterPasskey = jest.fn();+const mockRefetchStartupConfig = jest.fn();jest.mock('~/data-provider', () => ({+ useGetStartupConfig: () => ({+ data: { maxPasskeysPerUser: 20 },+ refetch: mockRefetchStartupConfig,+ }),usePasskeysQuery: () => ({ data: { passkeys: [] }, isLoading: false, isError: false }),useRenamePasskeyMutation: () => ({ mutate: jest.fn() }),useDeletePasskeyMutation: () => ({ mutateAsync: jest.fn() }),@@ -44,6 +49,20 @@ describe('Passkeys enrollment dialog', () => {jest.clearAllMocks();});+ it('refreshes startup configuration on each management dialog open', async () => {+ const user = userEvent.setup();+ render(<Passkeys />);+ expect(mockRefetchStartupConfig).not.toHaveBeenCalled();+ await user.click(screen.getByRole('button', { name: 'Passkeys' }));+ expect(mockRefetchStartupConfig).toHaveBeenCalledTimes(1);+ await user.keyboard('{Escape}');+ await waitFor(() =>+ expect(screen.queryByRole('dialog', { name: 'Passkeys' })).not.toBeInTheDocument(),+ );+ await user.click(screen.getByRole('button', { name: 'Passkeys' }));+ expect(mockRefetchStartupConfig).toHaveBeenCalledTimes(2);+ });+it('opens password confirmation in a separate dialog and restores focus on cancel', async () => {const user = userEvent.setup();render(<Passkeys />);diff --git a/e2e/specs/mock/scenarios/passkeys.spec.ts b/e2e/specs/mock/scenarios/passkeys.spec.tsindex 134874ad3f..58f359b0a3 100644--- a/e2e/specs/mock/scenarios/passkeys.spec.ts+++ b/e2e/specs/mock/scenarios/passkeys.spec.ts@@ -9,6 +9,7 @@ import type {} from '@playwright/test';import { seedPasskey, deleteUserByEmail, countUserPasskeys, enableTwoFactorFlag } from '../db';import { NEW_CHAT_PATH } from '../helpers';+import { getPrimaryE2EUser } from '../../../setup/users.mock';/*** Passkey sign-in and management, driven through a real WebAuthn ceremony: Chromium's@@ -423,4 +424,107 @@ test.describe('passkeys', () => {await request.dispose();}});++ test('a configured per-user cap hides the add control at that cap @scenario:passkey-cap-hides-add-control', async ({+ browser,+ playwright,+ baseURL,+ }) => {+ test.setTimeout(60000);+ const request = await playwright.request.newContext({ baseURL: passkeyBaseURL(baseURL) });+ user = await createFreshUser(request);+ await seedPasskey(user.email, `e2e-cap-${randomUUID()}`, 'Only key');+ context = await openContextFor(browser, request, passkeyBaseURL(baseURL));+ await request.dispose();+ const page = await context.newPage();++ await page.route('**/api/config', async (route) => {+ const response = await route.fetch();+ const config = await response.json();+ await route.fulfill({ response, json: { ...config, maxPasskeysPerUser: 1 } });+ });++ const cappedDialog = await openPasskeysDialog(page);+ const cappedAdd = cappedDialog.getByRole('button', { name: 'Add passkey' });+ await expect(cappedAdd).toBeVisible();+ await expect(cappedAdd).toBeDisabled();+ await expect(+ cappedDialog.getByText('You have reached the maximum number of passkeys'),+ ).toBeVisible();++ await page.unroute('**/api/config');+ await page.keyboard.press('Escape');+ await expect(cappedDialog).toBeHidden();+ await page+ .getByRole('dialog', { name: /Settings/ })+ .getByRole('button', { name: 'Passkeys', exact: true })+ .click();+ const defaultDialog = page.getByRole('dialog', { name: 'Passkeys', exact: true });+ const defaultAdd = defaultDialog.getByRole('button', { name: 'Add passkey' });+ await expect(defaultAdd).toBeVisible();+ await expect(defaultAdd).toBeEnabled();+ await expect(+ defaultDialog.getByText('You have reached the maximum number of passkeys'),+ ).toHaveCount(0);+ });++ test('the effective user cap reaches startup and both enrollment routes @scenario:passkey-cap-effective-config', async ({+ playwright,+ baseURL,+ }) => {+ test.setTimeout(60000);+ const request = await playwright.request.newContext({ baseURL: passkeyBaseURL(baseURL) });+ user = await createFreshUser(request);+ const headers = { Authorization: `Bearer ${user.token}` };+ const admin = getPrimaryE2EUser();+ const login = await request.post('/api/auth/login', {+ data: { email: admin.email, password: admin.password },+ });+ expect(login.ok()).toBeTruthy();+ const adminHeaders = { Authorization: `Bearer ${(await login.json()).token}` };+ const overridePath = `/api/admin/config/user/${user.id}`;+ try {+ const baseline = await request.get('/api/config', { headers });+ expect((await baseline.json()).maxPasskeysPerUser).toBe(20);+ await seedPasskey(user.email, `e2e-effective-cap-${randomUUID()}`, 'Existing key');+ const saved = await request.put(overridePath, {+ headers: adminHeaders,+ data: { overrides: { passkeys: { perUserMax: 1 } } },+ });+ expect(saved.ok()).toBeTruthy();+ await expect+ .poll(async () => {+ const config = await request.get('/api/config', { headers });+ return (await config.json()).maxPasskeysPerUser;+ })+ .toBe(1);++ for (const path of ['options', 'verify']) {+ const response = await request.post(`/api/auth/passkey/register/${path}`, {+ headers,+ data: { password: user.password, credential: { id: 'over-cap' } },+ });+ expect(response.status()).toBe(409);+ expect(await response.json()).toEqual({ message: 'Passkey limit reached' });+ }+ expect(await countUserPasskeys(user.id)).toBe(1);+ const restored = await request.delete(overridePath, { headers: adminHeaders });+ expect(restored.ok()).toBeTruthy();+ await expect+ .poll(async () => {+ const config = await request.get('/api/config', { headers });+ return (await config.json()).maxPasskeysPerUser;+ })+ .toBe(20);+ const allowed = await request.post('/api/auth/passkey/register/options', {+ headers,+ data: { password: user.password },+ });+ expect(allowed.status()).toBe(200);+ } finally {+ const cleanup = await request.delete(overridePath, { headers: adminHeaders });+ expect([200, 404]).toContain(cleanup.status());+ await request.dispose();+ }+ });});diff --git a/librechat.example.yaml b/librechat.example.yamlindex 84dbc91070..741fe622b3 100644--- a/librechat.example.yaml+++ b/librechat.example.yaml@@ -390,6 +390,11 @@ interface:# enabled: true# tokenTTLSeconds: 900+# Passkey (WebAuthn) enrollment limits.+# Omitted, perUserMax falls back to MAX_PASSKEYS_PER_USER, then 20.+# passkeys:+# perUserMax: 20+registration:socialLogins: ['github', 'google', 'discord', 'openid', 'facebook', 'apple', 'saml']# allowedDomains:diff --git a/packages/api/src/app/AppService.spec.ts b/packages/api/src/app/AppService.spec.tsindex f4f64ef23c..c695344212 100644--- a/packages/api/src/app/AppService.spec.ts+++ b/packages/api/src/app/AppService.spec.ts@@ -68,6 +68,11 @@ const defaultAgentCapabilitiesWithoutMemory = defaultAgentCapabilities.filter();describe('AppService', () => {+ it('preserves the YAML passkey cap in the effective configuration', async () => {+ const result = await AppService({ config: { passkeys: { perUserMax: 2 } } });+ expect(result?.passkeys).toEqual({ perUserMax: 2 });+ });+const mockSystemTools: Record<string, FunctionTool> = {ExampleTool: {type: 'function',diff --git a/packages/api/src/auth/passkey.spec.ts b/packages/api/src/auth/passkey.spec.tsindex 472819a678..e79ca41abc 100644--- a/packages/api/src/auth/passkey.spec.ts+++ b/packages/api/src/auth/passkey.spec.ts@@ -1,7 +1,9 @@import Keyv from 'keyv';import { logger } from '@librechat/data-schemas';+import { MAX_PASSKEYS_PER_USER } from 'librechat-data-provider';import { createHash, generateKeyPairSync, sign } from 'node:crypto';import type { AuthenticationResponseJSON, RegistrationResponseJSON } from '@simplewebauthn/server';+import type { TCustomConfig } from 'librechat-data-provider';import type { PasskeyChallengeStore, PasskeyConfig } from './passkey';import {authenticationChallengeKey,@@ -12,6 +14,7 @@ import {getPasskeyConfig,isPasskeyEnabled,registrationChallengeKey,+ resolveMaxPasskeysPerUser,verifyPasskeyAuthentication,verifyPasskeyRegistration,} from './passkey';@@ -107,6 +110,50 @@ function createAuthenticator(credentialId = 'cred-id') {return { assert, credential: { credentialId: id, publicKey: cosePublicKey, counter: 0 } };}+describe('resolveMaxPasskeysPerUser', () => {+ it('prefers the yaml value over the environment and the documented default', () => {+ expect(+ resolveMaxPasskeysPerUser({ perUserMax: 5 }, {+ MAX_PASSKEYS_PER_USER: '9',+ } as NodeJS.ProcessEnv),+ ).toBe(5);+ });++ it('falls back to the environment, then the documented default', () => {+ expect(+ resolveMaxPasskeysPerUser(undefined, { MAX_PASSKEYS_PER_USER: '9' } as NodeJS.ProcessEnv),+ ).toBe(9);+ expect(resolveMaxPasskeysPerUser(undefined, {} as NodeJS.ProcessEnv)).toBe(+ MAX_PASSKEYS_PER_USER,+ );+ expect(+ resolveMaxPasskeysPerUser(undefined, {+ MAX_PASSKEYS_PER_USER: 'not-a-number',+ } as NodeJS.ProcessEnv),+ ).toBe(MAX_PASSKEYS_PER_USER);+ });++ it('applies the schema bounds to the environment value too', () => {+ const rejected = ['0', '-1', '101', '9abc', '1.5'];+ for (const value of rejected) {+ expect(+ resolveMaxPasskeysPerUser(undefined, { MAX_PASSKEYS_PER_USER: value } as NodeJS.ProcessEnv),+ ).toBe(MAX_PASSKEYS_PER_USER);+ }+ expect(+ resolveMaxPasskeysPerUser(undefined, { MAX_PASSKEYS_PER_USER: '100' } as NodeJS.ProcessEnv),+ ).toBe(100);+ });++ it('ignores an out-of-bounds cap from an unvalidated override', () => {+ const env = { MAX_PASSKEYS_PER_USER: '9' } as NodeJS.ProcessEnv;+ const rejected: unknown[] = [0, -1, 101, 1.5, '5', 'abc', null];+ for (const perUserMax of rejected) {+ expect(resolveMaxPasskeysPerUser({ perUserMax } as TCustomConfig['passkeys'], env)).toBe(9);+ }+ });+});+describe('getPasskeyConfig', () => {it('derives the RP ID and origins from DOMAIN_CLIENT', () => {const resolved = getPasskeyConfig({diff --git a/packages/api/src/auth/passkey.ts b/packages/api/src/auth/passkey.tsindex fe067d7984..c266439b83 100644--- a/packages/api/src/auth/passkey.ts+++ b/packages/api/src/auth/passkey.ts@@ -1,12 +1,12 @@import { randomUUID } from 'node:crypto';import { logger } from '@librechat/data-schemas';+import { MAX_PASSKEYS_PER_USER } from 'librechat-data-provider';import {generateAuthenticationOptions,generateRegistrationOptions,verifyAuthenticationResponse,verifyRegistrationResponse,} from '@simplewebauthn/server';-import type {AuthenticationResponseJSON,AuthenticatorTransportFuture,@@ -15,7 +15,7 @@ import type {RegistrationResponseJSON,} from '@simplewebauthn/server';import type { PasskeyDeviceType } from '@librechat/data-schemas';-+import type { TCustomConfig } from 'librechat-data-provider';import { isEnabled } from '~/utils';/** How long a generated challenge stays valid, in milliseconds. */@@ -147,6 +147,29 @@ export function isPasskeyEnabled(config: PasskeyConfig = getPasskeyConfig()): boreturn config.enabled && config.origins.length > 0;}+/** The schema's bounds for `passkeys.perUserMax`, applied to every source of the cap. */+const isCapWithinBounds = (value: unknown): value is number =>+ typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= 100;++/**+ * yaml wins over the environment, which wins over the documented default, so a+ * deployment that sets neither keeps exactly the behavior it has today. Every+ * source is held to the schema's bounds: principal-scoped database overrides+ * merge in without passing through `configSchema`, and a stray value must+ * neither brick enrollment nor lift the cap.+ */+export function resolveMaxPasskeysPerUser(+ config?: TCustomConfig['passkeys'],+ env: NodeJS.ProcessEnv = process.env,+): number {+ const fromConfig: unknown = config?.perUserMax;+ if (isCapWithinBounds(fromConfig)) {+ return fromConfig;+ }+ const fromEnv = Number(env.MAX_PASSKEYS_PER_USER);+ return isCapWithinBounds(fromEnv) ? fromEnv : MAX_PASSKEYS_PER_USER;+}+/** Namespaced cache key for a pending registration ceremony. */export const registrationChallengeKey = (userId: string): string => `passkey-reg:${userId}`;diff --git a/packages/api/src/auth/passkey/handlers.spec.ts b/packages/api/src/auth/passkey/handlers.spec.tsindex 5f94c80b4b..d16a9ae8a2 100644--- a/packages/api/src/auth/passkey/handlers.spec.ts+++ b/packages/api/src/auth/passkey/handlers.spec.ts@@ -1,7 +1,7 @@import mongoose from 'mongoose';import { createHash } from 'node:crypto';import { MongoMemoryServer } from 'mongodb-memory-server';-import { MAX_PASSKEYS_PER_USER } from 'librechat-data-provider';+import { FileSources, MAX_PASSKEYS_PER_USER } from 'librechat-data-provider';import { logger, createMethods, createModels } from '@librechat/data-schemas';import type { RegistrationResponseJSON } from '@simplewebauthn/server';import type { IUser } from '@librechat/data-schemas';@@ -48,6 +48,7 @@ const ENV_KEYS = ['ALLOW_UNVERIFIED_EMAIL_LOGIN','EMAIL_SERVICE','EMAIL_FROM',+ 'MAX_PASSKEYS_PER_USER',] as const;type MockResponse = Response & { status: jest.Mock; json: jest.Mock };@@ -259,6 +260,190 @@ describe('passkey registration provider enforcement', () => {expect(res.json).toHaveBeenCalledWith({ message: 'Passkey limit reached' });});+ it('enforces the per-account cap the deployment configures', async () => {+ const handlers = createPasskeyHandlers(+ buildDeps({+ getAppConfig: async () => ({+ config: {},+ fileStrategy: FileSources.local,+ imageOutputType: 'png',+ passkeys: { perUserMax: 2 },+ }),+ }),+ );+ const user = await createUser();+ await Promise.all([createStoredPasskey(user, 'cap-0'), createStoredPasskey(user, 'cap-1')]);+ const res = buildRes();++ await handlers.registerPasskeyOptions(authedReq(user, { password: PASSWORD }), res);++ expect(res.status).toHaveBeenCalledWith(409);+ expect(res.json).toHaveBeenCalledWith({ message: 'Passkey limit reached' });+ });++ it('awaits an asynchronous cap resolver on the verify path', async () => {+ const handlers = createPasskeyHandlers(+ buildDeps({+ getAppConfig: async () => ({+ config: {},+ fileStrategy: FileSources.local,+ imageOutputType: 'png',+ passkeys: { perUserMax: 1 },+ }),+ }),+ );+ const user = await createUser();+ await createStoredPasskey(user, 'cap-verify-0');+ const res = buildRes();++ await handlers.registerPasskeyVerify(+ authedReq(user, {+ credential: attestation,+ name: 'Third key',+ password: PASSWORD,+ }),+ res,+ );++ expect(res.status).toHaveBeenCalledWith(409);+ expect(res.json).toHaveBeenCalledWith({ message: 'Passkey limit reached' });+ });++ it('resolves the authenticated principal once before writing a credential', async () => {+ const getAppConfig = jest+ .fn<+ ReturnType<NonNullable<PasskeyHandlersDeps['getAppConfig']>>,+ Parameters<NonNullable<PasskeyHandlersDeps['getAppConfig']>>+ >()+ .mockResolvedValueOnce({+ config: {},+ fileStrategy: FileSources.local,+ imageOutputType: 'png',+ passkeys: { perUserMax: 1 },+ })+ .mockRejectedValue(new Error('Config unavailable after enrollment'));+ const handlers = createPasskeyHandlers(buildDeps({ getAppConfig }));+ const user = await createUser();+ const req = authedReq(user, { credential: attestation, password: PASSWORD });+ req.user.role = 'USER';+ req.user.idOnTheSource = 'source-user';+ const res = buildRes();++ await handlers.registerPasskeyVerify(req, res);++ expect(res.status).toHaveBeenCalledWith(201);+ expect(getAppConfig).toHaveBeenCalledTimes(1);+ expect(getAppConfig).toHaveBeenCalledWith({+ userId: user._id.toString(),+ role: 'USER',+ idOnTheSource: 'source-user',+ tenantId: undefined,+ failClosed: true,+ });+ expect(await methods.countPasskeysByUser(user._id.toString())).toBe(1);+ });++ it('reuses configuration already loaded for the request', async () => {+ const getAppConfig = jest.fn().mockRejectedValue(new Error('Unnecessary config read'));+ const handlers = createPasskeyHandlers(buildDeps({ getAppConfig }));+ const user = await createUser();+ await createStoredPasskey(user);+ const req = authedReq(user, { password: PASSWORD });+ req.config = {+ config: {},+ fileStrategy: FileSources.local,+ imageOutputType: 'png',+ passkeys: { perUserMax: 1 },+ };+ const res = buildRes();++ await handlers.registerPasskeyOptions(req, res);++ expect(res.status).toHaveBeenCalledWith(409);+ expect(getAppConfig).not.toHaveBeenCalled();+ });++ it('does not enroll a credential when effective configuration cannot be loaded', async () => {+ const getAppConfig = jest.fn().mockRejectedValue(new Error('Config unavailable'));+ const handlers = createPasskeyHandlers(buildDeps({ getAppConfig }));+ const user = await createUser();+ const res = buildRes();++ await handlers.registerPasskeyVerify(+ authedReq(user, { credential: attestation, password: PASSWORD }),+ res,+ );++ expect(res.status).toHaveBeenCalledWith(500);+ expect(await methods.countPasskeysByUser(user._id.toString())).toBe(0);+ expect(mockVerifyRegistration).not.toHaveBeenCalled();+ });++ it('removes the inserted credential if the post-write count fails', async () => {+ const countPasskeysByUser = jest+ .fn(methods.countPasskeysByUser)+ .mockResolvedValueOnce(0)+ .mockRejectedValueOnce(new Error('Count unavailable'));+ const handlers = createPasskeyHandlers(buildDeps({ countPasskeysByUser }));+ const user = await createUser();+ const res = buildRes();++ await handlers.registerPasskeyVerify(+ authedReq(user, { credential: attestation, password: PASSWORD }),+ res,+ );++ expect(res.status).toHaveBeenCalledWith(500);+ expect(await methods.countPasskeysByUser(user._id.toString())).toBe(0);+ });++ it('rolls back a credential that wins the enrollment race past the cap', async () => {+ /** Both verifies observe the pre-enrollment count, as two concurrent+ * ceremonies for the same account do, so both pass the early check. */+ const racedCount = jest+ .fn()+ .mockImplementationOnce(async () => 0)+ .mockImplementationOnce(async () => 0)+ .mockImplementation(methods.countPasskeysByUser);+ const handlers = createPasskeyHandlers(+ buildDeps({+ getAppConfig: async () => ({+ config: {},+ fileStrategy: FileSources.local,+ imageOutputType: 'png',+ passkeys: { perUserMax: 1 },+ }),+ countPasskeysByUser: racedCount,+ }),+ );+ let ceremony = 0;+ mockVerifyRegistration.mockImplementation(async () =>+ verifiedRegistration(`raced-cred-${++ceremony}`),+ );+ const user = await createUser();+ const results = await Promise.allSettled(+ [1, 2].map((index) =>+ handlers.registerPasskeyVerify(+ authedReq(user, {+ credential: { id: `raced-cred-${index}` } as RegistrationResponseJSON,+ name: `Raced ${index}`,+ password: PASSWORD,+ }),+ buildRes(),+ ),+ ),+ );++ expect(+ results.every(+ (result) =>+ result.status === 'fulfilled' ||+ result.reason === undefined /** handlers return rather than throw */,+ ),+ ).toBe(true);+ expect(await methods.countPasskeysByUser(user._id.toString())).toBeLessThanOrEqual(1);+ });+it('stores the credential when the account is local', async () => {const handlers = createPasskeyHandlers(buildDeps());const user = await createUser();diff --git a/packages/api/src/auth/passkey/handlers.ts b/packages/api/src/auth/passkey/handlers.tsindex a03619660c..e1d57a7ed9 100644--- a/packages/api/src/auth/passkey/handlers.ts+++ b/packages/api/src/auth/passkey/handlers.ts@@ -1,9 +1,9 @@import { logger } from '@librechat/data-schemas';-import { MAX_PASSKEYS_PER_USER } from 'librechat-data-provider';import type { AuthenticationResponseJSON, RegistrationResponseJSON } from '@simplewebauthn/server';-import type { PasskeyCreateData, PasskeyRecord } from '@librechat/data-schemas';+import type { PasskeyCreateData, PasskeyRecord, AppConfig } from '@librechat/data-schemas';import type { TPasskey } from 'librechat-data-provider';import type { Request, Response } from 'express';+import type { AppConfigUserLike, GetAppConfigOptions } from '~/app/service';import type { PasskeyConfig, PasskeyChallengeStore } from '~/auth/passkey';import type { ComparePasswordDeps } from '~/auth/password';import type { UserDocumentId } from '~/auth/verification';@@ -11,12 +11,14 @@ import {getPasskeyConfig,isPasskeyEnabled,defaultPasskeyName,+ resolveMaxPasskeysPerUser,verifyPasskeyRegistration,verifyPasskeyAuthentication,createPasskeyRegistrationOptions,createPasskeyAuthenticationOptions,} from '~/auth/passkey';import { grandfatherLegacyEmailVerification } from '~/auth/verification';+import { resolveStrictAppConfig } from '~/app/service';import { comparePassword } from '~/auth/password';import { isEnabled } from '~/utils';@@ -53,7 +55,7 @@ interface AuthenticationBody {* handoff to `loginController` and legacy-verification grandfathering, not by* the route handlers themselves.*/-export interface PasskeyAccount {+export interface PasskeyAccount extends AppConfigUserLike {id?: string;_id?: UserDocumentId;email?: string;@@ -74,6 +76,7 @@ export type PasskeyRequest<TBody = StepUpBody> = Request<> & {user?: PasskeyAccount;banned?: boolean;+ config?: AppConfig;};/** Every management route sits behind `requireJwtAuth`, so `req.user` is always populated. */@@ -115,6 +118,8 @@ export interface PasskeyHandlersDeps {findPasskeyByCredentialId: (credentialId: string) => Promise<PasskeyRecord | null>;/** Resolves the cache backing pending WebAuthn ceremonies. */getChallengeCache: () => PasskeyChallengeStore;+ /** Resolves effective configuration for the authenticated principal. */+ getAppConfig?: (options: GetAppConfigOptions) => Promise<AppConfig | undefined>;compare: ComparePasswordDeps['compare'];/** The login ban middleware; reports an internal failure through `next(err)`. */checkBan: (@@ -242,6 +247,7 @@ export function createPasskeyHandlers(deps: PasskeyHandlersDeps): PasskeyHandlerrecordPasskeyUse,getChallengeCache,findPasskeysByUser,+ getAppConfig,countPasskeysByUser,findPasskeyByCredentialId,} = deps;@@ -249,6 +255,14 @@ export function createPasskeyHandlers(deps: PasskeyHandlersDeps): PasskeyHandlerconst getChallengeStore = (): PasskeyChallengeStore =>createPasskeyChallengeStore(getChallengeCache());+ /** Resolved per request, so a config reload changes the cap without a restart. */+ const resolveMaxPasskeys = async (req: AuthenticatedPasskeyRequest): Promise<number> => {+ const appConfig =+ req.config ??+ (getAppConfig ? await resolveStrictAppConfig(getAppConfig, req.user) : undefined);+ return resolveMaxPasskeysPerUser(appConfig?.passkeys);+ };+/*** Step-up gate shared by the passkey endpoints that add or remove a login factor.* A passkey is a durable single-factor login that outlives session revocation, so@@ -336,8 +350,11 @@ export function createPasskeyHandlers(deps: PasskeyHandlersDeps): PasskeyHandler}try {- const existingCredentials = await findPasskeysByUser(req.user.id);- if (existingCredentials.length >= MAX_PASSKEYS_PER_USER) {+ const [existingCredentials, maxPasskeys] = await Promise.all([+ findPasskeysByUser(req.user.id),+ resolveMaxPasskeys(req),+ ]);+ if (existingCredentials.length >= maxPasskeys) {return res.status(409).json({ message: 'Passkey limit reached' });}@@ -387,7 +404,11 @@ export function createPasskeyHandlers(deps: PasskeyHandlersDeps): PasskeyHandlerreturn res.status(400).json({ message: 'Missing credential' });}- if ((await countPasskeysByUser(req.user.id)) >= MAX_PASSKEYS_PER_USER) {+ const [count, maxPasskeys] = await Promise.all([+ countPasskeysByUser(req.user.id),+ resolveMaxPasskeys(req),+ ]);+ if (count >= maxPasskeys) {return res.status(409).json({ message: 'Passkey limit reached' });}@@ -419,6 +440,24 @@ export function createPasskeyHandlers(deps: PasskeyHandlersDeps): PasskeyHandlertrimmedName.slice(0, MAX_PASSKEY_NAME_LENGTH) || defaultPasskeyName(verified.transports),});+ /**+ * The early count check races a concurrent ceremony for the same account:+ * both can observe a below-cap count and both insert. Re-counting after+ * the write and rolling this credential back keeps the stored set within+ * the cap without a transaction, at the cost of rejecting the whole race.+ */+ let countAfterWrite: number;+ try {+ countAfterWrite = await countPasskeysByUser(req.user.id);+ } catch (error) {+ await deletePasskey(passkey.id, req.user.id);+ throw error;+ }+ if (countAfterWrite > maxPasskeys) {+ await deletePasskey(passkey.id, req.user.id);+ return res.status(409).json({ message: 'Passkey limit reached' });+ }+return res.status(201).json({ passkey: serializePasskey(passkey) });} catch (err) {if (isDuplicateKeyError(err as MongoWriteError)) {diff --git a/packages/data-provider/src/config.spec.ts b/packages/data-provider/src/config.spec.tsindex 223e45d1ce..acb55cec5a 100644--- a/packages/data-provider/src/config.spec.ts+++ b/packages/data-provider/src/config.spec.ts@@ -175,6 +175,22 @@ describe('ask user retained answers', () => {});});+describe('passkey enrollment config', () => {+ it('ships a per-account cap a deployment can raise or lower', () => {+ expect(configSchema.parse({ version: '1.0' }).passkeys).toEqual({});+ expect(+ configSchema.parse({ version: '1.0', passkeys: { perUserMax: 5 } }).passkeys.perUserMax,+ ).toBe(5);+ /** A cap below one would brick enrollment; a fraction of a credential is nonsense. */+ expect(configSchema.safeParse({ version: '1.0', passkeys: { perUserMax: 0 } }).success).toBe(+ false,+ );+ expect(configSchema.safeParse({ version: '1.0', passkeys: { perUserMax: 1.5 } }).success).toBe(+ false,+ );+ });+});+describe('retained tool-count ceiling', () => {it('ships the exact-count budget a deployment can raise or lower', () => {/** The save path tokenizes a stopped turn's retained tool results to add andiff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.tsindex 8b66fdf554..18ddfbb798 100644--- a/packages/data-provider/src/config.ts+++ b/packages/data-provider/src/config.ts@@ -2748,6 +2748,8 @@ export type TStartupConfig = {appleLoginEnabled: boolean;samlLoginEnabled: boolean;passkeyLoginEnabled: boolean;+ /** Per-account passkey enrollment cap, from `passkeys.perUserMax`; post-login only. */+ maxPasskeysPerUser?: number;openidLabel: string;openidImageUrl: string;openidAutoRedirect: boolean;@@ -3521,6 +3523,14 @@ export const configSchema = z.object({tokenTTLSeconds: z.number().int().min(60).max(86_400).optional(),}).optional(),+ /** WebAuthn passkey enrollment. An unset field falls back to its env var, then the+ * documented default, so an existing deployment keeps the behavior it has today. */+ passkeys: z+ .object({+ /** `MAX_PASSKEYS_PER_USER` when unset; the documented default when neither is given. */+ perUserMax: z.number().int().min(1).max(100).optional(),+ })+ .default({}),balance: balanceSchema.optional(),transactions: transactionsSchema.optional(),speech: zdiff --git a/packages/data-schemas/src/app/service.ts b/packages/data-schemas/src/app/service.tsindex 78016b670b..2a40be0fee 100644--- a/packages/data-schemas/src/app/service.ts+++ b/packages/data-schemas/src/app/service.ts@@ -187,6 +187,7 @@ export const AppService = async (params?: {fileStrategy,registration,emailChange,+ passkeys: config.passkeys,transactions,filteredTools,includedTools,diff --git a/packages/data-schemas/src/types/app.ts b/packages/data-schemas/src/types/app.tsindex 7d6d673ab1..1a0b3a5d9f 100644--- a/packages/data-schemas/src/types/app.ts+++ b/packages/data-schemas/src/types/app.ts@@ -82,6 +82,8 @@ export interface AppConfig {registration?: TCustomConfig['registration'];/** Changing the registered email address */emailChange?: TCustomConfig['emailChange'];+ /** Passkey enrollment configuration */+ passkeys?: TCustomConfig['passkeys'];/** Actions configurations */actions?: TCustomConfig['actions'];/** Admin-filtered tools */