Skip to content

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

TypeScript
9.4 KB
Raw Blame
import bcrypt from 'bcryptjs'
import { type DbClient, pool } from '../../db.js'
import { type MemberPasswordWorkLease, runPasswordMutation } from '../auth/passwordWorkOwnership.js'
import {
  type InvitationUserRow,
  ensureInvitationUser,
  getInvitationRecordById,
  invitationResponse,
  invitationUserIsRetired,
  loadInvitationTeams,
  lockPasswordResetUser,
} from './invitationStore.js'
import { getMemberSessionContext } from './login.js'

async function updateActivePasswordHash(
  db: Pick<DbClient, 'query'>,
  userId: string,
  passwordHash: string
): Promise<boolean> {
  const update = await db.query(
    `UPDATE users
        SET password_hash = $2,
            password_set_at = NOW(),
            updated_at = NOW()
      WHERE id = $1
        AND lifecycle_state = 'active'
      RETURNING id`,
    [userId, passwordHash]
  )
  return update.rows.length === 1
}

async function loadInvitationPasswordResponse(
  db: Pick<DbClient, 'query'>,
  invitationId: string,
  user: InvitationUserRow,
  passwordHash: string
) {
  const invitation = await getInvitationRecordById(db, invitationId)
  if (!invitation) return null
  const teams = await loadInvitationTeams(db, invitation.id, invitation)
  return invitationResponse(invitation, { ...user, password_hash: passwordHash }, teams)
}

async function revokeSiblingPasswordResets(
  db: Pick<DbClient, 'query'>,
  email: string,
  redeemedInvitationId: string,
  userId: string
): Promise<void> {
  await db.query(
    `UPDATE invitations
        SET status = 'revoked'
      WHERE lower(email) = $1
        AND purpose = 'password_reset'
        AND status IN ('draft', 'pending')
        AND id <> $2::uuid
        AND (accepted_user_id IS NULL OR accepted_user_id = $3)`,
    [email, redeemedInvitationId, userId]
  )
}

export async function setInvitationPasswordForUser(
  userId: string,
  email: string,
  invitationId: string,
  password: string,
  passwordWorkLease?: MemberPasswordWorkLease
) {
  const trimmedUserId = userId.trim()
  const normalizedEmail = email.trim().toLowerCase()
  const trimmedInvitationId = invitationId.trim()
  const trimmedPassword = password.trim()
  if (!trimmedUserId || !normalizedEmail || !trimmedInvitationId) {
    return { error: 'not_found' as const }
  }
  if (trimmedPassword.length < 8 || trimmedPassword.length > 256) {
    return { error: 'invalid_password' as const }
  }

  const candidate = await getInvitationRecordById(pool, trimmedInvitationId)
  if (!candidate) return { error: 'not_found' as const }
  if (candidate.email.toLowerCase() !== normalizedEmail) {
    return { error: 'forbidden' as const }
  }
  if (candidate.purpose === 'password_reset') {
    const result = await setInvitationPasswordForEmail(
      normalizedEmail,
      trimmedInvitationId,
      trimmedPassword,
      trimmedUserId,
      passwordWorkLease
    )
    if ('error' in result) return result
    const { sessionContext: _sessionContext, ...data } = result.data
    return { data }
  }
  if (candidate.purpose !== 'member_invitation' && candidate.purpose !== 'admin_desktop_access') {
    return { error: 'not_found' as const }
  }
  if (candidate.status !== 'accepted') return { error: 'not_accepted' as const }

  return runPasswordMutation(
    async db => {
      const invitation = await getInvitationRecordById(db, trimmedInvitationId)
      if (!invitation) return { error: 'not_found' as const }
      if (invitation.email.toLowerCase() !== normalizedEmail) {
        return { error: 'forbidden' as const }
      }
      if (
        invitation.purpose !== 'member_invitation' &&
        invitation.purpose !== 'admin_desktop_access'
      ) {
        return { error: 'not_found' as const }
      }
      if (invitation.status !== 'accepted') return { error: 'not_accepted' as const }
      const user = await ensureInvitationUser(db, invitation.email, invitation.invitee_name)
      if (invitationUserIsRetired(user)) return { error: 'user_retired' as const }
      if (user.id !== trimmedUserId) return { error: 'forbidden' as const }
      const passwordHash = await bcrypt.hash(trimmedPassword, 12)
      if (!(await updateActivePasswordHash(db, user.id, passwordHash))) {
        return { error: 'user_retired' as const }
      }

      if (!invitation.accepted_user_id) {
        await db.query(`UPDATE invitations SET accepted_user_id = $2 WHERE id = $1`, [
          invitation.id,
          user.id,
        ])
      }

      const response = await loadInvitationPasswordResponse(db, invitation.id, user, passwordHash)
      if (!response) return { error: 'not_found' as const }
      return {
        data: {
          passwordUpdated: true,
          ...response,
        },
      }
    },
    { mode: 'standard', lease: passwordWorkLease }
  )
}

export async function setInvitationPasswordForEmail(
  email: string,
  invitationId: string,
  password: string,
  expectedUserId?: string,
  passwordWorkLease?: MemberPasswordWorkLease
) {
  const normalizedEmail = email.trim().toLowerCase()
  const trimmedInvitationId = invitationId.trim()
  const trimmedPassword = password.trim()
  if (!normalizedEmail || !trimmedInvitationId) {
    return { error: 'not_found' as const }
  }
  if (trimmedPassword.length < 8 || trimmedPassword.length > 256) {
    return { error: 'invalid_password' as const }
  }

  return runPasswordMutation(
    async db => {
      const candidate = await getInvitationRecordById(db, trimmedInvitationId)
      if (!candidate || candidate.purpose !== 'password_reset') {
        return { error: 'not_found' as const }
      }
      if (candidate.email.toLowerCase() !== normalizedEmail) {
        return { error: 'forbidden' as const }
      }

      const user = await lockPasswordResetUser(db, normalizedEmail)
      if (!user) return { error: 'not_found' as const }
      if (invitationUserIsRetired(user)) return { error: 'user_retired' as const }
      if (expectedUserId && user.id !== expectedUserId.trim()) {
        return { error: 'forbidden' as const }
      }
      const invitation = await getInvitationRecordById(db, trimmedInvitationId, true)
      if (!invitation || invitation.purpose !== 'password_reset') {
        return { error: 'not_found' as const }
      }
      if (invitation.email.toLowerCase() !== normalizedEmail) {
        return { error: 'forbidden' as const }
      }
      if (invitation.status !== 'pending') return { error: 'not_pending' as const }
      if (invitation.expires_at.getTime() <= Date.now()) return { error: 'expired' as const }
      if (invitation.accepted_user_id && invitation.accepted_user_id !== user.id) {
        return { error: 'forbidden' as const }
      }

      const passwordHash = await bcrypt.hash(trimmedPassword, 12)
      if (!(await updateActivePasswordHash(db, user.id, passwordHash))) {
        return { error: 'user_retired' as const }
      }

      const redeemed = await db.query(
        `UPDATE invitations
            SET status = 'accepted',
                accepted_at = NOW(),
                accepted_user_id = $2
          WHERE id = $1 AND status = 'pending'
          RETURNING id`,
        [invitation.id, user.id]
      )
      if (redeemed.rows.length !== 1) return { error: 'not_pending' as const }
      await revokeSiblingPasswordResets(db, normalizedEmail, invitation.id, user.id)

      const response = await loadInvitationPasswordResponse(db, invitation.id, user, passwordHash)
      if (!response) return { error: 'not_found' as const }
      const sessionContext = await getMemberSessionContext(db, user)
      return {
        data: {
          passwordUpdated: true,
          sessionContext,
          ...response,
        },
      }
    },
    { mode: 'one_use_recovery', lease: passwordWorkLease }
  )
}

export async function updateUserPassword(
  userId: string,
  email: string,
  currentPassword: string,
  newPassword: string
) {
  const normalizedUserId = userId.trim()
  const normalizedEmail = email.trim().toLowerCase()
  const nextPassword = newPassword.trim()
  if (!normalizedUserId || !normalizedEmail) {
    return { error: 'not_found' as const }
  }
  if (nextPassword.length < 8 || nextPassword.length > 256) {
    return { error: 'invalid_password' as const }
  }

  return runPasswordMutation(
    async db => {
      const result = await db.query(
        `SELECT password_hash, password_auth_generation
           FROM users
          WHERE id = $1
            AND email = $2
          LIMIT 1`,
        [normalizedUserId, normalizedEmail]
      )
      const user =
        (result.rows[0] as
          | { password_hash: string | null; password_auth_generation: string | number }
          | undefined) || null
      if (!user) {
        return { error: 'not_found' as const }
      }
      if (!user.password_hash) {
        return { error: 'password_not_set' as const }
      }
      const currentOk = await bcrypt.compare(currentPassword, user.password_hash)
      if (!currentOk) {
        return { error: 'invalid_current_password' as const }
      }

      const update = await db.query(
        `UPDATE users
            SET password_hash = $3,
                password_set_at = NOW(),
                updated_at = NOW()
          WHERE id = $1
            AND password_auth_generation = $2
            AND password_hash = $4
          RETURNING id`,
        [
          normalizedUserId,
          user.password_auth_generation,
          await bcrypt.hash(nextPassword, 12),
          user.password_hash,
        ]
      )
      if (update.rows.length !== 1) return { error: 'credential_changed' as const }
      return { updated: true as const }
    },
    { mode: 'standard' }
  )
}