Skip to content

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

TypeScript
6.7 KB
Raw Blame
import type { DbClient } from '../../db.js'
import { pool } from '../../db.js'
import { bulkSetLinkedItems } from '../../shared/generics.js'
import {
  type ControlApiPermissionSubject,
  appendControlApiPermissionEventsInTransaction,
} from '../tracing/controlApiPermissionEvents.js'

async function appendAgentAccessChanges(
  db: DbClient,
  operatorSub: string,
  subject: ControlApiPermissionSubject,
  change: { added: string[]; removed: string[] }
): Promise<void> {
  const mapChanges = (action: 'grant' | 'revoke', values: string[]) =>
    values.map(value => ({
      action,
      resourceClass: 'agent_access',
      resourceRef: `agent:${value}`,
      subject,
    }))
  await appendControlApiPermissionEventsInTransaction(db, {
    operatorSub,
    changes: [...mapChanges('grant', change.added), ...mapChanges('revoke', change.removed)],
  })
}

export { LinkedItemsPreconditionError as AgentGrantPreconditionError } from '../../shared/generics.js'

export async function setUserAgents(
  userId: string,
  agentNames: string[],
  operatorSub: string,
  expectedCurrentAgentNames?: string[]
) {
  const result = await bulkSetLinkedItems(
    'user_agents',
    'user_id',
    userId,
    'agent_name',
    agentNames,
    (db, change) => appendAgentAccessChanges(db, operatorSub, { kind: 'user', id: userId }, change),
    { expectedItems: expectedCurrentAgentNames }
  )
  return { userId, agentNames: result.items }
}

/**
 * Replace the full set of users authorized to invoke a given agent.
 * Inverse of setUserAgents — manages user_agents from the agent's perspective.
 * Used when creating or editing a Host CRD and selecting its authorized users.
 */
export async function setAgentUsers(agentName: string, userIds: string[], operatorSub: string) {
  const result = await bulkSetLinkedItems(
    'user_agents',
    'agent_name',
    agentName,
    'user_id',
    userIds,
    async (db, change) => {
      await appendControlApiPermissionEventsInTransaction(db, {
        operatorSub,
        changes: [
          ...change.added.map(userId => ({
            action: 'grant' as const,
            resourceClass: 'agent_access',
            resourceRef: `agent:${agentName}`,
            subject: { kind: 'user' as const, id: userId },
          })),
          ...change.removed.map(userId => ({
            action: 'revoke' as const,
            resourceClass: 'agent_access',
            resourceRef: `agent:${agentName}`,
            subject: { kind: 'user' as const, id: userId },
          })),
        ],
      })
    }
  )
  return { agentName, userIds: result.items }
}

export async function getUserAgents(userId: string, db: Pick<DbClient, 'query'> = pool) {
  const result = await db.query(
    `SELECT agent_name
       FROM user_agents ua
       JOIN users u ON u.id = ua.user_id
      WHERE ua.user_id = $1
        AND u.lifecycle_state = 'active'
   ORDER BY agent_name ASC`,
    [userId]
  )
  return {
    userId,
    agentNames: result.rows.map(row => String((row as { agent_name: string }).agent_name)),
  }
}

export async function listUsersByAgent(agentName: string) {
  const resolvedAgentName = agentName.trim()
  if (!resolvedAgentName) return []

  const result = await pool.query(
    `SELECT u.id, u.email, u.name, p.display_name
       FROM user_agents ua
       JOIN users u ON u.id = ua.user_id
  LEFT JOIN profiles p ON p.user_id = u.id
      WHERE ua.agent_name = $1
        AND u.lifecycle_state = 'active'
   ORDER BY u.email ASC`,
    [resolvedAgentName]
  )

  return result.rows.map(row => ({
    id: String((row as { id: string }).id),
    email: String((row as { email: string }).email),
    name: ((row as { name?: string | null }).name ?? null) as string | null,
    displayName: ((row as { display_name?: string | null }).display_name ?? null) as string | null,
  }))
}

export async function setTeamAgents(
  teamId: string,
  agentNames: string[],
  operatorSub: string,
  expectedCurrentAgentNames?: string[]
) {
  const result = await bulkSetLinkedItems(
    'team_agents',
    'team_id',
    teamId,
    'agent_name',
    agentNames,
    (db, change) => appendAgentAccessChanges(db, operatorSub, { kind: 'team', id: teamId }, change),
    { expectedItems: expectedCurrentAgentNames }
  )
  return { teamId, agentNames: result.items }
}

/**
 * Replace the full set of teams authorized to invoke a given agent.
 * Inverse of setTeamAgents — manages team_agents from the agent's perspective.
 * Used when creating or editing a Host CRD and selecting its authorized teams.
 */
export async function setAgentTeams(agentName: string, teamIds: string[], operatorSub: string) {
  const result = await bulkSetLinkedItems(
    'team_agents',
    'agent_name',
    agentName,
    'team_id',
    teamIds,
    async (db, change) => {
      await appendControlApiPermissionEventsInTransaction(db, {
        operatorSub,
        changes: [
          ...change.added.map(teamId => ({
            action: 'grant' as const,
            resourceClass: 'agent_access',
            resourceRef: `agent:${agentName}`,
            subject: { kind: 'team' as const, id: teamId },
          })),
          ...change.removed.map(teamId => ({
            action: 'revoke' as const,
            resourceClass: 'agent_access',
            resourceRef: `agent:${agentName}`,
            subject: { kind: 'team' as const, id: teamId },
          })),
        ],
      })
    }
  )
  return { agentName, teamIds: result.items }
}

export async function getTeamAgents(teamId: string, db: Pick<DbClient, 'query'> = pool) {
  const result = await db.query(
    `SELECT agent_name
       FROM team_agents
      WHERE team_id = $1
   ORDER BY agent_name ASC`,
    [teamId]
  )
  return {
    teamId,
    agentNames: result.rows.map(row => String((row as { agent_name: string }).agent_name)),
  }
}

export async function listTeamAgentsByTeam() {
  const result = await pool.query(
    `SELECT team_id, agent_name
       FROM team_agents
   ORDER BY team_id ASC, agent_name ASC`
  )
  const byTeam: Record<string, string[]> = {}
  for (const row of result.rows) {
    const teamId = String((row as { team_id: string }).team_id)
    const agentName = String((row as { agent_name: string }).agent_name)
    if (!byTeam[teamId]) byTeam[teamId] = []
    byTeam[teamId].push(agentName)
  }
  return byTeam
}

export async function listTeamsByAgent(agentName: string) {
  const resolvedAgentName = agentName.trim()
  if (!resolvedAgentName) return []

  const result = await pool.query(
    `SELECT t.id, t.name
       FROM team_agents ta
       JOIN teams t ON t.id = ta.team_id
      WHERE ta.agent_name = $1
   ORDER BY t.name ASC`,
    [resolvedAgentName]
  )

  return result.rows.map(row => ({
    id: String((row as { id: string }).id),
    name: String((row as { name: string }).name),
  }))
}