Skip to content

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

TypeScript
23.9 KB
Raw Blame
import { type Request, type RequestHandler, Router } from 'express'
import bcrypt from 'bcryptjs'
import { ipKeyGenerator } from 'express-rate-limit'
import { createHash } from 'node:crypto'
import { config } from '../../config.js'
import { pool } from '../../db.js'
import { type UiAuthedRequest, requireAuthForControlUI } from '../../middleware/controlUIAuth.js'
import { sendPasswordAdmissionError } from '../../middleware/passwordLoginAdmission.js'
import { rateLimitMiddleware } from '../../middleware/rateLimitMiddleware.js'
import { rootLogger } from '../../observability/logger.js'
import {
  completeControlAdminEmailChangeRequest,
  completeControlAdminInvitation,
  completeControlAdminPasswordResetRequest,
  createControlAdminPasswordResetRequest,
  findAdminById,
  findAdminByLogin,
  getPendingControlAdminEmailChangeRequest,
  getPendingControlAdminInvitation,
  getPendingControlAdminPasswordResetRequest,
  isValidAdminEmail,
  isValidAdminUsername,
  markControlAdminInvitationOpened,
  registerAdminFailedLogin,
  registerAdminSuccessfulLogin,
  revokeAdminTokenJti,
  revokeControlAdminPasswordResetRequest,
  setupInitialAdminCredentials,
} from '../../services/adminAuthService.js'
import {
  registerAndSendControlAdminPasswordReset,
  validateControlAdminEmailConfirmationToken,
  validateControlAdminInvitationToken,
  validateControlAdminPasswordResetToken,
} from '../../services/controlAdminInvitationRegistrationService.js'
import {
  acceptInvitationById,
  getPendingMemberInvitationForEmail,
  provisionAdminDesktopWorkspace,
  setInvitationPasswordForUser,
} from '../../services/directory/index.js'
import {
  type MemberPasswordWorkLease,
  withMemberPasswordWorkLease,
} from '../../services/directory/membership.js'
import { setupInitialAdminWithDesktopWorkspace } from '../../services/initialAdminSetupService.js'
import { memberRegistrationErrorResponse } from '../../services/memberRegistrationErrors.js'
import { signAdminToken } from '../../utils/auth/adminAuthToken.js'
import {
  CONTROL_UI_ADMIN_SESSION_COOKIE,
  clearHttpOnlySessionCookie,
  setHttpOnlySessionCookie,
} from '../../utils/auth/sessionCookies.js'

const ADMIN_PASSWORD_MIN_LENGTH = 8
const ADMIN_PASSWORD_MAX_LENGTH = 256

const logger = rootLogger.child({ module: 'admin-auth' })

function remoteAddressOf(req: Request): string {
  return req.ip || req.socket.remoteAddress || 'unknown'
}

/**
 * Two buckets per public token route, applied in this order:
 *
 * 1. Source IP + submitted value (email, login or token prefix), at
 *    `adminPublicTokenRlPerMin`: one person retrying the same value.
 * 2. Source IP alone (IPv6 grouped by /56), at `adminPublicTokenIpRlPerMin`:
 *    the ceiling on rotating values from one source, which the first bucket
 *    cannot see because every new value gets a fresh key.
 *
 * Many admins can share one public IP (a corporate VPN egress, an office
 * NAT), so the second ceiling is several times the first. A request the first
 * bucket refuses never reaches the second, so one person's retry loop costs
 * the shared IP at most `adminPublicTokenRlPerMin` per minute.
 */
function publicAdminTokenRateLimits(routeName: string): [RequestHandler, RequestHandler] {
  const perValue = rateLimitMiddleware({
    bucketType: `control_admin_public_${routeName}`,
    maxPerMinute: config.adminPublicTokenRlPerMin,
    getBucketKey: req => {
      const token = String(req.body?.token || '').trim()
      const email = String(req.body?.email || '')
        .trim()
        .toLowerCase()
      const login = String(req.body?.username || req.body?.login || '').trim()
      // The submitted value has no length bound before this point, and the key
      // is stored per window, so it enters the key as a fixed-size digest. The
      // digest also keeps emails out of the bucket table.
      const submitted = email || login || token.slice(0, 48) || 'missing'
      return `control-admin-public:${routeName}:${remoteAddressOf(req)}:${createHash('sha256').update(submitted).digest('hex')}`
    },
    onBackendUnavailable: 'process-memory',
  })
  const perIp = rateLimitMiddleware({
    bucketType: `control_admin_public_ip_${routeName}`,
    maxPerMinute: config.adminPublicTokenIpRlPerMin,
    getBucketKey: req =>
      `control-admin-public-ip:${routeName}:${ipKeyGenerator(remoteAddressOf(req))}`,
    onBackendUnavailable: 'process-memory',
  })
  return [perValue, perIp]
}

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

  router.post('/admin/auth/login', async (req, res, next) => {
    try {
      const username = String(req.body?.username || '').trim()
      const password = String(req.body?.password || '')
      if (!username || !password) {
        res.status(400).json({ error: 'username and password are required' })
        return
      }

      const user = await findAdminByLogin(username)
      if (!user || user.status !== 'active') {
        res.status(401).json({ error: 'Unauthorized' })
        return
      }
      if (user.lockedUntil && user.lockedUntil.getTime() > Date.now()) {
        res.status(423).json({ error: 'Account is temporarily locked' })
        return
      }

      const ok = await bcrypt.compare(password, user.passwordHash)
      if (!ok) {
        await registerAdminFailedLogin(
          user.id,
          config.adminAuthLockMinutes,
          config.adminAuthMaxFailures
        )
        res.status(401).json({ error: 'Unauthorized' })
        return
      }

      await registerAdminSuccessfulLogin(user.id)
      const token = signAdminToken(user.id, 'admin', user.sessionVersion)
      setHttpOnlySessionCookie(
        req,
        res,
        CONTROL_UI_ADMIN_SESSION_COOKIE,
        token,
        config.adminJwtTtlSeconds
      )
      res.status(200).json({
        me: {
          id: user.id,
          username: user.username,
          email: user.email,
          role: 'admin',
        },
      })
    } catch (error) {
      next(error)
    }
  })

  router.post('/admin/auth/setup', async (req, res, next) => {
    try {
      const username = String(req.body?.username || '').trim()
      const email = String(req.body?.email || '')
        .trim()
        .toLowerCase()
      const password = String(req.body?.password || '')
      if (!email || !username || !password) {
        res.status(400).json({ error: 'email, username and password are required' })
        return
      }
      if (!isValidAdminEmail(email)) {
        res.status(400).json({ error: 'email must be valid' })
        return
      }
      if (!isValidAdminUsername(username)) {
        res.status(400).json({
          error:
            'username must be 3-64 characters and use letters, numbers, dots, dashes or underscores',
        })
        return
      }
      if (
        password.length < ADMIN_PASSWORD_MIN_LENGTH ||
        password.length > ADMIN_PASSWORD_MAX_LENGTH
      ) {
        res.status(400).json({ error: 'password must be between 8 and 256 characters' })
        return
      }

      const passwordHash = await bcrypt.hash(password, 12)
      // Only a literal false opts out (fail-safe toward the human first-run
      // flow, where one credential for Control UI + desktop is the feature).
      // Managed installs send false: the desktop password then comes only
      // from the directory invitation email.
      const seedDesktopPassword = req.body?.seedDesktopPassword !== false
      let created
      if (config.desktopGfsOperatorLinkingEnabled) {
        try {
          created = await setupInitialAdminWithDesktopWorkspace({
            bootstrapUsername: config.adminBootstrapUsername,
            email,
            username,
            passwordHash,
            displayName: username,
            agentNames: config.adminDefaultAgentNames,
            contextIds: config.adminDefaultContextIds,
            seedPassword: seedDesktopPassword,
            linkDesktopOperator: true,
            requestId: req.correlationId ?? null,
          })
        } catch (err) {
          logger.error(
            { err, email, requestId: req.correlationId ?? null },
            'self-hosted initial admin setup rolled back; retry is required'
          )
          res.status(503).json({ error: 'Initial admin setup is incomplete; retry' })
          return
        }
      } else {
        created = await setupInitialAdminCredentials(
          config.adminBootstrapUsername,
          email,
          username,
          passwordHash
        )
      }
      if (!created) {
        res.status(409).json({ error: 'Initial admin setup is no longer available' })
        return
      }

      if (!config.desktopGfsOperatorLinkingEnabled) {
        try {
          await provisionAdminDesktopWorkspace({
            controlAdminId: created.id,
            email,
            displayName: username,
            passwordHash,
            agentNames: config.adminDefaultAgentNames,
            contextIds: config.adminDefaultContextIds,
            seedPassword: seedDesktopPassword,
            linkDesktopOperator: false,
            requestId: req.correlationId ?? null,
          })
        } catch (err) {
          // Managed/base installs retain the existing admin-first onboarding
          // contract because Desktop operator linking is explicitly disabled.
          logger.error(
            { err, email },
            'admin desktop workspace provisioning failed; control admin still created'
          )
        }
      }

      const token = signAdminToken(created.id, 'admin', created.sessionVersion)
      setHttpOnlySessionCookie(
        req,
        res,
        CONTROL_UI_ADMIN_SESSION_COOKIE,
        token,
        config.adminJwtTtlSeconds
      )
      res.status(200).json({
        me: {
          id: created.id,
          username: created.username,
          email: created.email,
          role: 'admin',
        },
      })
    } catch (error) {
      next(error)
    }
  })

  router.post(
    '/admin/auth/password-reset/request',
    ...publicAdminTokenRateLimits('password_reset_request'),
    async (req, res, next) => {
      try {
        const username = String(req.body?.username || '').trim()
        if (!username) {
          res.status(202).json({ requested: true })
          return
        }

        const reset = await createControlAdminPasswordResetRequest(username)
        if ('skipped' in reset) {
          res.status(202).json({ requested: true })
          return
        }

        try {
          await registerAndSendControlAdminPasswordReset(
            reset.email,
            reset.id,
            reset.createdAt.toISOString(),
            reset.expiresAt.toISOString()
          )
        } catch (sendError) {
          await revokeControlAdminPasswordResetRequest(reset.id)
          throw sendError
        }

        res.status(202).json({ requested: true })
      } catch (error) {
        next(error)
      }
    }
  )

  router.post(
    '/admin/auth/password-reset/validate',
    ...publicAdminTokenRateLimits('password_reset_validate'),
    async (req, res, next) => {
      try {
        const token = String(req.body?.token || '').trim()
        const email = String(req.body?.email || '')
          .trim()
          .toLowerCase()
        if (!token) {
          res.status(400).json({ error: 'token is required' })
          return
        }

        const validation = await validateControlAdminPasswordResetToken(token, email || undefined)
        const reset = await getPendingControlAdminPasswordResetRequest(
          pool,
          validation.resetUuid,
          validation.email
        )
        if (!reset) {
          res.status(404).json({ error: 'invalid_password_reset' })
          return
        }

        res.status(200).json({
          valid: true,
          email: validation.email,
          resetUuid: validation.resetUuid,
        })
      } catch (error) {
        if (memberRegistrationErrorResponse(error)) return next(error)
        res.status(400).json({ error: 'invalid_password_reset' })
      }
    }
  )

  router.post(
    '/admin/auth/password-reset/complete',
    ...publicAdminTokenRateLimits('password_reset_complete'),
    async (req, res, next) => {
      try {
        const token = String(req.body?.token || '').trim()
        const email = String(req.body?.email || '')
          .trim()
          .toLowerCase()
        const password = String(req.body?.password || '')
        if (!token || !email || !password) {
          res.status(400).json({ error: 'token, email and password are required' })
          return
        }
        if (!isValidAdminEmail(email)) {
          res.status(400).json({ error: 'email must be valid' })
          return
        }
        if (
          password.length < ADMIN_PASSWORD_MIN_LENGTH ||
          password.length > ADMIN_PASSWORD_MAX_LENGTH
        ) {
          res.status(400).json({ error: 'password must be between 8 and 256 characters' })
          return
        }

        let validation: { email: string; resetUuid: string }
        try {
          validation = await validateControlAdminPasswordResetToken(token, email)
        } catch (error) {
          if (memberRegistrationErrorResponse(error)) throw error
          res.status(400).json({ error: 'invalid_password_reset' })
          return
        }
        const passwordHash = await bcrypt.hash(password, 12)
        const result = await completeControlAdminPasswordResetRequest({
          requestId: validation.resetUuid,
          email: validation.email,
          passwordHash,
        })
        if ('error' in result) {
          res.status(404).json({ error: 'invalid_password_reset' })
          return
        }

        res.status(200).json({
          completed: true,
          login: {
            username: result.email || result.username,
          },
        })
      } catch (error) {
        next(error)
      }
    }
  )

  router.post(
    '/admin/auth/control-admin-invitations/validate',
    ...publicAdminTokenRateLimits('invitation_validate'),
    async (req, res, next) => {
      try {
        const token = String(req.body?.token || '').trim()
        const email = String(req.body?.email || '')
          .trim()
          .toLowerCase()
        if (!token) {
          res.status(400).json({ error: 'token is required' })
          return
        }

        const validation = await validateControlAdminInvitationToken(token, email || undefined)
        const invitation = await getPendingControlAdminInvitation(
          pool,
          validation.invitationUuid,
          validation.email
        )
        if (!invitation) {
          res.status(404).json({ error: 'invalid_invitation' })
          return
        }
        await markControlAdminInvitationOpened(invitation.id)
        const desktopAccess = await getPendingMemberInvitationForEmail(validation.email)
        res.status(200).json({
          valid: true,
          email: validation.email,
          invitationUuid: validation.invitationUuid,
          desktopAccess,
        })
      } catch (error) {
        if (memberRegistrationErrorResponse(error)) return next(error)
        res.status(400).json({ error: 'invalid_invitation' })
      }
    }
  )

  router.post(
    '/admin/auth/control-admin-invitations/complete',
    ...publicAdminTokenRateLimits('invitation_complete'),
    async (req, res, next) => {
      try {
        const token = String(req.body?.token || '').trim()
        const email = String(req.body?.email || '')
          .trim()
          .toLowerCase()
        const username = String(req.body?.username || '').trim()
        const password = String(req.body?.password || '')
        const useSameMemberPassword = req.body?.useSameMemberPassword !== false
        const memberPassword = useSameMemberPassword
          ? password
          : String(req.body?.memberPassword || '')
        if (!token || !email || !username || !password) {
          res.status(400).json({ error: 'token, email, username and password are required' })
          return
        }
        if (!isValidAdminEmail(email)) {
          res.status(400).json({ error: 'email must be valid' })
          return
        }
        if (!isValidAdminUsername(username)) {
          res.status(400).json({
            error:
              'username must be 3-64 characters and use letters, numbers, dots, dashes or underscores',
          })
          return
        }
        if (
          password.length < ADMIN_PASSWORD_MIN_LENGTH ||
          password.length > ADMIN_PASSWORD_MAX_LENGTH
        ) {
          res.status(400).json({ error: 'password must be between 8 and 256 characters' })
          return
        }
        const desktopAccess = await getPendingMemberInvitationForEmail(email)
        if (desktopAccess && (memberPassword.length < 8 || memberPassword.length > 256)) {
          res.status(400).json({ error: 'member password must be between 8 and 256 characters' })
          return
        }

        const validation = await validateControlAdminInvitationToken(token, email)
        const passwordHash = await bcrypt.hash(password, 12)
        const completeInvitation = async (passwordWorkLease?: MemberPasswordWorkLease) => {
          const result = await completeControlAdminInvitation({
            email: validation.email,
            invitationId: validation.invitationUuid,
            username,
            passwordHash,
          })
          if ('error' in result) {
            return {
              status: result.error === 'not_found' ? 404 : 409,
              body: { error: result.error },
            }
          }

          const acceptedDesktopAccess = desktopAccess
            ? await acceptInvitationById(validation.email, desktopAccess.id)
            : null
          if (acceptedDesktopAccess && 'error' in acceptedDesktopAccess) {
            // The control-admin invitation is already committed. A failed desktop
            // acceptance leaves that admin in place and, for a hand-over, the
            // inviter already retired. Record the code without the invitee email.
            rootLogger.error(
              {
                event: 'control_admin_desktop_acceptance_failed',
                invitationId: validation.invitationUuid,
                adminId: result.id,
                errorCode: acceptedDesktopAccess.error,
              },
              'desktop invitation acceptance failed after the control admin invitation committed'
            )
            return { status: 409, body: { error: acceptedDesktopAccess.error } }
          }
          if (acceptedDesktopAccess?.data?.userId && desktopAccess) {
            const passwordResult = await setInvitationPasswordForUser(
              acceptedDesktopAccess.data.userId,
              validation.email,
              desktopAccess.id,
              memberPassword,
              passwordWorkLease
            )
            if ('error' in passwordResult) {
              return { status: 409, body: { error: passwordResult.error } }
            }
          }

          return {
            status: 200,
            body: {
              completed: true,
              desktopAccessCompleted: Boolean(
                acceptedDesktopAccess && !('error' in acceptedDesktopAccess)
              ),
              login: {
                username: result.email || result.username,
              },
            },
          }
        }
        const completion = desktopAccess
          ? await withMemberPasswordWorkLease(lease => completeInvitation(lease))
          : await completeInvitation()
        res.status(completion.status).json(completion.body)
      } catch (error) {
        if (sendPasswordAdmissionError(error, res)) return
        next(error)
      }
    }
  )

  router.post(
    '/admin/auth/control-admin-email-confirmations/validate',
    ...publicAdminTokenRateLimits('email_confirmation_validate'),
    async (req, res, next) => {
      try {
        const token = String(req.body?.token || '').trim()
        const email = String(req.body?.email || '')
          .trim()
          .toLowerCase()
        if (!token) {
          res.status(400).json({ error: 'token is required' })
          return
        }

        const validation = await validateControlAdminEmailConfirmationToken(
          token,
          email || undefined
        )
        const confirmation = await getPendingControlAdminEmailChangeRequest(
          pool,
          validation.confirmationUuid,
          validation.email
        )
        if (!confirmation) {
          res.status(404).json({ error: 'invalid_confirmation' })
          return
        }

        res.status(200).json({
          valid: true,
          email: validation.email,
          confirmationUuid: validation.confirmationUuid,
        })
      } catch (error) {
        if (memberRegistrationErrorResponse(error)) return next(error)
        res.status(400).json({ error: 'invalid_confirmation' })
      }
    }
  )

  router.post(
    '/admin/auth/control-admin-email-confirmations/complete',
    ...publicAdminTokenRateLimits('email_confirmation_complete'),
    async (req, res, next) => {
      try {
        const token = String(req.body?.token || '').trim()
        const email = String(req.body?.email || '')
          .trim()
          .toLowerCase()
        if (!token) {
          res.status(400).json({ error: 'token is required' })
          return
        }
        if (email && !isValidAdminEmail(email)) {
          res.status(400).json({ error: 'email must be valid' })
          return
        }

        let validation: { email: string; confirmationUuid: string }
        try {
          validation = await validateControlAdminEmailConfirmationToken(token, email || undefined)
        } catch (error) {
          if (memberRegistrationErrorResponse(error)) throw error
          res.status(400).json({ error: 'invalid_confirmation' })
          return
        }
        const result = await completeControlAdminEmailChangeRequest({
          requestId: validation.confirmationUuid,
          email: validation.email,
        })
        if ('alreadyConfirmed' in result) {
          res.status(200).json({
            completed: true,
            alreadyConfirmed: true,
            login: {
              username: result.admin.email || result.admin.username,
            },
          })
          return
        }
        if ('error' in result) {
          const status = result.error === 'not_found' ? 404 : 409
          res.status(status).json({ error: result.error })
          return
        }

        res.status(200).json({
          completed: true,
          alreadyConfirmed: false,
          login: {
            username: result.email || result.username,
          },
        })
      } catch (error) {
        next(error)
      }
    }
  )

  router.get('/admin/auth/me', requireAuthForControlUI, async (req: UiAuthedRequest, res, next) => {
    try {
      const adminId = req.adminAuth?.sub
      const admin = adminId ? await findAdminById(adminId) : null
      if (!admin) {
        res.status(401).json({ error: 'Unauthorized' })
        return
      }

      res.status(200).json({
        me: {
          id: admin.id,
          username: admin.username,
          email: admin.email,
          role: admin.role,
        },
        // The recipe-secret namespaces this control-api enforces (see
        // WORKFLOW_RECIPE_SECRET_NAMESPACES in the recipes route). In a managed
        // per-tenant deployment these are suffixed (sandbox-recipes-<slug> /
        // mcp-server-<slug>); control-ui needs them to write recipe-secret VALUES
        // to the correct namespace at CREATE time (the recipe namespace does not
        // exist yet). Same source of truth as the POST /admin/recipes/secrets
        // validator, so the UI and validator can never disagree.
        namespaces: {
          sandbox: config.sandboxNamespace,
          mcpServer: config.mcpServersNamespace,
        },
      })
    } catch (error) {
      next(error)
    }
  })

  router.post(
    '/admin/auth/logout',
    requireAuthForControlUI,
    async (req: UiAuthedRequest, res, next) => {
      try {
        const claims = req.adminAuth!
        await revokeAdminTokenJti(claims.jti, claims.exp)
        clearHttpOnlySessionCookie(req, res, CONTROL_UI_ADMIN_SESSION_COOKIE)
        res.status(200).json({ ok: true })
      } catch (error) {
        next(error)
      }
    }
  )

  return router
}