Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
12.1 KB
Raw Blame
import { type Request, Router } from 'express'
import { randomBytes } from 'node:crypto'
import { config } from '../../config.js'
import {
  createExternalClientRateLimiters,
  externalClientIpRateLimitKey,
} from '../../middleware/externalClientIdentity.js'
import {
  type ExternalAuthedRequest,
  rejectBodyUserTeamMismatch,
  requireValidExternalSessionToken,
} from '../../middleware/externalSessionAuth.js'
import { sendPasswordAdmissionError } from '../../middleware/passwordLoginAdmission.js'
import { rateLimitMiddleware } from '../../middleware/rateLimitMiddleware.js'
import {
  acceptInvitationForEmail,
  getInvitationByToken,
  listPendingInvitations,
  setInvitationPasswordForEmail,
  setInvitationPasswordForUser,
  verifyUserPassword,
} from '../../services/directory/index.js'
import {
  storeDesktopAuthorizationToken,
  validateInvitationFlowToken,
} from '../../services/invitationFlowRegistrationService.js'
import { memberRegistrationErrorResponse } from '../../services/memberRegistrationErrors.js'
import { signExternalSessionToken } from '../../utils/auth/externalSessionAuthToken.js'

function invitationAdmissionKey(req: Request, operation: 'preview' | 'password-token'): string {
  return `invite-token:${operation}:${externalClientIpRateLimitKey(req)}`
}

export function createExternalInvitationsRouter(): Router {
  const router = Router()
  const externalInvitationsEdgeRateLimits = createExternalClientRateLimiters(
    'invitations',
    config.approvalRlExternalClientIpPerMin,
    config.approvalRlExternalEdgePerMin
  )
  router.get(
    '/external/invitations/token/:token',
    ...externalInvitationsEdgeRateLimits,
    rateLimitMiddleware({
      bucketType: 'external_invitation_lookup',
      maxPerMinute: 30,
      getBucketKey: req => invitationAdmissionKey(req, 'preview'),
      onBackendUnavailable: 'process-memory',
    }),
    async (req, res, next) => {
      try {
        const token = String(req.params.token || '').trim()
        if (!token) {
          return res.status(400).json({ error: 'token is required' })
        }

        let validation: { email: string; invitationUuid: string }
        try {
          validation = await validateInvitationFlowToken(token)
        } catch (error) {
          if (memberRegistrationErrorResponse(error)) throw error
          return res.status(400).json({ error: 'invalid_invitation' })
        }
        const invitation = await getInvitationByToken(validation.invitationUuid)
        if (!invitation) {
          return res.status(404).json({ error: 'not_found' })
        }
        return res.status(200).json(invitation)
      } catch (error) {
        return next(error)
      }
    }
  )

  router.post(
    '/external/invitations/password-token',
    ...externalInvitationsEdgeRateLimits,
    rateLimitMiddleware({
      bucketType: 'external_invitation_password_token',
      maxPerMinute: 10,
      getBucketKey: req => invitationAdmissionKey(req, 'password-token'),
      onBackendUnavailable: 'process-memory',
    }),
    async (req, res, next) => {
      try {
        const email = String(req.body?.email || '')
          .trim()
          .toLowerCase()
        const token = String(req.body?.token || '').trim()
        const invitationId = String(req.body?.invitationId || '').trim()
        const password = String(req.body?.password || '')
        if (!email || !token || !invitationId) {
          return res.status(400).json({ error: 'invalid payload' })
        }
        if (!password) {
          return res.status(400).json({ error: 'invalid_password' })
        }

        let validation: { email: string; invitationUuid: string }
        try {
          validation = await validateInvitationFlowToken(token, email)
        } catch (error) {
          if (memberRegistrationErrorResponse(error)) throw error
          return res.status(400).json({ error: 'invalid_invitation' })
        }
        // The trusted Member Registration flow binds invitationUuid to the
        // invitation token. The UI submits the distinct database row ID.
        // Resolve the trusted token first, then bind the supplied row ID to
        // that exact invitation before mutating credentials.
        const invitation = await getInvitationByToken(validation.invitationUuid)
        if (!invitation || invitation.id !== invitationId) {
          return res.status(403).json({ error: 'forbidden' })
        }
        if (
          invitation.email.toLowerCase() !== validation.email.toLowerCase() ||
          invitation.purpose !== 'password_reset' ||
          invitation.status !== 'pending'
        ) {
          return res.status(409).json({ error: 'invitation_not_pending' })
        }

        const result = await setInvitationPasswordForEmail(
          validation.email,
          invitation.id,
          password
        )
        if ('error' in result) {
          if (result.error === 'not_found') {
            return res.status(404).json({ error: 'not_found' })
          }
          if (result.error === 'forbidden') {
            return res.status(403).json({ error: 'forbidden' })
          }
          if (result.error === 'not_pending') {
            return res.status(409).json({ error: 'invitation_not_pending' })
          }
          if (result.error === 'expired') {
            return res.status(410).json({ error: 'expired' })
          }
          if (result.error === 'user_retired') {
            return res.status(401).json({ error: 'user_retired' })
          }
          return res.status(400).json({ error: 'invalid_password' })
        }

        const userId = result.data.userId
        if (!userId) {
          return res.status(409).json({ error: 'invitation_not_ready' })
        }
        const session = result.data.sessionContext
        if (
          !session ||
          session.userId !== userId ||
          !Number.isSafeInteger(session.authGeneration) ||
          session.authGeneration < 1
        ) {
          return res.status(409).json({ error: 'invitation_not_ready' })
        }

        const sessionToken = signExternalSessionToken(session)
        const { sessionContext: _sessionContext, ...response } = result.data

        return res.status(200).json({
          ...response,
          token: sessionToken,
        })
      } catch (error) {
        if (sendPasswordAdmissionError(error, res)) return
        return next(error)
      }
    }
  )

  router.post(
    '/external/invitations/password',
    ...externalInvitationsEdgeRateLimits,
    requireValidExternalSessionToken,
    rejectBodyUserTeamMismatch,
    async (req, res, next) => {
      try {
        const userId = String(req.body?.userId || '').trim()
        const email = String(req.body?.email || '')
          .trim()
          .toLowerCase()
        const invitationId = String(req.body?.invitationId || '').trim()
        const password = String(req.body?.password || '')
        if (!userId || !email || !invitationId) {
          return res.status(400).json({ error: 'invalid payload' })
        }

        const result = await setInvitationPasswordForUser(userId, email, invitationId, password)
        if ('error' in result) {
          if (result.error === 'not_found') {
            return res.status(404).json({ error: 'not_found' })
          }
          if (result.error === 'forbidden') {
            return res.status(403).json({ error: 'forbidden' })
          }
          if (result.error === 'not_accepted') {
            return res.status(409).json({ error: 'invitation_not_accepted' })
          }
          if (result.error === 'not_pending') {
            return res.status(409).json({ error: 'invitation_not_pending' })
          }
          if (result.error === 'expired') {
            return res.status(410).json({ error: 'expired' })
          }
          if (result.error === 'user_retired') {
            return res.status(401).json({ error: 'user_retired' })
          }
          return res.status(400).json({ error: 'invalid_password' })
        }
        return res.status(200).json(result.data)
      } catch (error) {
        if (sendPasswordAdmissionError(error, res)) return
        return next(error)
      }
    }
  )

  router.post(
    '/external/invitations/desktop-authorization',
    ...externalInvitationsEdgeRateLimits,
    requireValidExternalSessionToken,
    rejectBodyUserTeamMismatch,
    async (req, res, next) => {
      try {
        const userId = String(req.body?.userId || '').trim()
        const email = String(req.body?.email || '')
          .trim()
          .toLowerCase()
        const password = String(req.body?.password || '')
        if (!userId || !email || !password) {
          return res.status(400).json({ error: 'invalid payload' })
        }

        const passwordValid = await verifyUserPassword({ userId, email, password })
        if (!passwordValid) {
          return res.status(401).json({ error: 'invalid_password' })
        }

        const authorizationToken = randomBytes(24).toString('base64url')
        try {
          await storeDesktopAuthorizationToken(email, authorizationToken)
        } catch (error) {
          if (memberRegistrationErrorResponse(error)) throw error
          const message = error instanceof Error ? error.message : ''
          if (message.includes('(404)')) {
            return res.status(404).json({ error: 'not_found' })
          }
          throw error
        }
        return res.status(200).json({
          authorizationToken,
          expiresInSeconds: 120,
        })
      } catch (error) {
        if (sendPasswordAdmissionError(error, res)) return
        return next(error)
      }
    }
  )

  router.get(
    '/external/invitations/pending',
    ...externalInvitationsEdgeRateLimits,
    requireValidExternalSessionToken,
    async (req, res, next) => {
      try {
        const email = String(req.query.email || '')
          .trim()
          .toLowerCase()
        if (!email) return res.status(400).json({ error: 'email is required' })
        return res.status(200).json({ items: await listPendingInvitations(email) })
      } catch (error) {
        return next(error)
      }
    }
  )

  router.post(
    '/external/invitations/accept',
    ...externalInvitationsEdgeRateLimits,
    async (req: ExternalAuthedRequest, res, next) => {
      try {
        const email = String(req.body?.email || '')
          .trim()
          .toLowerCase()
        const token = String(req.body?.token || '').trim()
        if (!email || !token) return res.status(400).json({ error: 'invalid payload' })

        let validation: { email: string; invitationUuid: string }
        try {
          validation = await validateInvitationFlowToken(token, email)
        } catch (error) {
          if (memberRegistrationErrorResponse(error)) throw error
          return res.status(400).json({ error: 'invalid_invitation' })
        }
        const result = await acceptInvitationForEmail(validation.email, validation.invitationUuid)
        if ('error' in result) {
          if (result.error === 'not_found') {
            return res.status(404).json({ error: 'not_found' })
          }
          if (result.error === 'forbidden') {
            return res.status(403).json({ error: 'forbidden' })
          }
          if (result.error === 'expired') {
            return res.status(410).json({ error: 'expired' })
          }
          if (result.error === 'user_retired') {
            return res.status(401).json({ error: 'Unauthorized' })
          }
          return res.status(400).json({ error: 'not_pending' })
        }

        const authGeneration = Number(result.data.authGeneration)
        if (
          result.data.lifecycleState !== 'active' ||
          !Number.isSafeInteger(authGeneration) ||
          authGeneration < 1
        ) {
          return res.status(409).json({ error: 'invitation_not_ready' })
        }
        const sessionToken = signExternalSessionToken({
          userId: result.data.userId,
          email: result.data.email,
          teamId: result.data.teamId || null,
          role: result.data.role,
          authGeneration,
        })

        return res.status(200).json({
          ...result.data,
          token: sessionToken,
        })
      } catch (error) {
        return next(error)
      }
    }
  )

  return router
}