Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
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
}