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 { timingSafeEqual } from 'node:crypto'
import fsSync from 'node:fs'
import fs from 'node:fs/promises'
import http from 'node:http'
import { executeSnippetInWorker } from './snippetRuntime'
import type {
  SnippetExecuteRequest,
  SnippetResolvedMcpServer,
  SnippetResolvedWorkload,
  SnippetRunInvocationRequest,
} from './snippetTypes'
import type { SnippetRunSpec } from './types'

const DEFAULT_PORT = 8095
const MAX_REQUEST_BYTES = 256_000
const DEFAULT_WORKFLOW_CONFIG_PATH = '/etc/workflow/config.json'
const DEFAULT_SNIPPET_STEP_TIMEOUT_MS = 300_000
const SNIPPET_RUNNER_STEP_TIMEOUT_MS_ENV = 'SNIPPET_RUNNER_STEP_TIMEOUT_MS'

interface RuntimeWorkflowConfig {
  name?: string
  recipeName?: string
  inputs?: Record<string, unknown>
  steps: Array<{
    id: string
    timeoutSeconds?: number
    run?: SnippetRunSpec
  }>
  workloads?: SnippetResolvedWorkload[]
  mcpServers?: Array<{ id: string; endpoint: string; transport?: string }>
}

function safeEqual(a: string, b: string): boolean {
  if (a.length !== b.length) return false
  return timingSafeEqual(Buffer.from(a), Buffer.from(b))
}

function getBearerToken(req: http.IncomingMessage): string | undefined {
  const auth = req.headers.authorization
  if (!auth?.startsWith('Bearer ')) return undefined
  return auth.slice('Bearer '.length)
}

export async function readSnippetRunnerToken(): Promise<string> {
  const tokenFile = process.env.SNIPPET_RUNNER_TOKEN_FILE
  if (!tokenFile) throw new Error('SNIPPET_RUNNER_TOKEN_FILE is required')
  const token = (await fs.readFile(tokenFile, 'utf8')).trim()
  if (!token) throw new Error('SNIPPET_RUNNER_TOKEN_FILE is empty')
  return token
}

async function readJson(req: http.IncomingMessage): Promise<unknown> {
  const chunks: Buffer[] = []
  let total = 0
  for await (const chunk of req) {
    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
    total += buf.length
    if (total > MAX_REQUEST_BYTES) throw new Error('snippet request body is too large')
    chunks.push(buf)
  }
  return JSON.parse(Buffer.concat(chunks).toString('utf8'))
}

function writeJson(res: http.ServerResponse, status: number, body: unknown): void {
  res.writeHead(status, { 'Content-Type': 'application/json' })
  res.end(JSON.stringify(body))
}

function isSnippetRunInvocationRequest(value: unknown): value is SnippetRunInvocationRequest {
  if (!value || typeof value !== 'object') return false
  const raw = value as Record<string, unknown>
  return (
    typeof raw.workflowName === 'string' &&
    typeof raw.stepId === 'string' &&
    (raw.previousOutputs === undefined ||
      (typeof raw.previousOutputs === 'object' && !Array.isArray(raw.previousOutputs))) &&
    (raw.inputs === undefined || (typeof raw.inputs === 'object' && !Array.isArray(raw.inputs))) &&
    (raw.timeoutSeconds === undefined ||
      (typeof raw.timeoutSeconds === 'number' &&
        Number.isSafeInteger(raw.timeoutSeconds) &&
        raw.timeoutSeconds > 0))
  )
}

export function createSnippetRunnerServer(): http.Server {
  const tokenFile = process.env.SNIPPET_RUNNER_TOKEN_FILE
  if (!tokenFile) {
    throw new Error('SNIPPET_RUNNER_TOKEN_FILE is required')
  }
  try {
    const token = fsSync.readFileSync(tokenFile, 'utf8').trim()
    if (!token) throw new Error('empty token file')
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error)
    throw new Error(`SNIPPET_RUNNER_TOKEN_FILE is unreadable: ${message}`)
  }

  return http.createServer(async (req, res) => {
    if (req.method === 'GET' && req.url === '/health') {
      writeJson(res, 200, { status: 'ok' })
      return
    }
    if (req.method !== 'POST' || req.url !== '/api/v1/snippet/execute') {
      writeJson(res, 404, { error: 'not-found' })
      return
    }
    const token = getBearerToken(req)
    let expectedToken: string
    try {
      expectedToken = await readSnippetRunnerToken()
    } catch (error) {
      writeJson(res, 500, { error: error instanceof Error ? error.message : String(error) })
      return
    }
    if (!token || !safeEqual(token, expectedToken)) {
      writeJson(res, 401, { error: 'unauthorized' })
      return
    }
    try {
      const body = await readJson(req)
      if (!isSnippetRunInvocationRequest(body)) {
        writeJson(res, 400, { error: 'invalid snippet execute request' })
        return
      }
      const request = await buildBoundSnippetRequest(body)
      const response = await executeSnippetInWorker(
        request,
        resolveTimeoutMs(request.timeoutSeconds)
      )
      writeJson(res, response.status === 'completed' ? 200 : 422, response)
    } catch (error) {
      writeJson(res, 500, { error: error instanceof Error ? error.message : String(error) })
    }
  })
}

export async function buildBoundSnippetRequest(
  invocation: SnippetRunInvocationRequest
): Promise<SnippetExecuteRequest> {
  const expectedWorkflowName = process.env.CLERUM_WORKFLOW_NAME
  if (!expectedWorkflowName) throw new Error('CLERUM_WORKFLOW_NAME is required')
  if (invocation.workflowName !== expectedWorkflowName) {
    throw new Error('snippet workflowName does not match runner binding')
  }

  const config = await loadRuntimeWorkflowConfig()
  const configName = config.recipeName ?? config.name
  if (configName !== expectedWorkflowName) {
    throw new Error('workflow config does not match runner binding')
  }
  const step = config.steps.find(item => item.id === invocation.stepId)
  if (!step?.run || step.run.type !== 'snippet') {
    throw new Error(`snippet step is not declared in workflow config: ${invocation.stepId}`)
  }
  if (invocation.timeoutSeconds !== undefined) {
    if (step.timeoutSeconds === undefined || invocation.timeoutSeconds !== step.timeoutSeconds) {
      throw new Error('snippet timeoutSeconds does not match workflow config')
    }
  }

  return {
    workflowName: expectedWorkflowName,
    stepId: invocation.stepId,
    run: step.run,
    inputs: invocation.inputs ?? config.inputs,
    previousOutputs: invocation.previousOutputs ?? {},
    ...(step.timeoutSeconds !== undefined && { timeoutSeconds: step.timeoutSeconds }),
    resolvedWorkloads: config.workloads ?? [],
    resolvedMcpServers: resolveMcpServers(config),
  }
}

async function loadRuntimeWorkflowConfig(): Promise<RuntimeWorkflowConfig> {
  const file = process.env.WORKFLOW_CONFIG_PATH ?? DEFAULT_WORKFLOW_CONFIG_PATH
  const parsed = JSON.parse(await fs.readFile(file, 'utf8')) as RuntimeWorkflowConfig
  if (!Array.isArray(parsed.steps)) throw new Error('workflow config is missing steps')
  return parsed
}

function resolveMcpServers(config: RuntimeWorkflowConfig): SnippetResolvedMcpServer[] {
  return (config.mcpServers ?? []).map(server => ({
    id: server.id,
    url: server.endpoint,
    ...(server.transport && { transport: server.transport }),
  }))
}

export function resolveTimeoutMs(timeoutSeconds?: number): number {
  if (timeoutSeconds !== undefined) {
    if (!Number.isSafeInteger(timeoutSeconds) || timeoutSeconds < 1) {
      throw new Error('snippet timeoutSeconds must be a positive safe integer')
    }
    return timeoutSeconds * 1000
  }
  const raw = process.env[SNIPPET_RUNNER_STEP_TIMEOUT_MS_ENV]
  if (raw === undefined || raw === '') return DEFAULT_SNIPPET_STEP_TIMEOUT_MS
  if (!/^\d+$/.test(raw)) {
    throw new Error(`${SNIPPET_RUNNER_STEP_TIMEOUT_MS_ENV} must be a positive safe integer`)
  }
  const value = Number.parseInt(raw, 10)
  if (!Number.isSafeInteger(value) || value < 1) {
    throw new Error(`${SNIPPET_RUNNER_STEP_TIMEOUT_MS_ENV} must be a positive safe integer`)
  }
  return value
}

if (require.main === module) {
  const port = Number.parseInt(process.env.PORT ?? `${DEFAULT_PORT}`, 10)
  const server = createSnippetRunnerServer()
  server.listen(port, () => {
    console.log(`[SnippetRunner] listening on ${port}`)
  })
}