Skip to content

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

TypeScript
7.7 KB
Raw Blame
import { type Response, Router } from 'express'
import { asyncHandler } from '../../http/asyncHandler.js'
import type { K8sGateway } from '../../k8s.js'
import type { UiAuthedRequest } from '../../middleware/controlUIAuth.js'
import {
  addMemberToTeam,
  adminDeleteTeam,
  createTeam,
  getTeamById,
  listAllPendingInvitationsAdmin,
  listAllTeams,
  listMembers,
  listTeamAgentsByTeam,
  listTeamContextsByTeam,
  listUsers,
  renameTeam,
  softDeleteMember,
  updateMemberRole,
} from '../../services/directory/index.js'
import { normalizeTeamRoleInput } from '../../services/directory/types.js'
import {
  loadAdminActiveAgentNames,
  loadAdminActiveContextIds,
  sendAdminAccessReconciliationError,
} from './accessReconciliationResponse.js'
import { registerAdminTeamAccessRoutes } from './teamAccess.js'
import { registerAdminTeamInvitationRoutes } from './teamInvitations.js'

function sendInvitationServiceError(res: Response, error: unknown): boolean {
  const message = error instanceof Error ? error.message : String(error)
  if (!message.includes('Member registration service')) return false
  res.status(502).json({ error: 'invitation_service_unavailable', message })
  return true
}

function isTeamAuditHistoryForeignKeyError(error: unknown): boolean {
  if (!error || typeof error !== 'object') return false
  const pgError = error as {
    code?: unknown
    constraint?: unknown
    detail?: unknown
    message?: unknown
  }
  if (String(pgError.code || '') !== '23503') return false
  const details = [pgError.constraint, pgError.detail, pgError.message]
    .filter((value): value is string => typeof value === 'string')
    .join('\n')
  return (
    details.includes('team_workflow_grants_audit') ||
    details.includes('workflow_recipe_allowed_teams_audit')
  )
}

export function createAdminTeamsRouter(gateway: K8sGateway): Router {
  const router = Router()

  router.get('/admin/pending-invitations', async (_req, res, next) => {
    try {
      res.status(200).json({ items: await listAllPendingInvitationsAdmin() })
    } catch (error) {
      if (sendInvitationServiceError(res, error)) return
      next(error)
    }
  })

  router.get(
    '/admin/profile-admin/overview',
    asyncHandler(async (_req, res) => {
      try {
        const [
          teams,
          users,
          pendingInvitations,
          agentsByTeam,
          contextsByTeam,
          activeAgentNames,
          activeContextIds,
        ] = await Promise.all([
          listAllTeams(),
          listUsers(''),
          listAllPendingInvitationsAdmin(),
          listTeamAgentsByTeam(),
          listTeamContextsByTeam(),
          loadAdminActiveAgentNames(gateway),
          loadAdminActiveContextIds(gateway),
        ])
        const activeAgentSet = new Set(activeAgentNames)
        const activeContextSet = new Set(activeContextIds)
        const teamAgentCounts = Object.fromEntries(
          teams.map(team => [
            team.id,
            (agentsByTeam[team.id] || []).filter(agentName => activeAgentSet.has(agentName)).length,
          ])
        )
        const teamContextCounts = Object.fromEntries(
          teams.map(team => [
            team.id,
            (contextsByTeam[team.id] || []).filter(contextId => activeContextSet.has(contextId))
              .length,
          ])
        )
        res.status(200).json({
          teams,
          users,
          pendingInvitations,
          teamAgentCounts,
          teamContextCounts,
        })
      } catch (error) {
        if (sendInvitationServiceError(res, error)) return
        if (sendAdminAccessReconciliationError(res, error)) return
        throw error
      }
    })
  )

  router.get('/admin/teams', async (_req, res, next) => {
    try {
      res.status(200).json({ items: await listAllTeams() })
    } catch (error) {
      if (sendInvitationServiceError(res, error)) return
      next(error)
    }
  })

  router.post('/admin/teams', async (req, res, next) => {
    try {
      const name = String(req.body?.name || '').trim()
      if (!name) {
        res.status(400).json({ error: 'name is required' })
        return
      }
      res.status(200).json(await createTeam(name))
    } catch (error) {
      next(error)
    }
  })

  registerAdminTeamInvitationRoutes(router)

  router.get('/admin/teams/:teamId', async (req, res, next) => {
    try {
      const team = await getTeamById(req.params.teamId)
      if (!team) {
        res.status(404).json({ error: 'not_found' })
        return
      }
      res.status(200).json(team)
    } catch (error) {
      next(error)
    }
  })

  /**
   * Hard-delete an empty team plus its invitations, inactive memberships, and team
   * context/agent links (DB CASCADE). Active members block deletion (409 team_not_empty).
   * Audit history is retained, so teams referenced by workflow audit rows cannot be deleted
   * (409 team_has_audit_history).
   */
  router.delete('/admin/teams/:teamId', async (req, res, next) => {
    try {
      const deleted = await adminDeleteTeam(req.params.teamId)
      if ('error' in deleted) {
        if (deleted.error === 'team_not_empty') {
          res.status(409).json({ error: 'team_not_empty' })
          return
        }
        res.status(404).json({ error: 'not_found' })
        return
      }
      res.status(200).json({ deleted: true, id: deleted.id })
    } catch (error) {
      if (isTeamAuditHistoryForeignKeyError(error)) {
        res.status(409).json({ error: 'team_has_audit_history' })
        return
      }
      next(error)
    }
  })

  router.put('/admin/teams/:teamId/name', async (req, res, next) => {
    try {
      const name = String(req.body?.name || '').trim()
      if (!name) {
        res.status(400).json({ error: 'name is required' })
        return
      }
      const updated = await renameTeam(req.params.teamId, name)
      if (!updated) {
        res.status(404).json({ error: 'not_found' })
        return
      }
      res.status(200).json(updated)
    } catch (error) {
      next(error)
    }
  })

  router.get('/admin/teams/:teamId/members', async (req, res, next) => {
    try {
      res.status(200).json({ items: await listMembers(req.params.teamId) })
    } catch (error) {
      next(error)
    }
  })

  router.post('/admin/teams/:teamId/members', async (req, res, next) => {
    try {
      const userId = String(req.body?.userId || '').trim()
      const role = normalizeTeamRoleInput(req.body?.role || 'member')
      if (!userId || !role) {
        res.status(400).json({ error: 'invalid payload' })
        return
      }
      res
        .status(200)
        .json(
          await addMemberToTeam(
            req.params.teamId,
            userId,
            (req as UiAuthedRequest).adminAuth!.sub,
            role
          )
        )
    } catch (error) {
      next(error)
    }
  })

  router.patch('/admin/teams/:teamId/members/:userId/role', async (req, res, next) => {
    try {
      const role = normalizeTeamRoleInput(req.body?.role)
      if (!role) {
        res.status(400).json({ error: 'invalid role' })
        return
      }
      res
        .status(200)
        .json(
          await updateMemberRole(
            req.params.teamId,
            req.params.userId,
            role,
            (req as UiAuthedRequest).adminAuth!.sub
          )
        )
    } catch (error) {
      next(error)
    }
  })

  router.delete('/admin/teams/:teamId/members/:userId', async (req, res, next) => {
    try {
      const deleted = await softDeleteMember(
        req.params.teamId,
        req.params.userId,
        (req as UiAuthedRequest).adminAuth!.sub
      )
      if (!deleted) {
        res.status(404).json({ error: 'not_found' })
        return
      }
      res.status(200).json(deleted)
    } catch (error) {
      next(error)
    }
  })

  registerAdminTeamAccessRoutes(router, gateway)

  return router
}