Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
fix(profile-ui): route invitation password setup by purpose (r16-h1)
Josué9410fb6ef15c
diff --git a/Makefile b/Makefileindex 718643243..ad2e82117 100644--- a/Makefile+++ b/Makefile@@ -1510,6 +1510,7 @@ test-playwright-desktop: ## Run Playwright tests for Desktop App only (requires:.PHONY: test-playwright-profile-ui-recoverytest-playwright-profile-ui-recovery: ## Audit and run the Profile UI password-recovery browser journey@python3 tools/e2e_static_audit.py tests/e2e/playwright/profile-ui-recovery/reset-session-hydration.spec.ts+ @python3 tools/e2e_static_audit.py tests/e2e/playwright/profile-ui-recovery/ordinary-invitation-onboarding.spec.ts@cd tests/e2e/playwright && node run-profile-ui-recovery.mjs.PHONY: test-playwright-headeddiff --git a/control-api/package-lock.json b/control-api/package-lock.jsonindex e5e850253..f0e1c8757 100644--- a/control-api/package-lock.json+++ b/control-api/package-lock.json@@ -1,12 +1,12 @@{"name": "clerum-control-api",- "version": "0.1.780",+ "version": "0.1.781","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "clerum-control-api",- "version": "0.1.780",+ "version": "0.1.781","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 ff1bf0d1b..b92979931 100644--- a/control-api/package.json+++ b/control-api/package.json@@ -1,6 +1,6 @@{"name": "clerum-control-api",- "version": "0.1.780",+ "version": "0.1.781","description": "Internal Clerum control plane REST API + UI for managing CRDs and secrets","main": "dist/main.js","engines": {diff --git a/control-api/test/passwordRecovery.http.realPostgres.integration.test.ts b/control-api/test/passwordRecovery.http.realPostgres.integration.test.tsindex b836607ba..ca987daa6 100644--- a/control-api/test/passwordRecovery.http.realPostgres.integration.test.ts+++ b/control-api/test/passwordRecovery.http.realPostgres.integration.test.ts@@ -27,6 +27,7 @@ realPg('R2-M1/R2-M2 public password authority contract on PostgreSQL 16', () =>let publicProcess: ExternalRestHttpProcesslet bcrypt: typeof import('bcryptjs').defaultlet sourceCounter = 1+ const invitationFlowFixtures = new Map<string, { email: string; invitationUuid: string }>()beforeAll(async () => {admin = new Pool({ connectionString: adminUrl })@@ -47,6 +48,16 @@ realPg('R2-M1/R2-M2 public password authority contract on PostgreSQL 16', () =>publicKey.export({ type: 'spki', format: 'pem' }).toString())vi.resetModules()+ vi.doMock('../src/services/invitationFlowRegistrationService.js', () => ({+ validateInvitationFlowToken: vi.fn(async (token: string, email?: string) => {+ const flow = invitationFlowFixtures.get(token)+ if (!flow || (email && flow.email !== email.toLowerCase())) {+ throw new Error('invalid synthetic invitation flow')+ }+ return flow+ }),+ storeDesktopAuthorizationToken: vi.fn(),+ }))bcrypt = (await import('bcryptjs')).defaultdb = await import('../src/db.js')@@ -171,6 +182,18 @@ realPg('R2-M1/R2-M2 public password authority contract on PostgreSQL 16', () =>.send({ invitationId: session.invitationId, password })}+ async function invitationPasswordRequestWithoutSession(+ invitation: { id: string; token: string },+ email: string,+ sourceIp: string,+ password = invitationPassword+ ) {+ return request(publicApp)+ .post('/api/v1/invitations/password')+ .set('x-forwarded-for', sourceIp)+ .send({ token: invitation.token, email, invitationId: invitation.id, password })+ }+async function memberPasswordRequest(token: string,sourceIp: string,@@ -231,6 +254,79 @@ realPg('R2-M1/R2-M2 public password authority contract on PostgreSQL 16', () =>).toBe(true)})+ it.each(['member_invitation', 'admin_desktop_access'] as const)(+ 'composes token-based %s onboarding through the ordinary endpoint and persists its identity',+ async purpose => {+ const { createSilentInvitationForTeams } =+ await import('../src/services/directory/membership.js')+ const email = `r16-${purpose}-${randomBytes(8).toString('hex')}@example.invalid`+ const teamId = (+ await db.pool.query('INSERT INTO teams(name) VALUES ($1) RETURNING id', [+ `Synthetic ${purpose} onboarding team`,+ ])+ ).rows[0].id as string+ const role = purpose === 'admin_desktop_access' ? 'admin' : 'member'+ const invitation = await createSilentInvitationForTeams({+ inviteeName: `Synthetic ${purpose} invitee`,+ email,+ purpose,+ teamAssignments: [{ teamId, role }],+ fallbackRole: role,+ })+ const flowToken = `synthetic-r16-flow-${randomBytes(20).toString('hex')}`+ invitationFlowFixtures.set(flowToken, { email, invitationUuid: invitation.token })+ const password = `Synthetic-${purpose}-Onboarding-123`+ const response = await invitationPasswordRequestWithoutSession(+ { id: invitation.id, token: flowToken },+ email,+ nextSourceIp(),+ password+ )++ expect(response.status, JSON.stringify(response.body)).toBe(200)+ expect(response.body).toMatchObject({+ passwordUpdated: true,+ purpose,+ status: 'accepted',+ email,+ role,+ })+ expect(String(response.headers['set-cookie'])).toContain('profile_session=')++ const invitationRow = await db.pool.query(+ 'SELECT purpose, status, accepted_user_id FROM invitations WHERE id = $1',+ [invitation.id]+ )+ expect(invitationRow.rows).toEqual([+ expect.objectContaining({+ purpose,+ status: 'accepted',+ accepted_user_id: response.body.userId,+ }),+ ])+ const userRow = await db.pool.query(+ 'SELECT id, email, password_hash FROM users WHERE id = $1',+ [response.body.userId]+ )+ expect(userRow.rows[0]).toMatchObject({ id: response.body.userId, email })+ expect(await bcrypt.compare(password, userRow.rows[0].password_hash)).toBe(true)+ const memberships = await db.pool.query(+ 'SELECT team_id, role, status FROM team_members WHERE user_id = $1 AND team_id = $2',+ [response.body.userId, teamId]+ )+ expect(memberships.rows).toEqual([{ team_id: teamId, role, status: 'active' }])++ const sessionCookie = String(response.headers['set-cookie'])+ .split(';', 1)[0]+ .replace(/^profile_session=/, '')+ const identity = await request(publicApp)+ .get('/api/v1/me')+ .set('cookie', `profile_session=${sessionCookie}`)+ expect(identity.status).toBe(200)+ expect(identity.body).toMatchObject({ id: response.body.userId, email, role })+ }+ )+it('returns sanitized authority unavailability without consuming invitation state', async () => {const session = await acceptedInvitationSession()const sourceIp = nextSourceIp()diff --git a/profile-ui/app/components/__tests__/InvitationClient.reset.test.tsx b/profile-ui/app/components/__tests__/InvitationClient.reset.test.tsxindex af7320b4f..8fabede8a 100644--- a/profile-ui/app/components/__tests__/InvitationClient.reset.test.tsx+++ b/profile-ui/app/components/__tests__/InvitationClient.reset.test.tsx@@ -9,6 +9,7 @@ const mocks = vi.hoisted(() => ({acceptInvitation: vi.fn(),checkAuth: vi.fn(),routerReplace: vi.fn(),+ setupAcceptedInvitationPasswordWithToken: vi.fn(),setupInvitationPasswordWithToken: vi.fn(),}))@@ -26,6 +27,7 @@ vi.mock('@lib/api', async () => {...actual,acceptInvitation: mocks.acceptInvitation,getEvenfireDownloadUrl: () => 'https://downloads.example.invalid/evenfire',+ setupAcceptedInvitationPasswordWithToken: mocks.setupAcceptedInvitationPasswordWithToken,setupInvitationPasswordWithToken: mocks.setupInvitationPasswordWithToken,}})@@ -44,6 +46,24 @@ const passwordReset: InvitationPreview = {passwordPending: true,}+const acceptedMemberInvitation: InvitationPreview = {+ ...passwordReset,+ purpose: 'member_invitation',+ status: 'accepted',+ passwordPending: true,+}++const acceptedAdminDesktopInvitation: InvitationPreview = {+ ...passwordReset,+ id: 'admin-invite-1',+ email: '[email protected]',+ role: 'admin',+ purpose: 'admin_desktop_access',+ status: 'accepted',+ passwordPending: true,+ userId: 'admin-user-1',+}+function fillPassword() {fireEvent.change(screen.getByLabelText('Password'), {target: { value: 'new-synthetic-password' },@@ -60,6 +80,11 @@ beforeEach(() => {me: { id: 'user-1', email: '[email protected]' },})mocks.routerReplace.mockReset()+ mocks.setupAcceptedInvitationPasswordWithToken.mockReset().mockResolvedValue({+ ...acceptedMemberInvitation,+ passwordPending: false,+ passwordUpdated: true,+ })mocks.setupInvitationPasswordWithToken.mockReset().mockResolvedValue({...passwordReset,status: 'accepted',@@ -156,22 +181,41 @@ describe('InvitationClient verified password recovery', () => {})it('keeps member invitation password setup on its existing page flow', async () => {- mocks.setupInvitationPasswordWithToken.mockResolvedValue({- ...passwordReset,- purpose: 'member_invitation',- status: 'accepted',+ mocks.setupInvitationPasswordWithToken.mockRejectedValue(+ new ProfileApiError(409, 'invitation_not_pending', '409 Conflict - invitation_not_pending')+ )+ render(+ <InvitationClient+ invitationToken="member-invitation-proof"+ initialInvitation={acceptedMemberInvitation}+ initialError=""+ />+ )++ fillPassword()+ fireEvent.click(screen.getByRole('button', { name: 'Set password and continue' }))++ await waitFor(() => expect(screen.getByText('You are now registered with Evenfire.')))+ expect(mocks.routerReplace).not.toHaveBeenCalled()+ expect(mocks.setupAcceptedInvitationPasswordWithToken).toHaveBeenCalledWith(+ 'member-invitation-proof',+ '[email protected]',+ 'reset-1',+ 'new-synthetic-password'+ )+ expect(mocks.setupInvitationPasswordWithToken).not.toHaveBeenCalled()+ })++ it('keeps admin desktop password setup on the ordinary invitation operation', async () => {+ mocks.setupAcceptedInvitationPasswordWithToken.mockResolvedValue({+ ...acceptedAdminDesktopInvitation,passwordPending: false,passwordUpdated: true,})render(<InvitationClient- invitationToken="member-invitation-proof"- initialInvitation={{- ...passwordReset,- purpose: 'member_invitation',- status: 'accepted',- passwordPending: true,- }}+ invitationToken="admin-invitation-proof"+ initialInvitation={acceptedAdminDesktopInvitation}initialError=""/>)@@ -180,7 +224,13 @@ describe('InvitationClient verified password recovery', () => {fireEvent.click(screen.getByRole('button', { name: 'Set password and continue' }))await waitFor(() => expect(screen.getByText('You are now registered with Evenfire.')))- expect(mocks.routerReplace).not.toHaveBeenCalled()+ expect(mocks.setupAcceptedInvitationPasswordWithToken).toHaveBeenCalledWith(+ 'admin-invitation-proof',+ '[email protected]',+ 'admin-invite-1',+ 'new-synthetic-password'+ )+ expect(mocks.setupInvitationPasswordWithToken).not.toHaveBeenCalled()})it('shows a retryable message when bounded recovery admission is busy', async () => {diff --git a/profile-ui/app/invitations/[token]/InvitationClient.tsx b/profile-ui/app/invitations/[token]/InvitationClient.tsxindex d6333a2c3..81c541ec4 100644--- a/profile-ui/app/invitations/[token]/InvitationClient.tsx+++ b/profile-ui/app/invitations/[token]/InvitationClient.tsx@@ -19,6 +19,7 @@ import {ProfileApiError,acceptInvitation,getEvenfireDownloadUrl,+ setupAcceptedInvitationPasswordWithToken,setupInvitationPasswordWithToken,} from '@lib/api'import {@@ -323,7 +324,10 @@ export function InvitationClient({setSubmitting('password')if (isPasswordReset) setRecoveryPhase({ state: 'submitting' })try {- const response = await setupInvitationPasswordWithToken(+ const setupPassword = isPasswordReset+ ? setupInvitationPasswordWithToken+ : setupAcceptedInvitationPasswordWithToken+ const response = await setupPassword(invitationToken,invitation.email,invitation.id,diff --git a/profile-ui/lib/api.ts b/profile-ui/lib/api.tsindex f26fcec43..589c2fd3c 100644--- a/profile-ui/lib/api.ts+++ b/profile-ui/lib/api.ts@@ -263,6 +263,22 @@ export async function setupInvitationPasswordWithToken(return response}+export async function setupAcceptedInvitationPasswordWithToken(+ invitationUrlId: string,+ email: string,+ invitationId: string,+ password: string+): Promise<InvitationPreview & { passwordUpdated: boolean }> {+ const response = (await apiSend('POST', '/api/v1/invitations/password', {+ token: invitationUrlId,+ email,+ invitationId,+ password,+ })) as InvitationPreview & { passwordUpdated: boolean }+ clearToken()+ return response+}+export async function getMe(options: ApiRequestOptions = {}): Promise<Me> {return apiGet('/api/v1/me', {}, options) as Promise<Me>}diff --git a/profile-ui/package-lock.json b/profile-ui/package-lock.jsonindex 793031c8f..ba44f58b3 100644--- a/profile-ui/package-lock.json+++ b/profile-ui/package-lock.json@@ -1,12 +1,12 @@{"name": "clerum-profile-ui",- "version": "0.1.178",+ "version": "0.1.179","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "clerum-profile-ui",- "version": "0.1.178",+ "version": "0.1.179","dependencies": {"@clerum/desktop-app-links": "file:../packages/desktop-app-links","@clerum/frontend-components": "file:../packages/frontend-components",diff --git a/profile-ui/package.json b/profile-ui/package.jsonindex d2c7ebd38..d8d8f21db 100644--- a/profile-ui/package.json+++ b/profile-ui/package.json@@ -1,6 +1,6 @@{"name": "clerum-profile-ui",- "version": "0.1.178",+ "version": "0.1.179","private": true,"scripts": {"dev": "next dev",diff --git a/tests/e2e/playwright/package-lock.json b/tests/e2e/playwright/package-lock.jsonindex 48e30a2bb..8f1f75870 100644--- a/tests/e2e/playwright/package-lock.json+++ b/tests/e2e/playwright/package-lock.json@@ -1,12 +1,12 @@{"name": "clerum-playwright-tests",- "version": "0.1.79",+ "version": "0.1.80","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "clerum-playwright-tests",- "version": "0.1.79",+ "version": "0.1.80","devDependencies": {"@playwright/test": "^1.50.0","@types/node": "^22.0.0",diff --git a/tests/e2e/playwright/package.json b/tests/e2e/playwright/package.jsonindex 90eb88e2b..b1ef8f21d 100644--- a/tests/e2e/playwright/package.json+++ b/tests/e2e/playwright/package.json@@ -1,6 +1,6 @@{"name": "clerum-playwright-tests",- "version": "0.1.79",+ "version": "0.1.80","private": true,"description": "Playwright E2E tests for Control UI and Desktop App","scripts": {diff --git a/tests/e2e/playwright/profile-ui-recovery-fixture.mjs b/tests/e2e/playwright/profile-ui-recovery-fixture.mjsindex 4e84d03fb..00e80be07 100644--- a/tests/e2e/playwright/profile-ui-recovery-fixture.mjs+++ b/tests/e2e/playwright/profile-ui-recovery-fixture.mjs@@ -1,5 +1,5 @@import { spawn, spawnSync } from 'node:child_process'-import { generateKeyPairSync } from 'node:crypto'+import { generateKeyPairSync, sign, verify } from 'node:crypto'import { createServer } from 'node:http'import path from 'node:path'import { fileURLToPath } from 'node:url'@@ -38,11 +38,76 @@ const member = {profile: { displayName: 'Synthetic Member', channels: {} },}+const ordinaryInvitations = new Map([+ [+ 'synthetic-member-invitation',+ {+ id: 'synthetic-member-invitation-row',+ teamId: 'synthetic-member-team',+ teamName: 'Synthetic Member Team',+ email: '[email protected]',+ role: 'member',+ purpose: 'member_invitation',+ status: 'pending',+ expiresAt: '2030-01-01T00:00:00.000Z',+ acceptedAt: null,+ acceptedUserId: null,+ userId: 'synthetic-member-onboarding-user',+ passwordPending: true,+ passwordMutationCount: 0,+ },+ ],+ [+ 'synthetic-admin-invitation',+ {+ id: 'synthetic-admin-invitation-row',+ teamId: null,+ teamName: null,+ email: '[email protected]',+ role: 'admin',+ purpose: 'admin_desktop_access',+ status: 'accepted',+ expiresAt: '2030-01-01T00:00:00.000Z',+ acceptedAt: '2026-10-16T00:00:00.000Z',+ acceptedUserId: 'synthetic-admin-onboarding-user',+ userId: 'synthetic-admin-onboarding-user',+ passwordPending: true,+ passwordMutationCount: 0,+ },+ ],+ [+ 'synthetic-wrong-purpose-invitation',+ {+ id: 'synthetic-wrong-purpose-invitation-row',+ teamId: null,+ teamName: null,+ email: '[email protected]',+ role: 'member',+ purpose: 'member_invitation',+ status: 'pending',+ expiresAt: '2030-01-01T00:00:00.000Z',+ acceptedAt: null,+ acceptedUserId: null,+ userId: 'synthetic-wrong-purpose-user',+ passwordPending: true,+ passwordMutationCount: 0,+ },+ ],+])+const ordinaryMetrics = {+ acceptanceRequests: [],+ passwordRequests: [],+ resetRequests: [],+ meRequests: [],+}+let resetPosts = 0let authenticatedMeReads = 0let passwordChanged = falselet contractResetPosts = 0let externalRestBaseUrl+let sessionPrivateKey+let sessionPublicKeyfunction sendJson(response, status, body, headers = {}) {response.writeHead(status, {@@ -58,9 +123,156 @@ async function readJson(request) {return JSON.parse(Buffer.concat(chunks).toString('utf8'))}+async function readBody(request) {+ const chunks = []+ for await (const chunk of request) chunks.push(chunk)+ return Buffer.concat(chunks)+}++function sessionTokenFor(invitation) {+ if (!sessionPrivateKey) throw new Error('Synthetic session signer is unavailable')+ const now = Math.floor(Date.now() / 1000)+ const header = Buffer.from(JSON.stringify({ alg: 'RS256', typ: 'JWT' })).toString('base64url')+ const payload = Buffer.from(+ JSON.stringify({+ userId: invitation.userId,+ email: invitation.email,+ teamId: invitation.teamId,+ role: invitation.role,+ authGeneration: 1,+ iat: now,+ exp: now + 3600,+ iss: 'control-api',+ aud: 'profile-ui',+ })+ ).toString('base64url')+ const signed = `${header}.${payload}`+ return `${signed}.${sign('RSA-SHA256', Buffer.from(signed), sessionPrivateKey).toString('base64url')}`+}++function sessionClaims(token) {+ if (!sessionPublicKey || typeof token !== 'string') return null+ const [header, payload, signature] = token.split('.')+ if (!header || !payload || !signature) return null+ const signed = `${header}.${payload}`+ if (+ !verify(+ 'RSA-SHA256',+ Buffer.from(signed),+ sessionPublicKey,+ Buffer.from(signature, 'base64url')+ )+ ) {+ return null+ }+ try {+ const claims = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'))+ if (+ claims.iss !== 'control-api' ||+ claims.aud !== 'profile-ui' ||+ typeof claims.exp !== 'number' ||+ claims.exp <= Math.floor(Date.now() / 1000)+ ) {+ return null+ }+ return claims+ } catch {+ return null+ }+}++function invitationForToken(token) {+ return ordinaryInvitations.get(token) || null+}++function ordinarySnapshot() {+ return {+ operations: ordinaryMetrics,+ invitations: [...ordinaryInvitations.values()].map(+ ({+ id,+ purpose,+ status,+ userId,+ acceptedUserId,+ passwordPending,+ passwordMutationCount,+ }) => ({+ id,+ purpose,+ status,+ userId,+ acceptedUserId,+ passwordPending,+ passwordMutationCount,+ })+ ),+ }+}++async function proxyExternalRest(request, response, path, bodyOverride) {+ try {+ const headers = {}+ for (const name of ['content-type', 'cookie', 'authorization', 'origin', 'sec-fetch-site']) {+ if (request.headers[name]) headers[name] = request.headers[name]+ }+ headers['x-forwarded-for'] = request.headers['x-forwarded-for'] || '192.0.2.48'+ const body =+ bodyOverride !== undefined+ ? Buffer.from(JSON.stringify(bodyOverride))+ : ['GET', 'HEAD'].includes(request.method || 'GET')+ ? undefined+ : await readBody(request)+ const upstream = await fetch(`${externalRestBaseUrl}${path}`, {+ method: request.method,+ headers,+ body,+ redirect: 'manual',+ })+ const responseHeaders = {+ 'content-type': upstream.headers.get('content-type') || 'application/json',+ }+ const cookies = upstream.headers.getSetCookie?.() || []+ if (cookies.length > 0) responseHeaders['set-cookie'] = cookies+ else if (upstream.headers.get('set-cookie')) {+ responseHeaders['set-cookie'] = upstream.headers.get('set-cookie')+ }+ response.writeHead(upstream.status, responseHeaders)+ response.end(await upstream.text())+ } catch {+ sendJson(response, 502, { error: 'synthetic_external_rest_unavailable' })+ }+}+const apiServer = createServer(async (request, response) => {const url = new URL(request.url || '/', 'http://127.0.0.1')+ const publicInvitationMatch = url.pathname.match(/^\/api\/v1\/invitations\/token\/([^/]+)$/)+ if (request.method === 'GET' && publicInvitationMatch) {+ const token = decodeURIComponent(publicInvitationMatch[1])+ if (invitationForToken(token)) {+ await proxyExternalRest(request, response, `${url.pathname}${url.search}`)+ return+ }+ }++ if (+ request.method === 'POST' &&+ ['/api/v1/invitations/accept', '/api/v1/invitations/password'].includes(url.pathname)+ ) {+ let body+ try {+ body = await readJson(request)+ } catch {+ sendJson(response, 400, { error: 'invalid_payload' })+ return+ }+ if (invitationForToken(String(body.token || ''))) {+ await proxyExternalRest(request, response, `${url.pathname}${url.search}`, body)+ return+ }+ }+if (request.method === 'GET' && url.pathname === `/api/v1/invitations/token/${invitationToken}`) {sendJson(response, 200, invitation)return@@ -99,6 +311,13 @@ const apiServer = createServer(async (request, response) => {}return}+ if (invitationForToken(String(body.token || ''))) {+ ordinaryMetrics.resetRequests.push({+ id: invitationForToken(String(body.token)).id,+ })+ await proxyExternalRest(request, response, `${url.pathname}${url.search}`, body)+ return+ }resetPosts += 1if (body.token !== invitationToken ||@@ -127,18 +346,21 @@ const apiServer = createServer(async (request, response) => {}if (request.method === 'GET' && url.pathname === '/api/v1/me') {- if (- !String(request.headers.cookie || '').includes('profile_session=synthetic-recovered-session')- ) {- sendJson(response, 401, { error: 'Unauthorized' })+ const cookie = String(request.headers.cookie || '')+ if (cookie.includes('profile_session=synthetic-recovered-session')) {+ authenticatedMeReads += 1+ if (authenticatedMeReads === 1) {+ sendJson(response, 404, { error: 'User not found' })+ return+ }+ sendJson(response, 200, member)return}- authenticatedMeReads += 1- if (authenticatedMeReads === 1) {- sendJson(response, 404, { error: 'User not found' })+ if (!cookie.includes('profile_session=')) {+ sendJson(response, 401, { error: 'Unauthorized' })return}- sendJson(response, 200, member)+ await proxyExternalRest(request, response, `${url.pathname}${url.search}`)return}@@ -148,6 +370,140 @@ const apiServer = createServer(async (request, response) => {authenticatedMeReads,passwordChanged,contractResetPosts,+ ordinary: ordinarySnapshot(),+ })+ return+ }++ const invitationTokenMatch = url.pathname.match(+ /^\/api\/v1\/external\/invitations\/token\/([^/]+)$/+ )+ if (request.method === 'GET' && invitationTokenMatch) {+ if (request.headers.authorization !== syntheticServiceAuthorization) {+ sendJson(response, 401, { error: 'Unauthorized' })+ return+ }+ const token = decodeURIComponent(invitationTokenMatch[1])+ const invited = invitationForToken(token)+ if (!invited) {+ sendJson(response, 404, { error: 'not_found' })+ return+ }+ sendJson(response, 200, invited)+ return+ }++ if (request.method === 'POST' && url.pathname === '/api/v1/external/invitations/accept') {+ let body+ try {+ body = await readJson(request)+ } catch {+ sendJson(response, 400, { error: 'invalid_payload' })+ return+ }+ const invited = invitationForToken(String(body.token || ''))+ if (request.headers.authorization !== syntheticServiceAuthorization) {+ sendJson(response, 401, { error: 'Unauthorized' })+ return+ }+ if (!invited || String(body.email || '').toLowerCase() !== invited.email.toLowerCase()) {+ sendJson(response, 403, { error: 'forbidden' })+ return+ }+ if (invited.purpose === 'password_reset' || invited.status === 'revoked') {+ sendJson(response, 400, { error: 'not_pending' })+ return+ }+ if (invited.acceptedUserId && invited.acceptedUserId !== invited.userId) {+ sendJson(response, 403, { error: 'forbidden' })+ return+ }+ invited.status = 'accepted'+ invited.acceptedAt ||= new Date().toISOString()+ invited.acceptedUserId = invited.userId+ ordinaryMetrics.acceptanceRequests.push({ id: invited.id, purpose: invited.purpose })+ sendJson(response, 200, {+ accepted: true,+ ...invited,+ token: sessionTokenFor(invited),+ })+ return+ }++ if (request.method === 'POST' && url.pathname === '/api/v1/external/invitations/password') {+ let body+ try {+ body = await readJson(request)+ } catch {+ sendJson(response, 400, { error: 'invalid_payload' })+ return+ }+ if (request.headers.authorization !== syntheticServiceAuthorization) {+ sendJson(response, 401, { error: 'Unauthorized' })+ return+ }+ const claims = sessionClaims(String(request.headers['x-user-session-token'] || ''))+ const selected = [...ordinaryInvitations.values()].find(item => item.id === body.invitationId)+ if (+ !claims ||+ !selected ||+ claims.userId !== selected.userId ||+ claims.email !== selected.email ||+ body.userId !== selected.userId ||+ String(body.email || '').toLowerCase() !== selected.email.toLowerCase() ||+ selected.acceptedUserId !== selected.userId+ ) {+ sendJson(response, 403, { error: 'forbidden' })+ return+ }+ if (+ selected.purpose === 'password_reset' ||+ !['member_invitation', 'admin_desktop_access'].includes(selected.purpose)+ ) {+ sendJson(response, 404, { error: 'not_found' })+ return+ }+ if (+ selected.status !== 'accepted' ||+ !selected.passwordPending ||+ selected.passwordMutationCount+ ) {+ sendJson(response, 409, { error: 'invitation_not_pending' })+ return+ }+ if (typeof body.password !== 'string' || body.password.trim().length < 8) {+ sendJson(response, 400, { error: 'invalid_password' })+ return+ }+ selected.passwordMutationCount += 1+ selected.passwordPending = false+ ordinaryMetrics.passwordRequests.push({ id: selected.id, purpose: selected.purpose })+ sendJson(response, 200, { ...selected, passwordUpdated: true })+ return+ }++ const meMatch = url.pathname.match(/^\/api\/v1\/external\/users\/([^/]+)\/me$/)+ if (request.method === 'GET' && meMatch) {+ if (request.headers.authorization !== syntheticServiceAuthorization) {+ sendJson(response, 401, { error: 'Unauthorized' })+ return+ }+ const claims = sessionClaims(String(request.headers['x-user-session-token'] || ''))+ const invited = [...ordinaryInvitations.values()].find(item => item.userId === meMatch[1])+ if (!claims || !invited || claims.userId !== invited.userId || claims.email !== invited.email) {+ sendJson(response, 403, { error: 'forbidden' })+ return+ }+ ordinaryMetrics.meRequests.push({ id: invited.id, userId: claims.userId })+ sendJson(response, 200, {+ id: invited.userId,+ email: invited.email,+ name: invited.role === 'admin' ? 'Synthetic Admin' : 'Synthetic Member',+ picture: null,+ teamId: invited.teamId,+ teamName: invited.teamName,+ role: invited.role,+ profile: { displayName: invited.role === 'admin' ? 'Synthetic Admin' : 'Synthetic Member' },})return}@@ -160,6 +516,16 @@ const apiServer = createServer(async (request, response) => {sendJson(response, 400, { error: 'invalid_payload' })return}+ const ordinaryInvitation = invitationForToken(String(body.token || ''))+ if (ordinaryInvitation) {+ ordinaryMetrics.resetRequests.push({ id: ordinaryInvitation.id })+ if (body.email !== ordinaryInvitation.email || body.invitationId !== ordinaryInvitation.id) {+ sendJson(response, 403, { error: 'forbidden' })+ } else {+ sendJson(response, 409, { error: 'invitation_not_pending' })+ }+ return+ }if (request.headers.authorization !== syntheticServiceAuthorization ||body.token !== invitationToken ||@@ -205,7 +571,9 @@ await new Promise((resolve, reject) => {const apiAddress = apiServer.address()if (!apiAddress || typeof apiAddress === 'string') throw new Error('Fixture API did not bind TCP')-const { publicKey } = generateKeyPairSync('rsa', { modulusLength: 2048 })+const { privateKey, publicKey } = generateKeyPairSync('rsa', { modulusLength: 2048 })+sessionPrivateKey = privateKey+sessionPublicKey = publicKeyconst externalRestProcess = spawn(process.execPath,[path.join(externalRestRoot, 'test/helpers/passwordRecoveryHttpServer.mjs')],@@ -247,6 +615,11 @@ externalRestBaseUrl = await new Promise((resolve, reject) => {})const nextBinary = path.join(profileUiRoot, 'node_modules/next/dist/bin/next')+const nextEnvironment = Object.fromEntries(+ ['PATH', 'HOME', 'TMPDIR', 'LANG', 'LC_ALL']+ .filter(name => typeof process.env[name] === 'string')+ .map(name => [name, process.env[name]])+)const nextProcess = spawn(process.execPath,[@@ -262,7 +635,7 @@ const nextProcess = spawn({cwd: profileUiRoot,env: {- ...process.env,+ ...nextEnvironment,EXTERNAL_REST_API_INTERNAL_URL: `http://127.0.0.1:${apiAddress.port}`,NEXT_TELEMETRY_DISABLED: '1',NODE_ENV: 'development',diff --git a/tests/e2e/playwright/profile-ui-recovery/ordinary-invitation-onboarding.spec.ts b/tests/e2e/playwright/profile-ui-recovery/ordinary-invitation-onboarding.spec.tsnew file mode 100644index 000000000..f7f1aa5fb--- /dev/null+++ b/tests/e2e/playwright/profile-ui-recovery/ordinary-invitation-onboarding.spec.ts@@ -0,0 +1,189 @@+import { expect, test } from '@playwright/test'++async function readMetrics(page: import('@playwright/test').Page) {+ const response = await page.request.get('/external-rest-api/__test/metrics')+ expect(response.status()).toBe(200)+ return response.json()+}++test('member accepts the prepared invitation and establishes its own password', async ({+ page,+}) => {+ // E2E_GUARDIAN_NAVIGATION: email-reset-entry — synthetic emailed invitation entry+ await page.goto('/invitations/synthetic-member-invitation')++ await expect(page.getByRole('heading', { name: 'Join Synthetic Member Team team' })).toBeVisible()+ await expect(page.getByText('[email protected]', { exact: true })).toBeVisible()+ await expect(page.getByText('Synthetic Member Team', { exact: true })).toBeVisible()+ await expect(page.getByText('Participant', { exact: true })).toBeVisible()++ const acceptPromise = page.waitForResponse(+ response =>+ response.url().endsWith('/api/v1/invitations/accept') &&+ response.request().method() === 'POST'+ )+ await page.getByRole('button', { name: 'Accept invitation' }).click()+ const accepted = await acceptPromise+ expect(accepted.status()).toBe(200)+ await expect(+ page.getByText('Set your password to finish joining Synthetic Member Team.')+ ).toBeVisible()++ await page.getByLabel('Password', { exact: true }).fill('Synthetic-Member-Onboarding-123')+ await page.getByLabel('Confirm password').fill('Synthetic-Member-Onboarding-123')+ const passwordResponsePromise = page.waitForResponse(+ response =>+ /\/api\/v1\/invitations\/password(?:-reset)?$/.test(response.url()) &&+ response.request().method() === 'POST'+ )+ await page.getByRole('button', { name: 'Set password and continue' }).click()+ const passwordResponse = await passwordResponsePromise+ expect(new URL(passwordResponse.url()).pathname).toBe(+ '/external-rest-api/api/v1/invitations/password'+ )+ expect(passwordResponse.status()).toBe(200)+ await expect(+ page.getByText('You are now registered to Synthetic Member Team.', { exact: true })+ ).toBeVisible()++ const cookies = await page.context().cookies()+ expect(cookies).toContainEqual(+ expect.objectContaining({ name: 'profile_session', httpOnly: true, sameSite: 'Lax' })+ )+ const identity = await page.evaluate(async () => {+ const response = await fetch('/external-rest-api/api/v1/me')+ return { status: response.status, body: await response.json() }+ })+ expect(identity).toMatchObject({+ status: 200,+ body: {+ id: 'synthetic-member-onboarding-user',+ email: '[email protected]',+ teamId: 'synthetic-member-team',+ role: 'member',+ },+ })++ const metrics = await readMetrics(page)+ expect(metrics.ordinary.operations.acceptanceRequests).toEqual([+ { id: 'synthetic-member-invitation-row', purpose: 'member_invitation' },+ ])+ expect(metrics.ordinary.operations.passwordRequests).toEqual([+ { id: 'synthetic-member-invitation-row', purpose: 'member_invitation' },+ ])+ expect(metrics.ordinary.operations.resetRequests).toEqual([])+ expect(metrics.ordinary.invitations).toContainEqual(+ expect.objectContaining({+ id: 'synthetic-member-invitation-row',+ purpose: 'member_invitation',+ status: 'accepted',+ userId: 'synthetic-member-onboarding-user',+ acceptedUserId: 'synthetic-member-onboarding-user',+ passwordPending: false,+ passwordMutationCount: 1,+ })+ )+})++test('accepted admin desktop invitation uses the token fallback without a prior session', async ({+ page,+}) => {+ // E2E_GUARDIAN_NAVIGATION: email-reset-entry — synthetic emailed invitation entry+ await page.goto('/invitations/synthetic-admin-invitation')++ await expect(page.getByText('[email protected]', { exact: true })).toBeVisible()+ await expect(page.getByText('Leader', { exact: true })).toBeVisible()+ await expect(+ page.getByText('Set your password to finish joining Evenfire.', { exact: true })+ ).toBeVisible()+ expect(await page.context().cookies()).toEqual([])++ await page.getByLabel('Password', { exact: true }).fill('Synthetic-Admin-Onboarding-123')+ await page.getByLabel('Confirm password').fill('Synthetic-Admin-Onboarding-123')+ const passwordResponsePromise = page.waitForResponse(+ response =>+ /\/api\/v1\/invitations\/password(?:-reset)?$/.test(response.url()) &&+ response.request().method() === 'POST'+ )+ await page.getByRole('button', { name: 'Set password and continue' }).click()+ const passwordResponse = await passwordResponsePromise+ expect(new URL(passwordResponse.url()).pathname).toBe(+ '/external-rest-api/api/v1/invitations/password'+ )+ expect(passwordResponse.status()).toBe(200)+ await expect(+ page.getByText('You are now registered with Evenfire.', { exact: true })+ ).toBeVisible()++ const identity = await page.evaluate(async () => {+ const response = await fetch('/external-rest-api/api/v1/me')+ return { status: response.status, body: await response.json() }+ })+ expect(identity).toMatchObject({+ status: 200,+ body: {+ id: 'synthetic-admin-onboarding-user',+ email: '[email protected]',+ role: 'admin',+ },+ })++ const metrics = await readMetrics(page)+ expect(metrics.ordinary.operations.acceptanceRequests).toContainEqual({+ id: 'synthetic-admin-invitation-row',+ purpose: 'admin_desktop_access',+ })+ expect(metrics.ordinary.operations.passwordRequests).toContainEqual({+ id: 'synthetic-admin-invitation-row',+ purpose: 'admin_desktop_access',+ })+ expect(metrics.ordinary.operations.resetRequests).toEqual([])+ expect(metrics.ordinary.invitations).toContainEqual(+ expect.objectContaining({+ id: 'synthetic-admin-invitation-row',+ purpose: 'admin_desktop_access',+ status: 'accepted',+ userId: 'synthetic-admin-onboarding-user',+ acceptedUserId: 'synthetic-admin-onboarding-user',+ passwordPending: false,+ passwordMutationCount: 1,+ })+ )+})++test('reset-only producer rejects an ordinary invitation without creating a session', async ({+ page,+}) => {+ const before = await readMetrics(page)+ const response = await page.request.post('/external-rest-api/api/v1/invitations/password-reset', {+ data: {+ token: 'synthetic-wrong-purpose-invitation',+ email: '[email protected]',+ invitationId: 'synthetic-wrong-purpose-invitation-row',+ password: 'Synthetic-Wrong-Purpose-123',+ },+ })++ expect(response.status()).toBe(409)+ expect(await response.json()).toMatchObject({ error: 'invitation_not_pending' })+ expect(response.headers()['set-cookie']).toBeUndefined()+ expect(await page.context().cookies()).toEqual([])++ const after = await readMetrics(page)+ expect(after.ordinary.operations.passwordRequests).toEqual(+ before.ordinary.operations.passwordRequests+ )+ expect(after.ordinary.invitations).toContainEqual(+ expect.objectContaining({+ id: 'synthetic-wrong-purpose-invitation-row',+ purpose: 'member_invitation',+ status: 'pending',+ acceptedUserId: null,+ passwordPending: true,+ passwordMutationCount: 0,+ })+ )+ expect(after.ordinary.operations.resetRequests).toContainEqual({+ id: 'synthetic-wrong-purpose-invitation-row',+ })+})diff --git a/tests/e2e/playwright/run-profile-ui-recovery.mjs b/tests/e2e/playwright/run-profile-ui-recovery.mjsindex a9e8af3cf..8bb4483b7 100644--- a/tests/e2e/playwright/run-profile-ui-recovery.mjs+++ b/tests/e2e/playwright/run-profile-ui-recovery.mjs@@ -22,6 +22,9 @@ if (listing.status !== 0) process.exit(listing.status || 1)if (!listingOutput.includes('reset-session-hydration.spec.ts')) {throw new Error('Profile UI recovery runner did not collect the recovery spec')}+if (!listingOutput.includes('ordinary-invitation-onboarding.spec.ts')) {+ throw new Error('Profile UI recovery runner did not collect ordinary invitation onboarding')+}if (!/Total:\s*[1-9]\d* tests?\b/.test(listingOutput)) {throw new Error('Profile UI recovery runner collected zero tests')}@@ -34,3 +37,14 @@ if (run.status !== 0) process.exit(run.status || 1)if (!/[1-9]\d* passed/.test(runOutput)) {throw new Error('Profile UI recovery runner did not report a passing test')}+for (const requiredSuite of [+ 'reset-session-hydration.spec.ts',+ 'ordinary-invitation-onboarding.spec.ts',+]) {+ if (!runOutput.includes(requiredSuite)) {+ throw new Error(`Profile UI recovery runner did not execute ${requiredSuite}`)+ }+}+if (/\b[1-9]\d* skipped\b/.test(runOutput)) {+ throw new Error('Profile UI recovery runner skipped a required test')+}