Skip to content

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.json
index 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.json
index 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.ts
new file mode 100644
index 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.json
index 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.json
index 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.ts
index 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.ts
index 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 error
if (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.ts
index 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',
+ 'synthetic-row-id',
+ 'Synthetic-Valid-Password-123'
+ )
+ ).rejects.toMatchObject({
+ status: 503,
+ body: { error: 'authority_unavailable' },
+ })
+ })
})