Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
import { config } from '../config.js'
import { ResolvedServerConnection } from '../types.js'
import {
type DirectRunBindingRequest,
type UserAllowedServers,
fetchHostConnectionFromControlApi,
fetchUserAllowedServersFromControlApi,
} from './controlApiRestService.js'
import { type HostAccessDenial, isHostAccessDenied } from './hostAccessDenial.js'
export { validateRpcRequest, forwardRpcToServer } from './mcpRpcService.js'
export {
forwardHostActivity,
forwardHostHealth,
type HostActivityEvent,
type HostActivitySnapshot,
type HostRuntimeMessageRequest,
forwardHostMessageToHost,
forwardHostStatus,
forwardTaskResultFromHost,
forwardCancelToHost,
UpstreamHostError,
type CancelUpstreamResult,
type HostRuntimeHealth,
type HostRuntimeStatus,
} from './mcpHostRestService.js'
type CacheEntry = {
data: UserAllowedServers
cachedAt: number
}
const userServerCache = new Map<string, CacheEntry>()
async function getCachedUserAllowedServers(
userId: string,
rpcAccessToken: string
): Promise<UserAllowedServers> {
const cached = userServerCache.get(userId)
const now = Date.now()
if (cached && now - cached.cachedAt <= config.controlApiCacheTtlMs) {
return cached.data
}
const data = await fetchUserAllowedServersFromControlApi(userId, rpcAccessToken)
userServerCache.set(userId, { data, cachedAt: now })
return data
}
export async function listAllowedServersForUser(
userId: string,
rpcAccessToken: string
): Promise<{ userId: string; contextIds: string[]; servers: string[] }> {
const data = await getCachedUserAllowedServers(userId, rpcAccessToken)
return {
userId,
contextIds: data.contextIds,
servers: data.servers.map(server => server.name),
}
}
export async function resolveServerConnectionForUser(
userId: string,
serverName: string,
rpcAccessToken: string
): Promise<ResolvedServerConnection | null> {
const data = await getCachedUserAllowedServers(userId, rpcAccessToken)
const server = data.servers.find(entry => entry.name === serverName)
if (!server) return null
return {
name: server.name,
url: server.url,
headers: {},
}
}
export async function resolveHostConnectionForUser(
userId: string,
hostRef: string,
rpcAccessToken: string,
edgeContext?: {
accessScope?: 'team' | 'user'
teamId?: string | null
requestId?: string
directRunBinding?: DirectRunBindingRequest
}
): Promise<ResolvedServerConnection | HostAccessDenial> {
const host = await fetchHostConnectionFromControlApi(userId, hostRef, rpcAccessToken, {
directRunBinding: edgeContext?.directRunBinding,
})
if (isHostAccessDenied(host)) return host
const headers: Record<string, string> = {
...host.headers,
'x-clerum-edge-caller': 'rpc-proxy',
'x-clerum-edge-host-ref': hostRef,
'x-clerum-edge-user-id': userId,
}
if (edgeContext?.teamId) headers['x-clerum-edge-team-id'] = edgeContext.teamId
headers['x-clerum-edge-access-scope'] =
edgeContext?.accessScope ?? (edgeContext?.teamId ? 'team' : 'user')
if (edgeContext?.requestId) headers['x-clerum-edge-request-id'] = edgeContext.requestId
return {
...host,
headers,
}
}