Skip to content

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

TypeScript
9.2 KB
Raw Blame
import express, { Router } from 'express'
import type { Request, Response } from 'express'
import { config } from '../../config.js'
import { pool } from '../../db.js'
import { K8sGateway } from '../../k8s.js'
import {
  requireRpcTokenUserMatch,
  requireValidRpcAccessToken,
  requireValidRpcAccessTokenAny,
} from '../../middleware/rpcAccessAuth.js'
import type { RpcAccessClaims } from '../../profileTypes.js'
import {
  resolveConnectorsForAgents,
  resolveInvocableMcpServersForContexts,
} from '../../services/access/mcpInvocable.js'
import {
  type RpcHostAccessDenialReason,
  type RpcHostAccessDirectory,
  authorizeRpcHostAccess,
} from '../../services/access/rpcHostAccessAuthorizer.js'
import { getUserAgents, getUserContexts } from '../../services/directory/index.js'
import {
  type DirectRunAttributionBindingService,
  DirectRunBindingConflictError,
} from '../../services/tracing/directRunAttributionBindingService.js'
import { parseDirectRunBindingRequest } from '../../services/tracing/directRunBindingRequest.js'

type RpcAccessUsersRouterOptions = {
  bindingService: Pick<DirectRunAttributionBindingService, 'bind'>
  directory?: RpcHostAccessDirectory
  bindingBudgetMs?: number
}

const DEFAULT_DIRECT_RUN_BINDING_BUDGET_MS = 750

const HOST_ACCESS_SCOPES = [
  'host:message:invoke',
  'host:status:read',
  'host:health:read',
  'host:activity:read',
  'host:approval:write',
  'host:model:write',
  'host:task:read',
  'host:session:read',
  'host:session:write',
  'desktop:view',
] as const

type RpcAuthedRequest = Request & { rpcAuth?: RpcAccessClaims }

/**
 * Response header that tells rpc-proxy why control-api denied Host access. The
 * 403 body stays exactly `{"error":"Forbidden"}` (a pinned 21-byte contract);
 * the reason travels out of band so rpc-proxy can tell removed access from
 * other denials. Scope denials from the auth middleware carry no such header.
 */
export const HOST_ACCESS_DENIAL_REASON_HEADER = 'x-host-access-denial-reason'

function denyHostAccess(
  req: RpcAuthedRequest,
  res: Response,
  reason: RpcHostAccessDenialReason | 'claims_missing'
): void {
  req.log?.warn(
    { event: 'rpc_host_access_denied', reason },
    'rpc host access denied by control-plane authority'
  )
  res.setHeader(HOST_ACCESS_DENIAL_REASON_HEADER, reason)
  res.status(403).json({ error: 'Forbidden' })
}

async function bindDirectRunWithinBudget(
  bindingService: Pick<DirectRunAttributionBindingService, 'bind'>,
  input: Parameters<DirectRunAttributionBindingService['bind']>[0],
  budgetMs: number
): Promise<'recorded' | 'unavailable' | 'conflict'> {
  let timeout: ReturnType<typeof setTimeout> | undefined
  const bindingAttempt = bindingService.bind(input).then(
    () => 'recorded' as const,
    error =>
      error instanceof DirectRunBindingConflictError
        ? ('conflict' as const)
        : ('unavailable' as const)
  )
  const deadline = new Promise<'unavailable'>(resolve => {
    timeout = setTimeout(() => resolve('unavailable'), budgetMs)
  })
  try {
    return await Promise.race([bindingAttempt, deadline])
  } finally {
    if (timeout) clearTimeout(timeout)
  }
}

export function createRpcAccessUsersRouter(
  gateway: K8sGateway,
  options: RpcAccessUsersRouterOptions
): Router {
  const router = Router()
  const { bindingService, directory } = options
  const bindingBudgetMs = options.bindingBudgetMs ?? DEFAULT_DIRECT_RUN_BINDING_BUDGET_MS

  router.get(
    '/rpc/access/users/:userId/contexts',
    requireValidRpcAccessToken(),
    requireRpcTokenUserMatch(),
    async (req, res, next) => {
      try {
        res.status(200).json(await getUserContexts(req.params.userId))
      } catch (error) {
        next(error)
      }
    }
  )

  router.get(
    '/rpc/access/users/:userId/agents',
    requireValidRpcAccessToken(),
    requireRpcTokenUserMatch(),
    async (req, res, next) => {
      try {
        res.status(200).json(await getUserAgents(req.params.userId))
      } catch (error) {
        next(error)
      }
    }
  )

  router.get(
    '/rpc/access/users/:userId/mcp-servers',
    requireValidRpcAccessToken(),
    requireRpcTokenUserMatch(),
    async (req, res, next) => {
      try {
        const userContexts = await getUserContexts(req.params.userId)
        // `req.params.userId` is authoritative here — `requireRpcTokenUserMatch()`
        // has already bound it to the RPC token subject. The DB client follows the
        // pool-wrapper idiom used by the other oauth routes (mcpOauth.ts,
        // internal/oauth.ts): `{ query: (t, v) => pool.query(t, v) }`.
        const servers = await resolveInvocableMcpServersForContexts(
          gateway,
          config.mcpServersNamespace,
          userContexts.contextIds,
          req.params.userId,
          { query: (text, values) => pool.query(text, values) }
        )
        res.status(200).json({
          userId: req.params.userId,
          contextIds: userContexts.contextIds,
          servers,
        })
      } catch (error) {
        next(error)
      }
    }
  )

  // Proactive connectors panel read-model (spec 11 U1): the CLASSIFIED fleet
  // per agent — `authorized` / `requires_setup` / `no_oauth`. Same gate as
  // `/mcp-servers`; `req.params.userId` is authoritative (bound to the RPC
  // token subject by `requireRpcTokenUserMatch()`) and flows only into the
  // grant-presence key, never from a body. Agents derive from `getUserAgents`.
  router.get(
    '/rpc/access/users/:userId/mcp-connectors',
    requireValidRpcAccessToken(),
    requireRpcTokenUserMatch(),
    async (req, res, next) => {
      try {
        const { agentNames } = await getUserAgents(req.params.userId)
        const agents = await resolveConnectorsForAgents(
          gateway,
          {
            mcpServersNamespace: config.mcpServersNamespace,
            hostsNamespace: config.hostsNamespace,
            agentNames,
            userId: req.params.userId,
          },
          { query: (text, values) => pool.query(text, values) }
        )
        res.status(200).json({ userId: req.params.userId, agents })
      } catch (error) {
        next(error)
      }
    }
  )

  // One control-plane authority serves both read-only Host resolution and the
  // message-path resolve+bind operation. Access requires the signed subject and
  // host claim, a live user/team directory grant, and an enabled Host CR.
  const hostAccessPath = '/rpc/access/users/:userId/mcp-hosts/:hostRef'

  router.get(
    hostAccessPath,
    requireValidRpcAccessTokenAny([...HOST_ACCESS_SCOPES]),
    async (req: RpcAuthedRequest, res, next) => {
      try {
        const userId = String(req.params.userId || '').trim()
        const hostRef = String(req.params.hostRef || '').trim()
        const claims = req.rpcAuth
        if (!claims) {
          denyHostAccess(req, res, 'claims_missing')
          return
        }
        const authorization = await authorizeRpcHostAccess(
          gateway,
          claims,
          userId,
          hostRef,
          directory
        )
        if (!authorization.authorized) {
          denyHostAccess(req, res, authorization.reason)
          return
        }
        res.status(200).json(authorization.connection)
      } catch (error) {
        next(error)
      }
    }
  )

  router.post(
    hostAccessPath,
    requireValidRpcAccessToken('host:message:invoke'),
    express.json({ limit: '2kb', strict: true }),
    async (req: RpcAuthedRequest, res, next) => {
      try {
        const userId = String(req.params.userId || '').trim()
        const hostRef = String(req.params.hostRef || '').trim()
        const claims = req.rpcAuth
        const binding = parseDirectRunBindingRequest(req.body)
        if (!claims) {
          denyHostAccess(req, res, 'claims_missing')
          return
        }
        if (!binding) {
          res.status(400).json({ error: 'invalid_direct_run_binding' })
          return
        }

        const authorization = await authorizeRpcHostAccess(
          gateway,
          claims,
          userId,
          hostRef,
          directory
        )
        if (!authorization.authorized) {
          denyHostAccess(req, res, authorization.reason)
          return
        }

        const bindingStatus = await bindDirectRunWithinBudget(
          bindingService,
          {
            ...binding,
            hostRef,
            identityIssuer: config.rpcJwtIssuer,
            actorHumanSub: claims.sub,
            userId: claims.sub,
            teamId: claims.teamId,
          },
          bindingBudgetMs
        )
        if (bindingStatus === 'recorded') {
          res.status(200).json({
            ...authorization.connection,
            bindingStatus: 'recorded',
          })
          return
        }
        if (bindingStatus === 'conflict') {
          res.status(409).json({ error: 'direct_run_binding_conflict' })
          return
        }
        req.log?.warn(
          {
            event: 'governed_trace_operational_error',
            scope: 'agent_run',
            reason: 'attribution_binding_unavailable',
          },
          'direct run attribution binding unavailable after host authorization'
        )
        res.status(200).json({
          ...authorization.connection,
          bindingStatus: 'unavailable',
        })
      } catch (error) {
        next(error)
      }
    }
  )

  return router
}