Skip to content

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/Makefile
index 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-recovery
test-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-headed
diff --git a/control-api/package-lock.json b/control-api/package-lock.json
index 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.json
index 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.ts
index 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: ExternalRestHttpProcess
let bcrypt: typeof import('bcryptjs').default
let 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')).default
db = 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.tsx
index 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',
+ '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',
+ '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.tsx
index 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.ts
index 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.json
index 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.json
index 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.json
index 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.json
index 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.mjs
index 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 = 0
let authenticatedMeReads = 0
let passwordChanged = false
let contractResetPosts = 0
let externalRestBaseUrl
+let sessionPrivateKey
+let sessionPublicKey
function 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 += 1
if (
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 = publicKey
const 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.ts
new file mode 100644
index 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.mjs
index 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')
+}