Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

4.6 KB
Raw Blame
import { randomBytes } from 'node:crypto'
import { openLocalWs } from '../lib/localTransport.js'
import { WebSocket } from 'ws'
import { env } from '../config/env.js'
import { readAuthSession } from '../lib/authSession.js'

export function localOrchestratorRequest(port: number, machineId: string, payload: Record<string, unknown>, timeoutMs = 30_000): Promise<Record<string, unknown>> {
  return new Promise((resolve, reject) => {
    const requestId = randomBytes(16).toString('hex')
    const ws = openLocalWs(env.ADAPTER_DATA_DIR, port, (url, headers) => new WebSocket(url, { headers }))
    let settled = false
    const finish = (error?: Error, reply?: Record<string, unknown>): void => {
      if (settled) return
      settled = true
      clearTimeout(timer)
      ws.close()
      if (error) reject(error); else resolve(reply!)
    }
    const timer = setTimeout(() => finish(new Error('The daemon did not confirm this operation. Check status before retrying.')), timeoutMs)
    ws.on('open', () => ws.send(JSON.stringify({ type: 'machine_select', payload: { machineId, localProtocolVersion: 1 } })))
    ws.on('error', error => finish(error))
    ws.on('close', () => finish(new Error('The local daemon disconnected. Check status before retrying.')))
    ws.on('message', raw => {
      try {
        const frame = JSON.parse(raw.toString())
        if (frame.type === 'connected') ws.send(JSON.stringify({ type: 'orchestrator', payload: { ...payload, requestId } }))
        if (frame.type === 'orchestrator_result' && frame.payload?.requestId === requestId) finish(undefined, frame.payload)
      } catch { finish(new Error('The local daemon returned an invalid response.')) }
    })
  })
}

export function parseOrchestratorArgs(argv: readonly string[]): { port: number; machineId: string; payload: Record<string, unknown> } {
  const args: string[] = []
  let port = env.PORT, machineId = readAuthSession()?.machineId ?? ''
  for (let i = 0; i < argv.length; i++) {
    if (argv[i] === '--port') port = Number(argv[++i])
    else if (argv[i] === '--machine') machineId = argv[++i] ?? ''
    else args.push(argv[i])
  }
  if (!Number.isInteger(port) || port < 1 || port > 65535 || !machineId) throw new Error('A running local daemon and machine identity are required (--port, --machine).')
  const [action, id, ...rest] = args
  const payload: Record<string, unknown> = { action, id }
  switch (action) {
    case 'list': case 'catalog': case 'status': case 'resume': break
    case 'plan': payload.tasks = JSON.parse(rest[0] ?? 'null'); break
    case 'retry': case 'cancel': if (rest[0]) payload.taskId = rest[0]; break
    case 'finish': case 'fail':
      Object.assign(payload, { taskId: rest[0], attempt: Number(rest[1]), summary: rest[2], artifacts: rest.slice(3) }); break
    case 'complete': payload.summary = rest[0]; break
    case 'message': Object.assign(payload, { text: rest[0], messageId: rest[1] ?? randomBytes(16).toString('hex') }); break
    case 'steer': Object.assign(payload, { taskId: rest[0], attempt: Number(rest[1]), text: rest[2], messageId: rest[3] ?? randomBytes(16).toString('hex') }); break
    default: throw new Error('Usage: harness orchestrator [--port N --machine ID] list|catalog|status|plan|finish|fail|retry|cancel|resume|complete|message|steer [project-id] [arguments]')
  }
  return { port, machineId, payload }
}
export async function orchestratorCommand(argv: readonly string[]): Promise<number> {
  try {
    const { port, machineId, payload } = parseOrchestratorArgs(argv)
    const reply = await localOrchestratorRequest(port, machineId, payload)
    console.log(JSON.stringify(summarizeOrchestratorReply(reply), null, 2))
    return reply.error ? 1 : 0
  } catch (error) {
    console.error(error instanceof Error ? error.message : 'Orchestrator request failed.')
    return 1
  }
}

/** Tool output is a work ledger, not a repeated copy of the director's whole
 * conversation and every specialist brief. The UI still receives full state. */
export function summarizeOrchestratorReply(reply: Record<string, unknown>): Record<string, unknown> {
  if (!reply.project || typeof reply.project !== 'object' || Array.isArray(reply.project)) return reply
  const { fingerprint: _fingerprint, messages, tasks, ...project } = reply.project as Record<string, unknown>
  return { ...reply, project: {
    ...project,
    tasks: Array.isArray(tasks) ? tasks.map(({ prompt: _prompt, ...task }) => task) : [],
    deliveries: Array.isArray(messages) ? messages.filter(m => m.delivery).slice(-20).map(m => ({
      id: m.id, targetAgentId: m.targetAgentId, delivery: m.delivery,
      deliveryReason: m.deliveryReason, text: String(m.text).slice(0, 160),
    })) : [],
  } }
}