bazilion 0.0.0 → 0.1.0

package/apps/daemon/src/runtime/worker/entry.ts

@@ -1,221 +0,0 @@
-// Subprocess entrypoint for whole-run isolation — no SQLite handle inside.
-//
-// Reads a `WorkerInput` JSON object from stdin describing the turn to run:
-// the pre-resolved agent record, enabled-provider set, and message text.
-// The daemon does all DB-backed lookups before spawning us.
-//
-// Live messaging (the `send_message` / `read_inbox` / `wait_for_reply` tools)
-// is delegated back to the daemon over Node IPC: each tool invocation sends
-// a `{type: 'rpc', ...}` message and awaits the matching reply. The parent
-// dispatches the request through its own DB-backed `MessagingHost`.
-//
-// Ownership split now reads:
-//   - daemon: SQLite handle, agent resolution, secrets envelope, scheduler,
-//     run-cancel registry, messaging RPC dispatch.
-//   - pi: conversation transcript, compaction entries, tool execution,
-//     provider retries.
-//   - this worker: glue between the two — runs `session.prompt(message)`,
-//     translates `AgentSessionEvent`s into Bazilion `SessionEvent`s, emits
-//     them as NDJSON `ChatFrame`s on stdout.
-//
-// Cancellation: SIGTERM from the parent → `session.abort()` → pi aborts the
-// current prompt → `agent_end` fires with error → translator emits an
-// `error` event so the client renders "cancelled" identically to other
-// failures.
-
-import { randomUUID } from 'node:crypto'
-import { join } from 'node:path'
-import type { ChatFrame, ResolvedAgent } from '@bazilion/api-types'
-import { resolvePaths } from '../../core/index.ts'
-import { qmdBackend } from '../memory/qmd.ts'
-import { piMessagesToProviderView, translatePiEvent } from '../pi/events.ts'
-import { createBazilionSession } from '../pi/session.ts'
-import type { IpcReply, IpcRequest, MessagingHost, RpcMethod } from './ipc-protocol.ts'
-
-interface WorkerInput {
-  agent: ResolvedAgent
-  message: string
-  enabledProviders: string[]
-  /** Pre-fetched API key for OAuth providers; undefined for env-key ones. */
-  apiKey?: string
-}
-
-function emit(frame: ChatFrame): void {
-  process.stdout.write(`${JSON.stringify(frame)}\n`)
-}
-
-async function readInput(): Promise<WorkerInput> {
-  const chunks: Buffer[] = []
-  for await (const c of process.stdin) chunks.push(c as Buffer)
-  const raw = Buffer.concat(chunks).toString('utf8').trim()
-  if (!raw) throw new Error('worker: empty stdin input')
-  const parsed = JSON.parse(raw) as WorkerInput
-  if (
-    !parsed.agent ||
-    typeof parsed.message !== 'string' ||
-    !Array.isArray(parsed.enabledProviders)
-  ) {
-    throw new Error('worker: stdin must be {agent, message, enabledProviders}')
-  }
-  return parsed
-}
-
-/**
- * Build a `MessagingHost` that proxies every method through the IPC channel
- * back to the parent. Each call gets a fresh correlation id and waits for the
- * matching `rpc-reply`. The promise rejects when the channel disconnects mid-
- * request — that path only fires during shutdown, where the LLM loop has
- * already been aborted, so the unresolved tool call doesn't matter.
- */
-function createIpcMessagingHost(): MessagingHost {
-  type Pending = { resolve: (value: unknown) => void; reject: (err: Error) => void }
-  const pending = new Map<string, Pending>()
-
-  process.on('message', (msg: unknown) => {
-    if (!isIpcReply(msg)) return
-    const entry = pending.get(msg.id)
-    if (!entry) return
-    pending.delete(msg.id)
-    if (msg.ok) entry.resolve(msg.result)
-    else entry.reject(new Error(msg.error))
-  })
-
-  process.on('disconnect', () => {
-    for (const [, entry] of pending) entry.reject(new Error('worker IPC channel disconnected'))
-    pending.clear()
-  })
-
-  function call<T>(method: RpcMethod, args: unknown): Promise<T> {
-    if (!process.send) {
-      return Promise.reject(new Error('worker: no IPC channel — daemon must spawn with stdio:ipc'))
-    }
-    const id = randomUUID()
-    // The wire format is uniform "method + args"; the parent's dispatcher
-    // re-narrows on `method`. TS can't follow that union construction here,
-    // so we cast through unknown rather than push the discrimination through
-    // every call site.
-    const message = { type: 'rpc', id, method, args } as unknown as IpcRequest
-    return new Promise<T>((resolve, reject) => {
-      pending.set(id, {
-        resolve: (v) => resolve(v as T),
-        reject,
-      })
-      // process.send is fire-and-forget; the callback only signals serialization
-      // failure. Treat it as a reject to surface the bug rather than hang.
-      process.send?.(message, undefined, undefined, (err) => {
-        if (err) {
-          pending.delete(id)
-          reject(err)
-        }
-      })
-    })
-  }
-
-  return {
-    agentExists: (agentId) => call<boolean>('agentExists', { agentId }),
-    sendMessage: (input) => call<{ messageId: string }>('sendMessage', input),
-    listInbox: (agentId, opts) => call('listInbox', { agentId, unreadOnly: opts.unreadOnly }),
-    markRead: async (messageId) => {
-      await call<null>('markRead', { messageId })
-    },
-    findReplies: (agentId, replyTo) => call('findReplies', { agentId, replyTo }),
-  }
-}
-
-function isIpcReply(msg: unknown): msg is IpcReply {
-  if (!msg || typeof msg !== 'object') return false
-  const m = msg as Record<string, unknown>
-  return m.type === 'rpc-reply' && typeof m.id === 'string' && typeof m.ok === 'boolean'
-}
-
-async function main(): Promise<void> {
-  // Install signal handlers FIRST so a SIGTERM that arrives during setup
-  // doesn't kill us with the Node default (exit-by-signal, no frame emitted).
-  // Pre-session, we just exit cleanly with a synthetic `cancelled` event;
-  // post-session, we delegate to `session.abort()` so pi unwinds the
-  // provider fetch and surfaces its own `error` event.
-  let aborted = false
-  let abortSession: (() => void) | null = null
-  const onSignal = (): void => {
-    aborted = true
-    if (abortSession) {
-      abortSession()
-    } else {
-      try {
-        emit({ kind: 'event', event: { type: 'error', error: 'cancelled' } })
-      } catch {}
-      process.exit(0)
-    }
-  }
-  process.on('SIGTERM', onSignal)
-  process.on('SIGINT', onSignal)
-
-  const { agent, message, enabledProviders, apiKey } = await readInput()
-
-  // Path resolution still happens in the worker — `resolvePaths()` only reads
-  // the `BAZILION_HOME` env var the daemon hands down. No DB, no filesystem
-  // probe of the live tree.
-  const paths = resolvePaths()
-
-  const memory = qmdBackend(join(agent.group.path, 'memory'))
-  await memory.init()
-
-  const messagingHost = createIpcMessagingHost()
-
-  const { session, dispose } = await createBazilionSession({
-    agent,
-    paths,
-    env: process.env,
-    memory,
-    enabledProviders: new Set(enabledProviders),
-    messagingHost,
-    apiKey,
-  })
-
-  abortSession = (): void => {
-    void session.abort()
-  }
-
-  const unsubscribe = session.subscribe((piEvent) => {
-    for (const ev of translatePiEvent(piEvent)) {
-      emit({ kind: 'event', event: ev })
-    }
-  })
-
-  try {
-    await session.prompt(message)
-    await session.agent.waitForIdle()
-
-    emit({
-      kind: 'done',
-      messages: piMessagesToProviderView(session.agent.state.messages),
-    })
-  } catch (err) {
-    if (!aborted) {
-      emit({ kind: 'event', event: { type: 'error', error: (err as Error).message } })
-    }
-    emit({ kind: 'fatal', error: (err as Error).message })
-    process.exitCode = 1
-  } finally {
-    unsubscribe()
-    process.off('SIGTERM', onSignal)
-    process.off('SIGINT', onSignal)
-    dispose()
-    // Detach from the parent's IPC channel so the worker's event loop can
-    // exit. `process.on('message', …)` registered above otherwise keeps
-    // the loop alive even after the turn finishes — Node treats an open
-    // IPC handle as a live ref the same way it treats an open socket.
-    try {
-      process.disconnect?.()
-    } catch {
-      // already disconnected (parent closed first) — fine
-    }
-  }
-}
-
-main().catch((err) => {
-  try {
-    emit({ kind: 'fatal', error: (err as Error)?.message ?? String(err) })
-  } catch {}
-  process.exit(1)
-})

package/apps/daemon/src/runtime/worker/ipc-protocol.ts

@@ -1,75 +0,0 @@
-// Worker ↔ daemon IPC protocol.
-//
-// The daemon is the single owner of `~/.bazilion`. Worker subprocesses run
-// agent turns without their own SQLite handle: anything that needs DB access
-// during a turn (currently the `send_message` / `read_inbox` /
-// `wait_for_reply` tools) is delegated to the parent over Node's built-in
-// `process.send` / `child.send` IPC channel (set up via `stdio: 'ipc'`).
-//
-// Wire format: one JSON object per `send`, with a stable `type` discriminator
-// and a correlation `id` for matching replies. The shape stays narrow on
-// purpose — only the messaging tools talk over IPC. Agent resolution,
-// provider gate, and merged env are pre-computed in the daemon and handed to
-// the worker on stdin (see `WorkerInput` in `worker/entry.ts`).
-
-import type { Message } from '@bazilion/api-types'
-
-export type RpcMethod = 'agentExists' | 'sendMessage' | 'listInbox' | 'markRead' | 'findReplies'
-
-export interface AgentExistsArgs {
-  agentId: string
-}
-
-export interface SendMessageArgs {
-  from: string
-  to: string
-  payload: string
-  replyTo: string | null
-}
-
-export interface ListInboxArgs {
-  agentId: string
-  unreadOnly: boolean
-}
-
-export interface MarkReadArgs {
-  messageId: string
-}
-
-export interface FindRepliesArgs {
-  agentId: string
-  replyTo: string
-}
-
-export type RpcArgs =
-  | { method: 'agentExists'; args: AgentExistsArgs }
-  | { method: 'sendMessage'; args: SendMessageArgs }
-  | { method: 'listInbox'; args: ListInboxArgs }
-  | { method: 'markRead'; args: MarkReadArgs }
-  | { method: 'findReplies'; args: FindRepliesArgs }
-
-export type RpcResult =
-  | { method: 'agentExists'; value: boolean }
-  | { method: 'sendMessage'; value: { messageId: string } }
-  | { method: 'listInbox'; value: Message[] }
-  | { method: 'markRead'; value: null }
-  | { method: 'findReplies'; value: Message[] }
-
-export type IpcRequest = { type: 'rpc'; id: string } & RpcArgs
-
-export type IpcReply =
-  | { type: 'rpc-reply'; id: string; ok: true; result: unknown }
-  | { type: 'rpc-reply'; id: string; ok: false; error: string }
-
-/**
- * The host-side surface the worker delegates messaging operations to. The
- * daemon implements this against `messageRepo` / `agentRepo`; tests can
- * provide an in-memory shim.
- */
-export interface MessagingHost {
-  agentExists(agentId: string): boolean | Promise<boolean>
-  sendMessage(input: SendMessageArgs): { messageId: string } | Promise<{ messageId: string }>
-  listInbox(agentId: string, opts: { unreadOnly: boolean }): Message[] | Promise<Message[]>
-  markRead(messageId: string): void | Promise<void>
-  findReplies(agentId: string, replyTo: string): Message[] | Promise<Message[]>
-}

package/apps/daemon/src/runtime/worker/spawn.ts

@@ -1,249 +0,0 @@
-// Parent-side spawn helper for whole-run subprocess isolation.
-//
-// `spawnWorkerTurn` launches `./entry.ts` and feeds it a `WorkerInput` JSON
-// blob on stdin describing the turn to run (pre-resolved agent record,
-// enabled-provider set, message text). The worker no longer opens its own
-// SQLite handle — the daemon is the sole owner of `~/.bazilion`.
-//
-// Two channels run between parent and child:
-//   - stdout (NDJSON): the worker emits `ChatFrame`s; we line-parse and
-//     yield each one to the caller.
-//   - IPC (Node `stdio: 'ipc'`): the worker calls back into the parent for
-//     anything that needs DB access during the turn (today: the messaging
-//     tools `send_message` / `read_inbox` / `wait_for_reply`). We dispatch
-//     each `IpcRequest` through the injected `MessagingHost` and reply with
-//     `child.send`.
-//
-// Cancellation: wire an AbortSignal via `opts.signal`. On abort we send
-// SIGTERM to the child — the child has a signal handler that calls
-// `session.abort()`, which aborts the provider fetch and surfaces a final
-// `error` SessionEvent before the worker exits cleanly. If the child doesn't
-// exit within `killGraceMs`, we SIGKILL it.
-
-import { type ChildProcess, spawn } from 'node:child_process'
-import { createRequire } from 'node:module'
-import { fileURLToPath, pathToFileURL } from 'node:url'
-import type { ChatFrame, ResolvedAgent } from '@bazilion/api-types'
-import type { IpcReply, IpcRequest, MessagingHost } from './ipc-protocol.ts'
-
-const DEFAULT_KILL_GRACE_MS = 3_000
-
-const entryPath = fileURLToPath(new URL('./entry.ts', import.meta.url))
-
-// Node 22.12+ (the project's minimum) runs `.ts` files directly via
-// `--experimental-strip-types`, which just strips type annotations without
-// any transform / loader plumbing. We prefer it over tsx for worker spawns
-// because it shaves ~1s off the subprocess boot (no tsx module to resolve,
-// no TypeScript compiler to initialize per turn). tsx remains available as
-// a fallback for environments where strip-types is disabled — detected at
-// spawn time by probing `process.features.typescript`.
-//
-// `--no-warnings` silences Node's "ExperimentalWarning: Type Stripping"
-// banner that would otherwise appear on every child start.
-function workerSpawnArgs(): string[] {
-  // `process.features.typescript` is 'strip' on builds where strip-types is
-  // enabled, 'transform' on nightly/experimental, undefined otherwise. Cast
-  // through unknown because the typing of ProcessFeatures doesn't yet
-  // include this field in our @types/node.
-  const tsFeature = (process.features as unknown as Record<string, unknown>).typescript
-  if (typeof tsFeature === 'string' || tsFeature === true) {
-    return ['--experimental-strip-types', '--no-warnings', entryPath]
-  }
-  return ['--import', tsxImportSpecifier(), entryPath]
-}
-
-let cachedTsxImport: string | null = null
-function tsxImportSpecifier(): string {
-  if (cachedTsxImport) return cachedTsxImport
-  // `require.resolve('tsx')` returns the absolute path to tsx's loader.mjs —
-  // the ESM module that hooks the runtime. Passing it to `node --import` as a
-  // file:// URL is the most portable way to activate tsx in a subprocess: it
-  // avoids CWD-sensitive bare-specifier resolution, and works regardless of
-  // where the caller lives in a pnpm-hoisted workspace.
-  const req = createRequire(import.meta.url)
-  cachedTsxImport = pathToFileURL(req.resolve('tsx')).href
-  return cachedTsxImport
-}
-
-export interface WorkerTurnSpec {
-  /** Pre-resolved agent record — the worker never queries the DB itself. */
-  agent: ResolvedAgent
-  /** First user-message text for this turn. */
-  message: string
-  /**
-   * Names of providers the user has enabled in /config. Empty array means
-   * no per-provider gating configured (all providers pass).
-   */
-  enabledProviders: string[]
-  /**
-   * Pre-fetched API key for the agent's provider. Required for OAuth-backed
-   * providers (`openai-codex`) — the worker has no DB handle to read the
-   * secrets table itself. Omit for env-key providers; `pi/session.ts` then
-   * derives the key from `process.env`.
-   */
-  apiKey?: string
-}
-
-export interface SpawnWorkerOpts {
-  /** Abort to kill the in-flight worker. */
-  signal?: AbortSignal
-  /** ms between SIGTERM and fallback SIGKILL (default 3000). */
-  killGraceMs?: number
-  /** Override env passed to the child. Defaults to `process.env`. */
-  env?: NodeJS.ProcessEnv
-  /**
-   * Daemon-side implementation of the messaging tools the worker calls back
-   * into via IPC. Omit only when the caller knows the agent will not invoke
-   * any of `send_message` / `read_inbox` / `wait_for_reply` — passing it
-   * costs nothing for turns that don't use messaging.
-   */
-  messagingHost?: MessagingHost
-}
-
-export async function* spawnWorkerTurn(
-  spec: WorkerTurnSpec,
-  opts: SpawnWorkerOpts = {},
-): AsyncGenerator<ChatFrame, void, void> {
-  const child = spawn(process.execPath, workerSpawnArgs(), {
-    env: opts.env ?? process.env,
-    stdio: ['pipe', 'pipe', 'inherit', 'ipc'],
-  })
-
-  if (opts.messagingHost) attachIpcHandler(child, opts.messagingHost)
-
-  child.stdin?.write(JSON.stringify(spec))
-  child.stdin?.end()
-
-  const grace = opts.killGraceMs ?? DEFAULT_KILL_GRACE_MS
-  let killTimer: NodeJS.Timeout | null = null
-  const onAbort = (): void => {
-    if (child.exitCode !== null || child.signalCode !== null) return
-    try {
-      child.kill('SIGTERM')
-    } catch {
-      // process may have already exited between our check and the kill
-    }
-    killTimer = setTimeout(() => {
-      if (child.exitCode === null && child.signalCode === null) {
-        try {
-          child.kill('SIGKILL')
-        } catch {}
-      }
-    }, grace)
-    killTimer.unref()
-  }
-  if (opts.signal?.aborted) onAbort()
-  else opts.signal?.addEventListener('abort', onAbort)
-
-  const waitForExit: Promise<{ code: number | null; signal: NodeJS.Signals | null }> = new Promise(
-    (resolve) => {
-      if (child.exitCode !== null || child.signalCode !== null) {
-        resolve({ code: child.exitCode, signal: child.signalCode })
-        return
-      }
-      child.once('close', (code, signal) => resolve({ code, signal }))
-    },
-  )
-
-  let emittedFatal = false
-
-  try {
-    let buf = ''
-    if (!child.stdout) throw new Error('worker spawn: stdout pipe missing')
-    for await (const chunk of child.stdout) {
-      buf += (chunk as Buffer).toString('utf8')
-      let idx = buf.indexOf('\n')
-      while (idx !== -1) {
-        const line = buf.slice(0, idx)
-        buf = buf.slice(idx + 1)
-        if (line.trim()) {
-          const frame = parseFrame(line)
-          if (frame.kind === 'fatal') emittedFatal = true
-          yield frame
-        }
-        idx = buf.indexOf('\n')
-      }
-    }
-    if (buf.trim()) {
-      const frame = parseFrame(buf)
-      if (frame.kind === 'fatal') emittedFatal = true
-      yield frame
-    }
-
-    const exit = await waitForExit
-    // Child exited without emitting a fatal frame but with non-zero status —
-    // surface that so the caller doesn't silently swallow a crash. Cancelled
-    // turns produce an `error` SessionEvent via the worker's signal handler
-    // and exit cleanly with code 0; only truly unexpected exits hit this.
-    if (!emittedFatal && exit.code !== 0 && exit.code !== null) {
-      yield {
-        kind: 'fatal',
-        error: `worker exited with code ${exit.code}${exit.signal ? ` (${exit.signal})` : ''}`,
-      }
-    } else if (!emittedFatal && exit.signal && exit.code === null) {
-      yield { kind: 'fatal', error: `worker killed by ${exit.signal}` }
-    }
-  } finally {
-    opts.signal?.removeEventListener('abort', onAbort)
-    if (killTimer) clearTimeout(killTimer)
-    try {
-      child.disconnect()
-    } catch {
-      // already disconnected (child closed first) — fine
-    }
-  }
-}
-
-function parseFrame(line: string): ChatFrame {
-  try {
-    return JSON.parse(line) as ChatFrame
-  } catch {
-    return { kind: 'fatal', error: `worker emitted malformed frame: ${line.slice(0, 200)}` }
-  }
-}
-
-function attachIpcHandler(child: ChildProcess, host: MessagingHost): void {
-  child.on('message', (msg: unknown) => {
-    if (!isIpcRequest(msg)) return
-    void dispatch(msg, host).then((reply) => {
-      try {
-        child.send?.(reply)
-      } catch {
-        // child may have exited between request and reply — drop silently
-      }
-    })
-  })
-}
-
-function isIpcRequest(msg: unknown): msg is IpcRequest {
-  if (!msg || typeof msg !== 'object') return false
-  const m = msg as Record<string, unknown>
-  return m.type === 'rpc' && typeof m.id === 'string' && typeof m.method === 'string'
-}
-
-async function dispatch(req: IpcRequest, host: MessagingHost): Promise<IpcReply> {
-  try {
-    let result: unknown
-    switch (req.method) {
-      case 'agentExists':
-        result = await host.agentExists(req.args.agentId)
-        break
-      case 'sendMessage':
-        result = await host.sendMessage(req.args)
-        break
-      case 'listInbox':
-        result = await host.listInbox(req.args.agentId, { unreadOnly: req.args.unreadOnly })
-        break
-      case 'markRead':
-        await host.markRead(req.args.messageId)
-        result = null
-        break
-      case 'findReplies':
-        result = await host.findReplies(req.args.agentId, req.args.replyTo)
-        break
-    }
-    return { type: 'rpc-reply', id: req.id, ok: true, result }
-  } catch (err) {
-    return { type: 'rpc-reply', id: req.id, ok: false, error: (err as Error).message }
-  }
-}