Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
import { Router } from 'express'
import bcrypt from 'bcryptjs'
import { type UiAuthedRequest, requireAuthForControlUI } from '../../middleware/controlUIAuth.js'
import {
createControlAdminEmailChangeRequest,
createControlAdminInvitation,
deleteControlAdmin,
findAdminById,
getPendingControlAdminEmailChangeForAdmin,
isValidAdminEmail,
isValidAdminUsername,
listControlAdmins,
revokeControlAdminEmailChangeRequest,
revokeControlAdminInvitation,
updateAdminPassword,
updateAdminUsername,
} from '../../services/adminAuthService.js'
import {
registerAndSendControlAdminEmailConfirmation,
registerAndSendControlAdminInvitation,
} from '../../services/controlAdminInvitationRegistrationService.js'
import {
findMemberByEmail,
provisionMemberFromAdmin,
} from '../../services/directory/adminProvisioning.js'
import { revokePendingInvitation } from '../../services/directory/index.js'
import { normalizeTeamRoleInput } from '../../services/directory/types.js'
import {
GfsDesktopOperatorLinkError,
gfsDesktopOperatorLinkService,
} from '../../services/gfsDesktopOperatorLinkService.js'
function readString(value: unknown): string {
return String(value || '').trim()
}
const ADMIN_PASSWORD_MIN_LENGTH = 8
const ADMIN_PASSWORD_MAX_LENGTH = 256
export function createAdminControlAdminsRouter(): Router {
const router = Router()
router.get('/admin/settings/me', 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
}
const pendingEmailChange = await getPendingControlAdminEmailChangeForAdmin(admin.id)
res.status(200).json({
me: {
id: admin.id,
username: admin.username,
email: admin.email,
role: admin.role,
pendingEmailChange: pendingEmailChange
? {
email: pendingEmailChange.email,
expiresAt: pendingEmailChange.expiresAt.toISOString(),
createdAt: pendingEmailChange.createdAt.toISOString(),
}
: null,
},
})
} catch (error) {
next(error)
}
})
router.get('/admin/settings/bridge-status', 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
}
const pendingEmailChange = await getPendingControlAdminEmailChangeForAdmin(admin.id)
const member = admin.email ? await findMemberByEmail(admin.email) : null
res.status(200).json({
admin: {
id: admin.id,
username: admin.username,
email: admin.email,
emailConfirmed: Boolean(admin.email && !pendingEmailChange),
pendingEmailChange: pendingEmailChange
? {
email: pendingEmailChange.email,
expiresAt: pendingEmailChange.expiresAt.toISOString(),
createdAt: pendingEmailChange.createdAt.toISOString(),
}
: null,
},
member,
})
} catch (error) {
next(error)
}
})
router.patch('/admin/settings/username', async (req: UiAuthedRequest, res, next) => {
try {
const adminId = req.adminAuth?.sub
if (!adminId) {
res.status(401).json({ error: 'Unauthorized' })
return
}
const username = readString(req.body?.username)
if (!username) {
res.status(400).json({ error: 'username is required' })
return
}
if (!isValidAdminUsername(username)) {
res.status(400).json({
error:
'username must be 3-64 characters and use letters, numbers, dots, dashes or underscores',
})
return
}
const result = await updateAdminUsername(adminId, username)
if ('error' in result) {
const status = result.error === 'not_found' ? 404 : 409
res.status(status).json({ error: result.error })
return
}
res.status(200).json({
me: {
id: result.id,
username: result.username,
email: result.email,
role: result.role,
},
})
} catch (error) {
next(error)
}
})
router.post('/admin/settings/email-change', async (req: UiAuthedRequest, res, next) => {
try {
const adminId = req.adminAuth?.sub
if (!adminId) {
res.status(401).json({ error: 'Unauthorized' })
return
}
const email = readString(req.body?.email).toLowerCase()
if (!email) {
res.status(400).json({ error: 'email is required' })
return
}
if (!isValidAdminEmail(email)) {
res.status(400).json({ error: 'email must be valid' })
return
}
const confirmation = await createControlAdminEmailChangeRequest(adminId, email)
if ('error' in confirmation) {
const status = confirmation.error === 'not_found' ? 404 : 409
res.status(status).json({ error: confirmation.error })
return
}
try {
await registerAndSendControlAdminEmailConfirmation(
confirmation.email,
confirmation.id,
confirmation.createdAt.toISOString(),
confirmation.expiresAt.toISOString()
)
} catch (sendError) {
await revokeControlAdminEmailChangeRequest(confirmation.id)
throw sendError
}
res.status(202).json({
confirmation: {
id: confirmation.id,
email: confirmation.email,
status: confirmation.status,
expiresAt: confirmation.expiresAt.toISOString(),
createdAt: confirmation.createdAt.toISOString(),
},
})
} catch (error) {
next(error)
}
})
router.post('/admin/settings/password', 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
}
const currentPassword = String(req.body?.currentPassword || '')
const newPassword = String(req.body?.newPassword || '')
if (!currentPassword || !newPassword) {
res.status(400).json({ error: 'currentPassword and newPassword are required' })
return
}
if (
newPassword.length < ADMIN_PASSWORD_MIN_LENGTH ||
newPassword.length > ADMIN_PASSWORD_MAX_LENGTH
) {
res.status(400).json({ error: 'newPassword must be between 8 and 256 characters' })
return
}
const currentPasswordOk = await bcrypt.compare(currentPassword, admin.passwordHash)
if (!currentPasswordOk) {
res.status(401).json({ error: 'current_password_invalid' })
return
}
await updateAdminPassword(admin.id, await bcrypt.hash(newPassword, 12))
res.status(200).json({ updated: true })
} catch (error) {
next(error)
}
})
router.get('/admin/control-admins', async (req: UiAuthedRequest, res, next) => {
try {
if (!req.adminAuth?.sub) {
res.status(401).json({ error: 'Unauthorized' })
return
}
const result = await listControlAdmins()
res.status(200).json(result)
} catch (error) {
next(error)
}
})
router.post('/admin/control-admin-invitations', async (req: UiAuthedRequest, res, next) => {
try {
const invitedByAdminId = req.adminAuth?.sub
if (!invitedByAdminId) {
res.status(401).json({ error: 'Unauthorized' })
return
}
const email = readString(req.body?.email).toLowerCase()
if (!email) {
res.status(400).json({ error: 'email is required' })
return
}
if (!isValidAdminEmail(email)) {
res.status(400).json({ error: 'email must be valid' })
return
}
const replaceInviterInput: unknown = req.body?.replaceInviter
if (replaceInviterInput !== undefined && typeof replaceInviterInput !== 'boolean') {
res.status(400).json({ error: 'replaceInviter must be a boolean' })
return
}
const createDesktopAccess = req.body?.createDesktopAccess === true
const teamsInput: unknown[] =
createDesktopAccess && Array.isArray(req.body?.teams) ? req.body.teams : []
const teamAssignments = teamsInput
.map(item => {
const row = item && typeof item === 'object' ? (item as Record<string, unknown>) : {}
const teamId = readString(row.teamId || row.id)
const role = normalizeTeamRoleInput(row.role) || 'member'
return teamId ? { teamId, role } : null
})
.filter((item): item is { teamId: string; role: 'admin' | 'inviter' | 'member' } =>
Boolean(item)
)
const created = await createControlAdminInvitation(email, invitedByAdminId, {
replaceInviter: replaceInviterInput === true,
...(createDesktopAccess ? { desktopAccess: { teamAssignments } } : {}),
})
if ('error' in created) {
res.status(409).json({ error: created.error })
return
}
const invitation = 'invitation' in created ? created.invitation : created
const desktopInvitation = 'desktopInvitation' in created ? created.desktopInvitation : null
try {
await registerAndSendControlAdminInvitation(
invitation.email,
invitation.id,
invitation.createdAt.toISOString(),
invitation.expiresAt.toISOString(),
{
desktopTeamNames: desktopInvitation?.teams.map(team => team.name) || [],
}
)
} catch (sendError) {
await revokeControlAdminInvitation(invitation.id)
if (desktopInvitation) {
await revokePendingInvitation(desktopInvitation.team_id, desktopInvitation.id)
}
throw sendError
}
res.status(201).json({
invitation: {
id: invitation.id,
email: invitation.email,
status: invitation.status,
expiresAt: invitation.expiresAt.toISOString(),
createdAt: invitation.createdAt.toISOString(),
replaceInviter: invitation.replaceInviter,
},
})
} catch (error) {
next(error)
}
})
router.get(
'/admin/control-admins/:adminId/gfs-operator-link',
async (req: UiAuthedRequest, res, next) => {
try {
const adminId = readString(req.params.adminId)
if (!adminId) return void res.status(400).json({ error: 'adminId is required' })
const link = await gfsDesktopOperatorLinkService.getLinkForControlAdmin(adminId)
res.status(200).json({
gfsOperatorLinkStatus: link?.state === 'active' ? 'active' : 'revoked',
controlAdminId: adminId,
desktopUserId: link?.desktopUserId ?? null,
generation: link?.generation ?? null,
rowVersion: link?.rowVersion ?? null,
revocationReason: link?.revocationReason ?? null,
})
} catch (error) {
next(error)
}
}
)
router.delete(
'/admin/control-admin-invitations/:invitationId',
requireAuthForControlUI,
async (req: UiAuthedRequest, res, next) => {
try {
const adminId = req.adminAuth?.sub
if (!adminId) {
res.status(401).json({ error: 'Unauthorized' })
return
}
const invitationId = readString(req.params.invitationId)
if (!invitationId) {
res.status(400).json({ error: 'invitationId is required' })
return
}
await revokeControlAdminInvitation(invitationId)
res.status(200).json({ revoked: true })
} catch (error) {
next(error)
}
}
)
router.delete('/admin/control-admins/:adminId', async (req: UiAuthedRequest, res, next) => {
try {
const currentAdminId = req.adminAuth?.sub
if (!currentAdminId) {
res.status(401).json({ error: 'Unauthorized' })
return
}
const adminId = readString(req.params.adminId)
if (!adminId) {
res.status(400).json({ error: 'adminId is required' })
return
}
if (adminId === currentAdminId) {
res.status(400).json({ error: 'cannot_delete_current_admin' })
return
}
const result = await deleteControlAdmin(currentAdminId, adminId)
if ('error' in result) {
res.status(404).json({ error: result.error })
return
}
res.status(200).json(result)
} catch (error) {
next(error)
}
})
router.delete(
'/admin/control-admins/:adminId/gfs-operator-link',
async (req: UiAuthedRequest, res, next) => {
try {
const operatorSub = req.adminAuth?.sub
if (!operatorSub) {
res.status(401).json({ error: 'Unauthorized' })
return
}
const adminId = readString(req.params.adminId)
if (!adminId) {
res.status(400).json({ error: 'adminId is required' })
return
}
const targetAdmin = await findAdminById(adminId)
if (!targetAdmin) {
res.status(404).json({ error: 'not_found' })
return
}
// Resolve the exact persisted pair server-side. The caller cannot
// choose a Desktop user or ask the endpoint to create/reassign one.
const link = await gfsDesktopOperatorLinkService.getLinkForControlAdmin(adminId)
if (!link || link.state === 'revoked') {
res.status(200).json({
revoked: false,
gfsOperatorLinkStatus: 'revoked',
controlAdminId: adminId,
desktopUserId: link?.desktopUserId ?? null,
generation: link?.generation ?? null,
rowVersion: link?.rowVersion ?? null,
})
return
}
const requestedRowVersion =
req.body?.rowVersion === undefined ? link.rowVersion : Number(req.body.rowVersion)
const result = await gfsDesktopOperatorLinkService.unlink({
desktopUserId: link.desktopUserId,
controlAdminId: link.controlAdminId,
operatorSub,
rowVersion: requestedRowVersion,
reason: readString(req.body?.reason),
})
res.status(200).json({
revoked: result.unlinked,
gfsOperatorLinkStatus: 'revoked',
controlAdminId: adminId,
desktopUserId: link.desktopUserId,
generation: result.link?.generation ?? link.generation ?? null,
rowVersion: result.link?.rowVersion ?? null,
})
} catch (error) {
if (error instanceof GfsDesktopOperatorLinkError) {
if (error.code === 'invalid_input') {
res.status(400).json({ error: error.code })
return
}
if (error.code === 'control_admin_not_found') {
res.status(404).json({ error: error.code })
return
}
if (error.code === 'link_conflict' || error.code === 'malformed_link') {
res.status(409).json({ error: error.code })
return
}
}
next(error)
}
}
)
router.post(
'/admin/control-admins/:adminId/gfs-operator-link/reactivate',
async (req: UiAuthedRequest, res, next) => {
try {
const operatorSub = req.adminAuth?.sub
const adminId = readString(req.params.adminId)
if (!operatorSub) return void res.status(401).json({ error: 'Unauthorized' })
if (!adminId) return void res.status(400).json({ error: 'adminId is required' })
const result = await gfsDesktopOperatorLinkService.reactivate({
controlAdminId: adminId,
operatorSub,
rowVersion: Number(req.body?.rowVersion),
reason: readString(req.body?.reason),
})
res.status(200).json({
reactivated: result.reactivated,
gfsOperatorLinkStatus: result.reactivated ? 'active' : 'revoked',
controlAdminId: adminId,
desktopUserId: result.link?.desktopUserId ?? null,
generation: result.link?.generation ?? null,
rowVersion: result.link?.rowVersion ?? null,
})
} catch (error) {
if (error instanceof GfsDesktopOperatorLinkError && error.code === 'invalid_input') {
res.status(400).json({ error: error.code })
return
}
if (error instanceof GfsDesktopOperatorLinkError && error.code === 'link_conflict') {
res.status(409).json({ error: error.code })
return
}
if (
error instanceof GfsDesktopOperatorLinkError &&
(error.code === 'control_admin_inactive' ||
error.code === 'desktop_user_retired' ||
error.code === 'malformed_link')
) {
res.status(409).json({ error: error.code })
return
}
if (
error instanceof GfsDesktopOperatorLinkError &&
error.code === 'desktop_user_not_found'
) {
res.status(404).json({ error: error.code })
return
}
next(error)
}
}
)
router.post('/admin/control-admins/:adminId/member', async (req: UiAuthedRequest, res, next) => {
try {
const currentAdminId = req.adminAuth?.sub
if (!currentAdminId) {
res.status(401).json({ error: 'Unauthorized' })
return
}
const adminId = readString(req.params.adminId)
if (!adminId) {
res.status(400).json({ error: 'adminId is required' })
return
}
const teamsInput: unknown[] = Array.isArray(req.body?.teams) ? req.body.teams : []
const teamAssignments = teamsInput
.map(item => {
const row = item && typeof item === 'object' ? (item as Record<string, unknown>) : {}
const teamId = readString(row.teamId || row.id)
const role = normalizeTeamRoleInput(row.role) || 'member'
return teamId ? { teamId, role } : null
})
.filter((item): item is { teamId: string; role: 'admin' | 'inviter' | 'member' } =>
Boolean(item)
)
const result = await provisionMemberFromAdmin({
adminId,
operatorSub: currentAdminId,
teamAssignments,
seedPassword: req.body?.reusePassword === true,
})
if ('error' in result) {
const status = result.error === 'admin_not_found' ? 404 : 409
res.status(status).json({ error: result.error })
return
}
res.status(result.created ? 201 : 200).json(result)
} catch (error) {
next(error)
}
})
return router
}