Skip to content

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

TypeScript
11.5 KB
Raw Blame
import { NextFunction, Request, Response, Router } from 'express'
import { verifyToken } from '../authToken.js'
import { ControlApiError } from '../controlApiClient.js'
import { sendPasswordAuthorityError } from '../http/passwordAdmissionError.js'
import { type AuthedRequest, extractAuthToken, requireAuth } from '../middleware/auth.js'
import { createRateLimiter } from '../middleware/rateLimit.js'
import {
  setupInvitationPassword,
  setupInvitationPasswordWithToken,
} from '../services/invitationPasswordService.js'
import {
  acceptInvitation,
  createDesktopAuthorization,
  getInvitationByToken,
  listPendingInvitations,
} from '../services/invitationsService.js'
import { setProfileSessionCookie } from '../sessionCookie.js'

const tokenLookupRateLimit = createRateLimiter({ windowMs: 60_000, maxRequests: 30 })
const acceptRateLimit = createRateLimiter({ windowMs: 60_000, maxRequests: 10 })

type InvitationPasswordAuth = {
  userId: string
  email: string
  sessionToken: string
}

function sendAcceptInvitationError(
  res: Response,
  error: 'not_found' | 'forbidden' | 'not_pending' | 'expired' | 'invalid'
): void {
  if (error === 'invalid') {
    res.status(400).json({ error: 'Invalid invitation' })
    return
  }
  if (error === 'not_found') {
    res.status(404).json({ error: 'Invitation not found' })
    return
  }
  if (error === 'forbidden') {
    res.status(403).json({ error: 'Invitation email does not match authenticated user' })
    return
  }
  if (error === 'expired') {
    res.status(410).json({ error: 'Invitation has expired' })
    return
  }
  res.status(400).json({ error: 'Invitation is not pending' })
}

function sendInvitationPasswordError(
  res: Response,
  error:
    | 'not_found'
    | 'forbidden'
    | 'not_accepted'
    | 'not_pending'
    | 'expired'
    | 'invalid_invitation'
    | 'invalid_password'
): void {
  if (error === 'invalid_invitation') {
    res.status(400).json({ error: 'invalid_invitation' })
    return
  }
  if (error === 'not_found') {
    res.status(404).json({ error: 'Invitation not found' })
    return
  }
  if (error === 'forbidden') {
    res.status(403).json({ error: 'Invitation is invalid or unavailable' })
    return
  }
  if (error === 'not_accepted') {
    res.status(409).json({ error: 'Invitation must be accepted before setting a password' })
    return
  }
  if (error === 'not_pending') {
    res.status(409).json({ error: 'Invitation has already been used' })
    return
  }
  if (error === 'expired') {
    res.status(410).json({ error: 'Invitation has expired' })
    return
  }
  res.status(400).json({ error: 'Password must be between 8 and 256 characters' })
}

function sendPasswordResetError(
  res: Response,
  error:
    | 'not_found'
    | 'forbidden'
    | 'not_accepted'
    | 'not_pending'
    | 'expired'
    | 'invalid_invitation'
    | 'invalid_password'
): void {
  const response = {
    not_found: { status: 404, code: 'not_found', message: 'Invitation not found' },
    forbidden: {
      status: 403,
      code: 'forbidden',
      message: 'Invitation is invalid or unavailable',
    },
    not_accepted: {
      status: 409,
      code: 'invitation_not_accepted',
      message: 'Invitation must be accepted before setting a password',
    },
    not_pending: {
      status: 409,
      code: 'invitation_not_pending',
      message: 'Invitation has already been used',
    },
    expired: { status: 410, code: 'expired', message: 'Invitation has expired' },
    invalid_invitation: {
      status: 400,
      code: 'invalid_invitation',
      message: 'This recovery link is invalid or expired',
    },
    invalid_password: {
      status: 400,
      code: 'invalid_password',
      message: 'Password must be between 8 and 256 characters',
    },
  }[error]
  res.status(response.status).json({ error: response.code, message: response.message })
}

async function invitationPasswordAuthFromRequest(req: Request): Promise<
  | { auth: InvitationPasswordAuth }
  | {
      status: number
      body: Record<string, string>
    }
> {
  const sessionToken = extractAuthToken(req)
  if (sessionToken) {
    const claims = verifyToken(sessionToken)
    if (claims) {
      return { auth: { userId: claims.userId, email: claims.email, sessionToken } }
    }
  }

  const token = String(req.body?.token || '').trim()
  const email = String(req.body?.email || '')
    .trim()
    .toLowerCase()
  if (!token || !email) {
    return { status: 401, body: { error: 'Unauthorized' } }
  }

  const accepted = await acceptInvitation(token, email)
  if (accepted.error) {
    const response = {
      invalid: { status: 400, body: { error: 'Invalid invitation' } },
      not_found: { status: 404, body: { error: 'Invitation not found' } },
      forbidden: {
        status: 403,
        body: { error: 'Invitation email does not match authenticated user' },
      },
      expired: { status: 410, body: { error: 'Invitation has expired' } },
      not_pending: { status: 400, body: { error: 'Invitation is not pending' } },
    }[accepted.error]
    return response ?? { status: 502, body: { error: 'Failed to start invited session' } }
  }
  if (!accepted.data?.token || !accepted.data.userId) {
    return { status: 502, body: { error: 'Failed to start invited session' } }
  }

  return {
    auth: {
      userId: accepted.data.userId,
      email: accepted.data.email,
      sessionToken: accepted.data.token,
    },
  }
}

function isInvalidInvitationProof(error: unknown): boolean {
  return (
    error instanceof ControlApiError && error.status === 400 && error.code === 'invalid_invitation'
  )
}

async function completePasswordReset(
  req: Request,
  res: Response,
  token: string,
  email: string,
  invitationId: string,
  password: string,
  sendError: typeof sendInvitationPasswordError = sendInvitationPasswordError
): Promise<void> {
  const result = await setupInvitationPasswordWithToken(token, email, invitationId, password)
  if (result.error) {
    sendError(res, result.error)
    return
  }
  const sessionToken = result.data?.token
  if (!result.data || !sessionToken) {
    res.status(502).json({ error: 'Failed to restore account session' })
    return
  }
  const { token: _sessionToken, ...body } = result.data
  setProfileSessionCookie(req, res, sessionToken)
  res.status(200).json(body)
}

export function createInvitationsRouter(): Router {
  const router = Router()

  router.get('/invitations/token/:token', tokenLookupRateLimit, async (req, res, next) => {
    try {
      const token = String(req.params.token || '').trim()
      if (!token) {
        res.status(400).json({ error: 'token is required' })
        return
      }

      let invitation: Awaited<ReturnType<typeof getInvitationByToken>>
      try {
        invitation = await getInvitationByToken(token)
      } catch (error) {
        if (isInvalidInvitationProof(error)) {
          res.status(400).json({ error: 'invalid_invitation' })
          return
        }
        throw error
      }
      if (!invitation) {
        res.status(404).json({ error: 'Invitation not found' })
        return
      }
      res.status(200).json(invitation)
    } catch (error) {
      next(error)
    }
  })

  router.post('/invitations/password', acceptRateLimit, async (req: AuthedRequest, res, next) => {
    try {
      const invitationId = String(req.body?.invitationId || '').trim()
      const password = String(req.body?.password || '')
      if (!invitationId) {
        res.status(400).json({ error: 'invitationId is required' })
        return
      }

      const token = String(req.body?.token || '').trim()
      const email = String(req.body?.email || '')
        .trim()
        .toLowerCase()
      if (token && email) {
        let preview: Awaited<ReturnType<typeof getInvitationByToken>>
        try {
          preview = await getInvitationByToken(token)
        } catch (error) {
          if (isInvalidInvitationProof(error)) {
            res.status(400).json({ error: 'invalid_invitation' })
            return
          }
          throw error
        }
        if (preview?.purpose === 'password_reset') {
          await completePasswordReset(req, res, token, email, invitationId, password)
          return
        }
      }

      const authResult = await invitationPasswordAuthFromRequest(req)
      if ('status' in authResult) {
        res.status(authResult.status).json(authResult.body)
        return
      }

      const result = await setupInvitationPassword(authResult.auth, invitationId, password)
      if (result.error) {
        sendInvitationPasswordError(res, result.error)
        return
      }
      setProfileSessionCookie(req, res, authResult.auth.sessionToken)
      res.status(200).json(result.data)
    } catch (error) {
      if (sendPasswordAuthorityError(error, res)) return
      next(error)
    }
  })

  router.post('/invitations/password-reset', acceptRateLimit, async (req: Request, res, next) => {
    try {
      const invitationId = String(req.body?.invitationId || '').trim()
      if (!invitationId) {
        res.status(400).json({ error: 'invitationId is required' })
        return
      }
      const token = String(req.body?.token || '').trim()
      const email = String(req.body?.email || '')
        .trim()
        .toLowerCase()
      if (!token || !email) {
        res.status(401).json({ error: 'Unauthorized' })
        return
      }
      const password = String(req.body?.password || '')
      await completePasswordReset(
        req,
        res,
        token,
        email,
        invitationId,
        password,
        sendPasswordResetError
      )
    } catch (error) {
      if (sendPasswordAuthorityError(error, res)) return
      next(error)
    }
  })

  router.post(
    '/invitations/desktop-authorization',
    requireAuth,
    async (req: AuthedRequest, res, next) => {
      try {
        const auth = req.auth!
        const sessionToken = extractAuthToken(req)
        const password = String(req.body?.password || '')
        if (!password) {
          res.status(400).json({ error: 'password is required' })
          return
        }

        const result = await createDesktopAuthorization({ ...auth, sessionToken }, password)
        if (result.error === 'not_found') {
          res.status(404).json({ error: 'Invitation setup not found' })
          return
        }
        if (result.error === 'invalid_password') {
          res.status(401).json({ error: 'Invalid password' })
          return
        }
        res.status(200).json(result.data)
      } catch (error) {
        if (sendPasswordAuthorityError(error, res)) return
        next(error)
      }
    }
  )

  router.get('/invitations/pending', requireAuth, async (req: AuthedRequest, res, next) => {
    try {
      const auth = req.auth!
      const sessionToken = extractAuthToken(req)
      res.status(200).json({ items: await listPendingInvitations(auth.email, sessionToken) })
    } catch (error) {
      next(error)
    }
  })

  router.post('/invitations/accept', acceptRateLimit, async (req: AuthedRequest, res, next) => {
    try {
      const token = String(req.body?.token || '').trim()
      const email = String(req.body?.email || '')
        .trim()
        .toLowerCase()
      if (!token || !email) {
        res.status(400).json({ error: 'token and email are required' })
        return
      }

      const result = await acceptInvitation(token, email)
      if (result.error) {
        sendAcceptInvitationError(res, result.error)
        return
      }
      setProfileSessionCookie(req, res, result.data!.token)
      const { token: _token, ...data } = result.data!
      res.status(200).json(data)
    } catch (error) {
      next(error)
    }
  })

  return router
}