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.

2.7 KB
Raw Blame
/**
 * Provisioning RPC over the manager socket (Phase 3) — replaces the backend→manager control HTTP
 * (`lib/manager.ts` create/destroy), so the backend no longer needs `Manager.publicHost`.
 *
 * Flow (works across backend instances behind a LB): the requesting backend publishes the command to
 * `mgr:{managerId}` and waits on `mgrreply:{requestId}`. Whichever backend holds a socket to that
 * manager (subscribed in managerWs) forwards it over the socket; the manager runs it and replies, which
 * that backend republishes to `mgrreply:{requestId}`. The manager op is idempotent on machineId, so if
 * multiple cluster sockets forward it, the duplicate simply errors and the first reply wins.
 */
import { randomUUID } from 'crypto'
import { publishMgr, subscribeReply } from './bus.js'

const PROVISION_TIMEOUT_MS = 60_000

/** No reply arrived before the deadline — the manager op's outcome is UNKNOWN (it may still be
 *  running / the container may still come up). Callers that fire-and-forget a `create` use this to
 *  avoid rolling back a binding whose container might yet register. A definitive failure (manager
 *  replied `ok:false`) rejects with a plain Error instead. */
export class ProvisionTimeoutError extends Error {
  readonly code = 'TIMEOUT' as const
  constructor(message: string) {
    super(message)
    this.name = 'ProvisionTimeoutError'
  }
}

export function provisionViaManager(
  managerId: string,
  cmd: 'create' | 'start' | 'stop' | 'destroy' | 'app_create' | 'app_delete',
  payload: Record<string, unknown>,
): Promise<unknown> {
  const requestId = randomUUID()
  return new Promise<unknown>((resolve, reject) => {
    let done = false
    let unsub: (() => void) | null = null
    const finish = (fn: () => void): void => {
      if (done) return
      done = true
      if (unsub) unsub()
      clearTimeout(timer)
      fn()
    }
    // Cold-start can include Docker boot + agent health + restoring a deployed app port.
    const timeoutMs = cmd === 'start' ? 125_000 : PROVISION_TIMEOUT_MS
    const timer = setTimeout(
      () => finish(() => reject(new ProvisionTimeoutError(`provision ${cmd} timed out (manager ${managerId} unreachable)`))),
      timeoutMs,
    )
    void subscribeReply(requestId, (msg) => {
      const r = msg as { ok?: boolean; data?: unknown; error?: string }
      finish(() => (r?.ok ? resolve(r.data) : reject(new Error(r?.error || 'provision failed'))))
    })
      .then((u) => {
        if (done) { u(); return }
        unsub = u
        void publishMgr(managerId, { requestId, cmd, payload })
          .catch((err) => finish(() => reject(err instanceof Error ? err : new Error(String(err)))))
      })
      .catch((err) => finish(() => reject(err instanceof Error ? err : new Error(String(err)))))
  })
}