Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
fix(external-rest-api): r4-l1 classify empty reset payload as invalid
Josué7fe7ebe202d6
diff --git a/control-api/package-lock.json b/control-api/package-lock.jsonindex 1c36f4bae..07acba3cf 100644--- a/control-api/package-lock.json+++ b/control-api/package-lock.json@@ -1,12 +1,12 @@{"name": "clerum-control-api",- "version": "0.1.755",+ "version": "0.1.756","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "clerum-control-api",- "version": "0.1.755",+ "version": "0.1.756","dependencies": {"@clerum/display-field": "file:../packages/display-field","@clerum/grok-provider-attempt-contract": "file:../packages/grok-provider-attempt-contract",diff --git a/control-api/package.json b/control-api/package.jsonindex b8e823509..cf3e3b57f 100644--- a/control-api/package.json+++ b/control-api/package.json@@ -1,6 +1,6 @@{"name": "clerum-control-api",- "version": "0.1.755",+ "version": "0.1.756","description": "Internal Clerum control plane REST API + UI for managing CRDs and secrets","main": "dist/main.js","engines": {diff --git a/control-api/test/r4l1.resetPasswordPayload.externalRest.realPostgres.integration.test.ts b/control-api/test/r4l1.resetPasswordPayload.externalRest.realPostgres.integration.test.tsnew file mode 100644index 000000000..91e2fcda2--- /dev/null+++ b/control-api/test/r4l1.resetPasswordPayload.externalRest.realPostgres.integration.test.ts@@ -0,0 +1,508 @@+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'+import express from 'express'+import bcrypt from 'bcryptjs'+import { type ChildProcess, spawn } from 'node:child_process'+import { generateKeyPairSync, randomBytes, randomUUID } from 'node:crypto'+import { once } from 'node:events'+import { type Server, createServer, request as httpRequest } from 'node:http'+import path from 'node:path'+import { Pool } from 'pg'+import request from 'supertest'+import { config as controlConfig } from '../src/config.js'+import { initDb } from '../src/db.js'+import { requireInternalToken } from '../src/middleware/internalServiceAuth.js'+import { sendPasswordAdmissionError } from '../src/middleware/passwordLoginAdmission.js'+import { createExternalInvitationsRouter } from '../src/routes/external/invitations.js'+import { createSilentInvitationForTeams } from '../src/services/directory/membership.js'+import { registerAndSendInvitation } from '../src/services/invitationFlowRegistrationService.js'+import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'++const holder = vi.hoisted(() => ({ pool: null as unknown as Pool }))++vi.mock('../src/db.js', async importOriginal => {+ const real = await importOriginal<typeof import('../src/db.js')>()+ const proxy = {+ query: (...args: unknown[]) => (holder.pool.query as Function)(...args),+ connect: () => holder.pool.connect(),+ }+ return {+ ...real,+ pool: proxy,+ corePool: proxy,+ rateLimitPool: proxy,+ withTransaction: (+ work: Parameters<typeof real.withTransaction>[0],+ _txPool?: Parameters<typeof real.withTransaction>[1],+ options?: Parameters<typeof real.withTransaction>[2]+ ) => real.withTransaction(work, holder.pool, options),+ }+})++const adminUrl = process.env.CONTROL_API_REAL_PG_ADMIN_URL+const memberRegistrationRoot = process.env.EVENFIRE_MEMBER_REGISTRATION_ROOT+const realProducer = adminUrl && memberRegistrationRoot ? describe : describe.skip+const internalToken = 'Synthetic-R4-L1-Internal-Token'+const tenantId = 'r4-l1-test-tenant'+const tenantKid = 'r4-l1-test-credential'+const tenantSecret = 'Synthetic-R4-L1-Member-Registration-Secret'+type ExternalConfig = typeof import('../../external-rest-api/src/config.js').config+type ExternalRouterFactory =+ typeof import('../../external-rest-api/src/routes/invitations.js').createInvitationsRouter+type ExternalAuthoritySender =+ typeof import('../../external-rest-api/src/http/passwordAdmissionError.js').sendPasswordAuthorityError+let externalConfig: ExternalConfig+let createInvitationsRouter: ExternalRouterFactory+let sendPasswordAuthorityError: ExternalAuthoritySender+let originalExternalJwtKey: string | undefined++function listen(server: Server): Promise<number> {+ return new Promise((resolve, reject) => {+ server.once('error', reject)+ server.listen(0, '127.0.0.1', () => {+ const address = server.address()+ if (!address || typeof address === 'string') {+ reject(new Error('test server did not bind TCP'))+ return+ }+ resolve(address.port)+ })+ })+}++async function freeLoopbackPort(): Promise<number> {+ const server = createServer()+ const port = await listen(server)+ await new Promise<void>((resolve, reject) =>+ server.close(error => (error ? reject(error) : resolve()))+ )+ return port+}++async function waitForMemberRegistration(port: number, child: ChildProcess): Promise<void> {+ const deadline = Date.now() + 20_000+ while (Date.now() < deadline) {+ if (child.exitCode !== null) {+ throw new Error(`local Member Registration producer exited (${child.exitCode})`)+ }+ try {+ const response = await fetch(`http://127.0.0.1:${port}/health`)+ if (response.ok) return+ } catch {+ // The local producer is still starting its PostgreSQL migrations.+ }+ await new Promise(resolve => setTimeout(resolve, 100))+ }+ throw new Error('local Member Registration producer did not become ready')+}++function createDropResetResponseProxy(controlApiPort: number) {+ let resetPostCount = 0+ let droppedResolve!: () => void+ const droppedResetResponse = new Promise<void>(resolve => {+ droppedResolve = resolve+ })+ const server = createServer((incoming, outgoing) => {+ const target = httpRequest({+ host: '127.0.0.1',+ port: controlApiPort,+ method: incoming.method,+ path: incoming.url,+ headers: { ...incoming.headers, host: `127.0.0.1:${controlApiPort}` },+ })+ target.on('response', response => {+ if (+ incoming.method === 'POST' &&+ incoming.url?.endsWith('/external/invitations/password-token')+ ) {+ resetPostCount += 1+ response.resume()+ response.once('end', () => {+ droppedResolve()+ outgoing.destroy()+ })+ return+ }+ outgoing.writeHead(response.statusCode || 502, response.headers)+ response.pipe(outgoing)+ })+ target.on('error', () => outgoing.destroy())+ incoming.pipe(target)+ })+ return {+ server,+ start: async () => {+ const port = await listen(server)+ return `http://127.0.0.1:${port}/api/v1`+ },+ get resetPostCount() {+ return resetPostCount+ },+ droppedResetResponse,+ close: () =>+ new Promise<void>((resolve, reject) =>+ server.close(error => (error ? reject(error) : resolve()))+ ),+ }+}++realProducer('R4-L1 reset password payload through the public route and real producers', () => {+ const controlDatabase = `r4l1_control_${randomBytes(6).toString('hex')}`+ const producerDatabase = `r4l1_member_registration_${randomBytes(6).toString('hex')}`+ const registrationSecret = tenantSecret+ let admin: Pool+ let controlPool: Pool+ let observer: Pool+ let producerObserver: Pool+ let controlServer: Server | undefined+ let memberRegistrationProcess: ChildProcess | undefined+ let ambiguousProxy: ReturnType<typeof createDropResetResponseProxy> | undefined+ let controlApiPort = 0+ let controlBaseUrl = ''+ let producerBaseUrl = ''+ let publicApp: express.Express+ let producerResponses: Array<{ status: number; error: string | null }> = []+ let originalControlConfig: Record<string, unknown> = {}+ let originalExternalConfig: Record<string, unknown> = {}++ beforeAll(async () => {+ originalExternalJwtKey = process.env.EXTERNAL_REST_API_JWT_PUBLIC_KEY+ if (!originalExternalJwtKey) {+ process.env.EXTERNAL_REST_API_JWT_PUBLIC_KEY = generateKeyPairSync('rsa', {+ modulusLength: 2048,+ privateKeyEncoding: { type: 'pkcs8', format: 'pem' },+ publicKeyEncoding: { type: 'spki', format: 'pem' },+ }).publicKey+ }+ externalConfig = (await import('../../external-rest-api/src/config.js')).config+ createInvitationsRouter = (await import('../../external-rest-api/src/routes/invitations.js'))+ .createInvitationsRouter+ sendPasswordAuthorityError = (+ await import('../../external-rest-api/src/http/passwordAdmissionError.js')+ ).sendPasswordAuthorityError++ admin = new Pool({ connectionString: adminUrl })+ await admin.query(`CREATE DATABASE "${controlDatabase}"`)+ await admin.query(`CREATE DATABASE "${producerDatabase}"`)+ const controlUrl = new URL(adminUrl!)+ controlUrl.pathname = `/${controlDatabase}`+ const producerUrl = new URL(adminUrl!)+ producerUrl.pathname = `/${producerDatabase}`+ controlPool = new Pool({ connectionString: controlUrl.toString() })+ observer = new Pool({ connectionString: controlUrl.toString() })+ producerObserver = new Pool({ connectionString: producerUrl.toString() })+ holder.pool = controlPool+ await initDb(controlPool)++ originalControlConfig = {+ memberRegistrationMode: controlConfig.memberRegistrationMode,+ memberRegistrationServiceBaseUrl: controlConfig.memberRegistrationServiceBaseUrl,+ memberRegistrationServiceHmacSecret: controlConfig.memberRegistrationServiceHmacSecret,+ memberRegistrationServiceHmacKid: controlConfig.memberRegistrationServiceHmacKid,+ memberRegistrationTenantId: controlConfig.memberRegistrationTenantId,+ desktopExternalRestApiBaseUrl: controlConfig.desktopExternalRestApiBaseUrl,+ desktopRpcProxyBaseUrl: controlConfig.desktopRpcProxyBaseUrl,+ desktopProfileUiBaseUrl: controlConfig.desktopProfileUiBaseUrl,+ desktopAppName: controlConfig.desktopAppName,+ internalServiceToken: controlConfig.internalServiceTokens['external-rest-api'],+ }+ originalExternalConfig = {+ controlApiBaseUrl: externalConfig.controlApiBaseUrl,+ controlApiServiceToken: externalConfig.controlApiServiceToken,+ controlApiServiceName: externalConfig.controlApiServiceName,+ }++ const producerPort = await freeLoopbackPort()+ memberRegistrationProcess = spawn(+ path.join(memberRegistrationRoot!, 'node_modules/.bin/tsx'),+ ['src/main.ts'],+ {+ cwd: memberRegistrationRoot,+ env: {+ ...process.env,+ NODE_ENV: 'test',+ MEMBER_REGISTRATION_SERVICE_PORT: String(producerPort),+ MEMBER_REGISTRATION_SERVICE_PG_CONNECTION_STRING: producerUrl.toString(),+ MEMBER_REGISTRATION_SERVICE_INVITATION_JWT_SECRET: registrationSecret,+ MEMBER_REGISTRATION_SERVICE_ADMIN_TOKEN: 'Synthetic-R4-L1-Admin-Token',+ MEMBER_REGISTRATION_PUBLIC_BASE_URL: `http://127.0.0.1:${producerPort}`,+ MEMBER_REGISTRATION_SERVICE_SMTP_HOST: '',+ MEMBER_REGISTRATION_SERVICE_SMTP_USER: '',+ MEMBER_REGISTRATION_SERVICE_SMTP_PASSWORD: '',+ },+ stdio: 'ignore',+ }+ )+ await waitForMemberRegistration(producerPort, memberRegistrationProcess)+ producerBaseUrl = `http://127.0.0.1:${producerPort}/api/v1`+ await producerObserver.query(+ `INSERT INTO tenant_credentials(tenant_id, kid, hmac_secret, tenant_type, bound_domain)+ VALUES ($1, $2, $3, 'managed', NULL)`,+ [tenantId, tenantKid, registrationSecret]+ )++ controlConfig.memberRegistrationMode = 'remote'+ controlConfig.memberRegistrationServiceBaseUrl = producerBaseUrl+ controlConfig.memberRegistrationServiceHmacSecret = registrationSecret+ controlConfig.memberRegistrationServiceHmacKid = tenantKid+ controlConfig.memberRegistrationTenantId = tenantId+ controlConfig.desktopExternalRestApiBaseUrl = 'https://api.example.invalid'+ controlConfig.desktopRpcProxyBaseUrl = 'https://rpc.example.invalid'+ controlConfig.desktopProfileUiBaseUrl = 'https://member.example.invalid'+ controlConfig.desktopAppName = 'Synthetic Evenfire'+ controlConfig.internalServiceTokens['external-rest-api'] = internalToken++ const controlApp = express()+ controlApp.use(express.json())+ controlApp.use((req, res, next) => {+ if (req.method === 'POST' && req.path === '/api/v1/external/invitations/password-token') {+ const json = res.json.bind(res)+ res.json = ((body: unknown) => {+ const error =+ body && typeof body === 'object' && 'error' in body+ ? String((body as { error: unknown }).error)+ : null+ producerResponses.push({ status: res.statusCode, error })+ return json(body)+ }) as typeof res.json+ }+ next()+ })+ controlApp.use('/api/v1', requireInternalToken, createExternalInvitationsRouter())+ controlApp.use(+ (error: unknown, _req: express.Request, res: express.Response, _next: unknown) => {+ if (sendPasswordAdmissionError(error, res)) return+ res.status(500).json({ error: 'Internal Server Error' })+ }+ )+ controlServer = createServer(controlApp)+ controlApiPort = await listen(controlServer)+ controlBaseUrl = `http://127.0.0.1:${controlApiPort}/api/v1`++ externalConfig.controlApiBaseUrl = controlBaseUrl+ externalConfig.controlApiServiceToken = internalToken+ externalConfig.controlApiServiceName = 'external-rest-api'+ publicApp = express()+ publicApp.use(express.json())+ publicApp.use(createInvitationsRouter())+ publicApp.use(+ (error: unknown, _req: express.Request, res: express.Response, _next: unknown) => {+ if (sendPasswordAuthorityError(error, res)) return+ res.status(500).json({ error: 'Internal Server Error' })+ }+ )+ }, 60_000)++ afterAll(async () => {+ try {+ await ambiguousProxy?.close()+ if (controlServer) {+ await new Promise<void>(resolve => controlServer!.close(() => resolve()))+ }+ if (memberRegistrationProcess && memberRegistrationProcess.exitCode === null) {+ const stopped = once(memberRegistrationProcess, 'exit')+ memberRegistrationProcess.kill('SIGTERM')+ await stopped+ }+ if (controlPool) await endPoolAndWaitForClients(controlPool)+ if (observer) await endPoolAndWaitForClients(observer)+ if (producerObserver) await endPoolAndWaitForClients(producerObserver)+ if (admin) {+ await admin.query(`DROP DATABASE IF EXISTS "${controlDatabase}"`)+ await admin.query(`DROP DATABASE IF EXISTS "${producerDatabase}"`)+ }+ } finally {+ Object.assign(controlConfig, {+ memberRegistrationMode: originalControlConfig.memberRegistrationMode,+ memberRegistrationServiceBaseUrl: originalControlConfig.memberRegistrationServiceBaseUrl,+ memberRegistrationServiceHmacSecret:+ originalControlConfig.memberRegistrationServiceHmacSecret,+ memberRegistrationServiceHmacKid: originalControlConfig.memberRegistrationServiceHmacKid,+ memberRegistrationTenantId: originalControlConfig.memberRegistrationTenantId,+ desktopExternalRestApiBaseUrl: originalControlConfig.desktopExternalRestApiBaseUrl,+ desktopRpcProxyBaseUrl: originalControlConfig.desktopRpcProxyBaseUrl,+ desktopProfileUiBaseUrl: originalControlConfig.desktopProfileUiBaseUrl,+ desktopAppName: originalControlConfig.desktopAppName,+ })+ if (originalControlConfig.internalServiceToken) {+ controlConfig.internalServiceTokens['external-rest-api'] = String(+ originalControlConfig.internalServiceToken+ )+ }+ Object.assign(externalConfig, originalExternalConfig)+ if (originalExternalJwtKey === undefined) {+ delete process.env.EXTERNAL_REST_API_JWT_PUBLIC_KEY+ } else {+ process.env.EXTERNAL_REST_API_JWT_PUBLIC_KEY = originalExternalJwtKey+ }+ await admin?.end()+ }+ })++ async function createReset(emailLabel: string) {+ const email = `r4l1-${emailLabel}-${randomUUID()}@example.invalid`+ const originalPassword = `Synthetic-R4-L1-Original-${randomUUID()}`+ const originalHash = await bcrypt.hash(originalPassword, 12)+ const userId = (+ await controlPool.query(+ 'INSERT INTO users(email, password_hash) VALUES ($1, $2) RETURNING id',+ [email, originalHash]+ )+ ).rows[0].id as string+ const invitation = await createSilentInvitationForTeams({+ inviteeName: 'Synthetic R4-L1 member',+ email,+ purpose: 'password_reset',+ teamAssignments: [],+ fallbackRole: 'member',+ })+ const sibling = await createSilentInvitationForTeams({+ inviteeName: 'Synthetic R4-L1 member',+ email,+ purpose: 'password_reset',+ teamAssignments: [],+ fallbackRole: 'member',+ })+ await registerAndSendInvitation(+ email,+ invitation.token,+ null,+ invitation.created_at.toISOString(),+ invitation.expires_at.toISOString(),+ { purpose: 'password_reset' }+ )+ const registered = await producerObserver.query<{ invitation_jwt: string }>(+ `SELECT invitation_jwt+ FROM invitation_flow_registrations+ WHERE email = $1 AND invitation_uuid = $2::uuid+ ORDER BY created_at DESC, id DESC+ LIMIT 1`,+ [email, invitation.token]+ )+ const proof = registered.rows[0]?.invitation_jwt+ expect(proof).toEqual(expect.any(String))+ return {+ email,+ userId,+ originalHash,+ invitationId: invitation.id,+ siblingId: sibling.id,+ proof: proof!,+ }+ }++ it('returns sanitized 400 for the producer invalid-payload response and allows valid retry', async () => {+ producerResponses = []+ const reset = await createReset('empty')+ const empty = await request(publicApp).post('/invitations/password').send({+ token: reset.proof,+ email: reset.email,+ invitationId: reset.invitationId,+ password: '',+ })++ expect(empty.status).toBe(400)+ expect(empty.body).toEqual({ error: 'Password must be between 8 and 256 characters' })+ expect(JSON.stringify(empty.body)).not.toContain('invalid payload')+ expect(empty.headers['set-cookie']).toBeUndefined()+ expect(producerResponses.at(-1)).toEqual({ status: 400, error: 'invalid payload' })+ const unchanged = await observer.query(+ `SELECT primary_invite.status AS reset_status,+ sibling.status AS sibling_status,+ member_user.password_hash+ FROM invitations primary_invite+ JOIN invitations sibling ON sibling.id = $2+ JOIN users member_user ON member_user.id = $3+ WHERE primary_invite.id = $1`,+ [reset.invitationId, reset.siblingId, reset.userId]+ )+ expect(unchanged.rows[0]).toMatchObject({+ reset_status: 'pending',+ sibling_status: 'pending',+ password_hash: reset.originalHash,+ })++ const replacementPassword = `Synthetic-R4-L1-Replacement-${randomUUID()}`+ const valid = await request(publicApp).post('/invitations/password').send({+ token: reset.proof,+ email: reset.email,+ invitationId: reset.invitationId,+ password: replacementPassword,+ })+ expect(valid.status).toBe(200)+ expect(valid.headers['set-cookie']).toEqual(+ expect.arrayContaining([expect.stringContaining('profile_session=')])+ )+ expect(valid.body).not.toHaveProperty('token')+ expect(valid.body).not.toHaveProperty('sessionContext')+ expect(producerResponses.at(-1)?.status).toBe(200)+ const accepted = await observer.query(+ `SELECT primary_invite.status AS reset_status,+ sibling.status AS sibling_status,+ member_user.password_hash+ FROM invitations primary_invite+ JOIN invitations sibling ON sibling.id = $2+ JOIN users member_user ON member_user.id = $3+ WHERE primary_invite.id = $1`,+ [reset.invitationId, reset.siblingId, reset.userId]+ )+ expect(accepted.rows[0]?.reset_status).toBe('accepted')+ expect(accepted.rows[0]?.sibling_status).toBe('revoked')+ expect(+ await bcrypt.compare(replacementPassword, accepted.rows[0]?.password_hash as string)+ ).toBe(true)+ }, 60_000)++ it('keeps an ambiguous post-dispatch outcome unknown and never repeats the reset', async () => {+ producerResponses = []+ const reset = await createReset('ambiguous')+ ambiguousProxy = createDropResetResponseProxy(controlApiPort)+ const proxyBaseUrl = await ambiguousProxy.start()+ externalConfig.controlApiBaseUrl = proxyBaseUrl+ const replacementPassword = `Synthetic-R4-L1-Ambiguous-${randomUUID()}`+ const unknown = await request(publicApp).post('/invitations/password').send({+ token: reset.proof,+ email: reset.email,+ invitationId: reset.invitationId,+ password: replacementPassword,+ })+ await ambiguousProxy.droppedResetResponse+ expect(unknown.status).toBe(503)+ expect(unknown.body).toEqual({ error: 'recovery_outcome_unknown', retryAfterSeconds: 2 })+ expect(unknown.headers['retry-after']).toBe('2')+ expect(unknown.headers['set-cookie']).toBeUndefined()+ expect(JSON.stringify(unknown.body)).not.toContain(reset.proof)+ expect(ambiguousProxy.resetPostCount).toBe(1)++ const committed = await observer.query(+ `SELECT primary_invite.status AS reset_status,+ sibling.status AS sibling_status,+ member_user.password_hash,+ (SELECT COUNT(*)::int FROM password_verification_work) AS owners+ FROM invitations primary_invite+ JOIN invitations sibling ON sibling.id = $2+ JOIN users member_user ON member_user.id = $3+ WHERE primary_invite.id = $1`,+ [reset.invitationId, reset.siblingId, reset.userId]+ )+ expect(committed.rows[0]).toMatchObject({+ reset_status: 'accepted',+ sibling_status: 'revoked',+ owners: 0,+ })+ expect(+ await bcrypt.compare(replacementPassword, committed.rows[0]?.password_hash as string)+ ).toBe(true)++ externalConfig.controlApiBaseUrl = controlBaseUrl+ const replay = await request(publicApp).post('/invitations/password').send({+ token: reset.proof,+ email: reset.email,+ invitationId: reset.invitationId,+ password: replacementPassword,+ })+ expect(replay.status).toBe(409)+ expect(replay.headers['set-cookie']).toBeUndefined()+ expect(ambiguousProxy.resetPostCount).toBe(1)+ expect(producerResponses.at(-1)?.status).toBe(409)+ }, 60_000)+})diff --git a/external-rest-api/package-lock.json b/external-rest-api/package-lock.jsonindex 81b894be2..1b351481e 100644--- a/external-rest-api/package-lock.json+++ b/external-rest-api/package-lock.json@@ -1,12 +1,12 @@{"name": "clerum-external-rest-api",- "version": "0.1.111",+ "version": "0.1.112","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "clerum-external-rest-api",- "version": "0.1.111",+ "version": "0.1.112","dependencies": {"@clerum/jwt-key-policy": "file:../packages/jwt-key-policy","cors": "^2.8.5",diff --git a/external-rest-api/package.json b/external-rest-api/package.jsonindex 3cabb19d0..e08b2fd04 100644--- a/external-rest-api/package.json+++ b/external-rest-api/package.json@@ -1,6 +1,6 @@{"name": "clerum-external-rest-api",- "version": "0.1.111",+ "version": "0.1.112","description": "External REST API for profile, team management, and RPC token brokerage","main": "dist/main.js","engines": {diff --git a/external-rest-api/src/releaseManifest.ts b/external-rest-api/src/releaseManifest.tsindex e095ddec4..f5c1670c2 100644--- a/external-rest-api/src/releaseManifest.ts+++ b/external-rest-api/src/releaseManifest.ts@@ -8,7 +8,7 @@ export type ReleaseManifest = {export const releaseManifest: ReleaseManifest = {releaseId: 'v0.10.0',- externalRestApiVersion: '0.1.111',+ externalRestApiVersion: '0.1.112',rpcProxyVersion: '0.1.126',desktopVersion: '0.10.0',minimumDesktopVersion: '0.1.252',diff --git a/external-rest-api/src/services/invitationsService.ts b/external-rest-api/src/services/invitationsService.tsindex eb6af9468..4dcbf09b4 100644--- a/external-rest-api/src/services/invitationsService.ts+++ b/external-rest-api/src/services/invitationsService.ts@@ -47,9 +47,17 @@ function controlApiErrorCode(error: ControlApiError): string | null {return null}-function resetPasswordDomainError(error: ControlApiError): ResetPasswordDomainError | null {+function resetPasswordDomainError(+ error: ControlApiError,+ password: string+): ResetPasswordDomainError | null {const code = controlApiErrorCode(error)if (error.status === 400 && code === 'invalid_password') return 'invalid_password'+ // The public reset route has already required token, email, and invitation ID.+ // The producer's exact payload error therefore identifies an empty password.+ if (error.status === 400 && code === 'invalid payload' && password.length === 0) {+ return 'invalid_password'+ }if (error.status === 400 && code === 'invalid_invitation') return 'invalid_invitation'if (error.status === 401 && code === 'user_retired') return 'invalid_invitation'if (error.status === 403 && code === 'forbidden') return 'forbidden'@@ -267,7 +275,7 @@ export async function setupInvitationPasswordWithToken(} catch (error) {if (error instanceof ControlApiError && [429, 503].includes(error.status)) throw errorif (error instanceof ControlApiError) {- const domainError = resetPasswordDomainError(error)+ const domainError = resetPasswordDomainError(error, password)if (domainError) return { error: domainError }if (error.status < 500) throw passwordAuthorityUnavailable()}diff --git a/external-rest-api/test/services.invitationsService.recovery.test.ts b/external-rest-api/test/services.invitationsService.recovery.test.tsindex d16d07c96..b7f2446e2 100644--- a/external-rest-api/test/services.invitationsService.recovery.test.ts+++ b/external-rest-api/test/services.invitationsService.recovery.test.ts@@ -40,4 +40,22 @@ describe('setupInvitationPasswordWithToken', () => {)).resolves.toEqual({ error: 'invalid_password' })})++ it('keeps invalid-payload outside the allowlist when a password was supplied', async () => {+ fetchMock.mockResolvedValue(+ new Response(JSON.stringify({ error: 'invalid payload' }), { status: 400 })+ )++ await expect(+ setupInvitationPasswordWithToken(+ 'synthetic-proof',+ '[email protected]',+ 'synthetic-row-id',+ 'Synthetic-Valid-Password-123'+ )+ ).rejects.toMatchObject({+ status: 503,+ body: { error: 'authority_unavailable' },+ })+ })})