bazilion 0.0.0

package/apps/daemon/src/lib/agent-turn.ts

@@ -0,0 +1,56 @@
+import type { ChatFrame } from '@bazilion/api-types'
+import { mergeSecretsIntoEnv, providerStateRepo, resolveAgent } from '../core/index.ts'
+import { spawnWorkerTurn } from '../runtime/index.ts'
+import { registerAgent, unregisterAgent } from './agent-cancel.ts'
+import { resolveAgentApiKey } from './api-key.ts'
+import { getCtx } from './ctx.ts'
+import { createDbMessagingHost } from './messaging-host.ts'
+
+interface RunAgentTurnOpts {
+  /** If omitted, a fresh AbortController is created internally. */
+  controller?: AbortController
+}
+
+/**
+ * Runs one full agent turn in an isolated subprocess, streaming `ChatFrame`s
+ * in NDJSON-ready order. The heavy lifting (provider calls, tool execution,
+ * pi session journal append) happens inside the child; this function is a
+ * thin relay that:
+ *   - resolves the agent + provider gate + secrets envelope here in the
+ *     daemon (the worker no longer holds a SQLite handle of its own),
+ *   - spawns the worker with an IPC channel and a `MessagingHost` that
+ *     services the inter-agent messaging tools the worker calls back into,
+ *   - forwards stdout frames to the caller and wires cancellation through
+ *     the agent-cancel registry.
+ */
+export async function* runAgentTurn(
+  agentId: string,
+  message: string,
+  opts: RunAgentTurnOpts = {},
+): AsyncGenerator<ChatFrame> {
+  const { db, paths, authToken } = getCtx()
+  const agent = resolveAgent(db, paths, agentId)
+  const enabledProviders = Array.from(providerStateRepo.listEnabled(db))
+  const env = mergeSecretsIntoEnv(db, authToken)
+  const messagingHost = createDbMessagingHost(db)
+  // Pre-fetch the API key for OAuth providers (`openai-codex`) before the
+  // worker spawns — the worker has no DB handle, so it can't reach the
+  // secrets table itself. For env-key providers this is a no-op (`{}`).
+  // Refresher is intentionally skipped: the worker has no IPC channel for
+  // OAuth refresh today, and the initial token comfortably outlives a
+  // single turn for ChatGPT-backed sessions.
+  const { apiKey } = await resolveAgentApiKey(db, authToken, agent)
+
+  const controller = opts.controller ?? new AbortController()
+  registerAgent(agentId, controller)
+  try {
+    for await (const frame of spawnWorkerTurn(
+      { agent, message, enabledProviders, apiKey },
+      { signal: controller.signal, env, messagingHost },
+    )) {
+      yield frame
+    }
+  } finally {
+    unregisterAgent(agentId)
+  }
+}

package/apps/daemon/src/lib/api-key.ts

@@ -0,0 +1,56 @@
+// Resolves the API key (and refresher) for an agent's provider. Centralizes
+// the OAuth special case for `openai-codex` — its access token lives in the
+// daemon-owned `secrets` table, not in env vars, so callers can't pluck it
+// from the merged env the way they can for plain API-key providers.
+
+import type { ResolvedAgent } from '@bazilion/api-types'
+import type { BazilionDb } from '../core/index.ts'
+import { hasOpenAICodexCredentials, loadOpenAICodexAccessToken } from '../runtime/index.ts'
+
+export interface AgentApiKey {
+  /** Initial access token / API key. Undefined when the env layer carries it. */
+  apiKey?: string
+  /**
+   * Optional refresher pi calls during long tool-execution loops to swap an
+   * expired JWT for a fresh one. Only set for OAuth providers — daemon-side
+   * sessions wire this; worker turns currently rely on the initial token
+   * carrying the whole turn (subsecond-to-minutes) since they have no DB
+   * handle to refresh against.
+   */
+  refreshApiKey?: (providerName: string) => Promise<string>
+}
+
+/**
+ * Pre-fetch the API key for `agent`'s provider. Returns `{}` when the
+ * provider is env-key-based (the merged env passed to the session already
+ * carries the value). For `openai-codex`, throws a friendly error when the
+ * user hasn't connected their ChatGPT account yet — that surfaces in the
+ * chat UI as a clear "go to /config" message rather than pi's generic
+ * "no API key" complaint.
+ */
+export async function resolveAgentApiKey(
+  db: BazilionDb,
+  authToken: string,
+  agent: ResolvedAgent,
+  opts: { withRefresher?: boolean } = {},
+): Promise<AgentApiKey> {
+  const providerName = agent.model.split(':', 1)[0] ?? ''
+  if (providerName !== 'openai-codex') return {}
+
+  if (!hasOpenAICodexCredentials(db, authToken)) {
+    throw new Error(
+      'openai-codex is not connected — run `bazilion auth openai login` or click Connect on /config',
+    )
+  }
+  const apiKey = await loadOpenAICodexAccessToken(db, authToken)
+  if (!opts.withRefresher) return { apiKey }
+  return {
+    apiKey,
+    refreshApiKey: async (requestedProvider) => {
+      if (requestedProvider !== 'openai-codex') {
+        throw new Error(`unexpected refresh request for ${requestedProvider}`)
+      }
+      return loadOpenAICodexAccessToken(db, authToken)
+    },
+  }
+}

package/apps/daemon/src/lib/auth.ts

@@ -0,0 +1,41 @@
+// Token verification primitives — framework-agnostic. The Hono auth middleware
+// (lib/middleware-auth.ts) wraps these; native clients (CLI, mobile) pass the
+// same token via `Authorization: Bearer …`, and browsers send the httpOnly
+// `bz_token` cookie minted by `POST /api/login`.
+//
+// All tokens — including the bootstrap one minted by the daemon's first-run
+// bootstrap — live as hashed rows in the `web_tokens` table. The bootstrap
+// row's plaintext is exposed in `~/.bazilion/auth.json` so the daemon (PBKDF2
+// seed for the secrets table) and the CLI (loopback bearer) can use it.
+// Validation goes through `findActiveByToken`, no special-case loopback path.
+
+import { webTokenRepo } from '../core/index.ts'
+import { getCtx } from './ctx.ts'
+
+/**
+ * Is this string a currently-valid token? Accepts any active (non-revoked)
+ * row in `web_tokens` — including the bootstrap row written by the daemon's
+ * first-run bootstrap. Bumps `last_used_at` on a match so operators can see
+ * idle vs active tokens in `token list`.
+ */
+export function isValidToken(token: string): boolean {
+  try {
+    const { db } = getCtx()
+    const match = webTokenRepo.findActiveByToken(db, token)
+    if (match) {
+      webTokenRepo.markUsed(db, match.id)
+      return true
+    }
+  } catch {
+    // db unavailable — treat as unauthenticated
+  }
+  return false
+}
+
+/** Pull the bearer token out of an `Authorization: Bearer …` header. */
+export function extractBearer(authHeader: string | null | undefined): string | null {
+  if (!authHeader) return null
+  // RFC 6750 auth scheme is case-insensitive.
+  const match = /^\s*Bearer\s+(.+?)\s*$/i.exec(authHeader)
+  return match?.[1] ?? null
+}

package/apps/daemon/src/lib/cron.ts

@@ -0,0 +1,93 @@
+// Minimal 5-field cron matcher: "minute hour day-of-month month day-of-week".
+// Supports *, */N, N, N-M, and comma-separated lists thereof per field.
+// Day-of-week: 0 or 7 = Sunday, 1 = Monday ... 6 = Saturday.
+//
+// Matching semantics match the "standard" cron (non-Vixie) rule: if BOTH
+// day-of-month and day-of-week are restricted (i.e. not `*`), the match is an
+// OR — the trigger fires when either matches. Most common expressions are
+// `*/5 * * * *` or `0 9 * * *` where only one of the two is restricted, so
+// the subtlety rarely matters.
+
+function parseField(raw: string, min: number, max: number): Set<number> {
+  const values = new Set<number>()
+  for (const part of raw.split(',')) {
+    const [rangePart, stepPart] = part.split('/')
+    const step = stepPart === undefined ? 1 : Number(stepPart)
+    if (!Number.isInteger(step) || step < 1) {
+      throw new Error(`invalid step "${stepPart}"`)
+    }
+    let lo: number
+    let hi: number
+    if (rangePart === '*' || rangePart === undefined) {
+      lo = min
+      hi = max
+    } else if (rangePart.includes('-')) {
+      const [a, b] = rangePart.split('-').map((n) => Number(n))
+      if (!Number.isInteger(a) || !Number.isInteger(b)) {
+        throw new Error(`invalid range "${rangePart}"`)
+      }
+      lo = a as number
+      hi = b as number
+    } else {
+      const n = Number(rangePart)
+      if (!Number.isInteger(n)) {
+        throw new Error(`invalid value "${rangePart}"`)
+      }
+      lo = n
+      hi = n
+    }
+    if (lo < min || hi > max || lo > hi) {
+      throw new Error(`value out of range ${min}-${max}: "${part}"`)
+    }
+    for (let v = lo; v <= hi; v += step) values.add(v)
+  }
+  return values
+}
+
+export interface ParsedCron {
+  minute: Set<number>
+  hour: Set<number>
+  dom: Set<number>
+  month: Set<number>
+  dow: Set<number>
+  domRestricted: boolean
+  dowRestricted: boolean
+}
+
+export function parseCron(expr: string): ParsedCron {
+  const parts = expr.trim().split(/\s+/)
+  if (parts.length !== 5) {
+    throw new Error(`expected 5 fields, got ${parts.length}: "${expr}"`)
+  }
+  const [m, h, dom, mon, dow] = parts as [string, string, string, string, string]
+  const parsed: ParsedCron = {
+    minute: parseField(m, 0, 59),
+    hour: parseField(h, 0, 23),
+    dom: parseField(dom, 1, 31),
+    month: parseField(mon, 1, 12),
+    // accept 7 as Sunday alias → normalise to 0
+    dow: new Set([...parseField(dow.replace(/7/g, '0'), 0, 6)]),
+    domRestricted: dom !== '*',
+    dowRestricted: dow !== '*',
+  }
+  return parsed
+}
+
+export function matchesCron(parsed: ParsedCron, date: Date): boolean {
+  if (!parsed.minute.has(date.getMinutes())) return false
+  if (!parsed.hour.has(date.getHours())) return false
+  if (!parsed.month.has(date.getMonth() + 1)) return false
+  const domMatch = parsed.dom.has(date.getDate())
+  const dowMatch = parsed.dow.has(date.getDay())
+  if (parsed.domRestricted && parsed.dowRestricted) {
+    return domMatch || dowMatch
+  }
+  if (parsed.domRestricted) return domMatch
+  if (parsed.dowRestricted) return dowMatch
+  return true
+}
+
+/** Validates an expression — throws on syntax errors. Used by API write paths. */
+export function validateCron(expr: string): void {
+  parseCron(expr)
+}

package/apps/daemon/src/lib/ctx.ts

@@ -0,0 +1,80 @@
+import { chmodSync, existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import {
+  type BazilionDb,
+  openDb,
+  type Paths,
+  readAuthFile,
+  resolvePaths,
+  runMigrations,
+  webTokenRepo,
+} from '../core/index.ts'
+import { startScheduler } from './scheduler.ts'
+
+let _db: BazilionDb | null = null
+let _paths: Paths | null = null
+let _authToken: string | null = null
+let _schedulerStarted = false
+
+export interface DaemonCtx {
+  db: BazilionDb
+  paths: Paths
+  /**
+   * Plaintext bootstrap token from `auth.json`. Used to derive the encryption
+   * key for the `secrets` table — `mergeSecretsIntoEnv(db, ctx.authToken)`.
+   * Cached for the process lifetime; if the user rotates the token, the
+   * daemon must restart to pick it up.
+   */
+  authToken: string
+}
+
+/**
+ * One-shot first-run bootstrap. Idempotent: every step skips itself when its
+ * artifact already exists. Mints the bootstrap web_tokens row + writes the
+ * plaintext into auth.json the first time we see no auth file.
+ */
+function bootstrap(paths: Paths): { db: BazilionDb; authToken: string } {
+  for (const d of [
+    paths.home,
+    paths.profilesDir,
+    paths.agentsDir,
+    paths.skillsDir,
+    paths.groupsDir,
+    paths.logsDir,
+  ]) {
+    mkdirSync(d, { recursive: true })
+  }
+
+  const db = openDb(paths.db)
+  runMigrations(db)
+
+  if (!existsSync(paths.authFile)) {
+    const created = webTokenRepo.create(db, 'bootstrap')
+    writeFileSync(paths.authFile, `${JSON.stringify({ token: created.token }, null, 2)}\n`, {
+      mode: 0o600,
+    })
+    try {
+      chmodSync(paths.authFile, 0o600)
+    } catch {
+      // Windows: chmod is a no-op
+    }
+    console.log(`bazilion auto-bootstrapped at ${paths.home}`)
+    console.log(`bootstrap token written to ${paths.authFile}`)
+    return { db, authToken: created.token }
+  }
+
+  return { db, authToken: readAuthFile(paths.authFile).token }
+}
+
+export function getCtx(): DaemonCtx {
+  if (!_paths) _paths = resolvePaths()
+  if (!_db || _authToken === null) {
+    const result = bootstrap(_paths)
+    _db = result.db
+    _authToken = result.authToken
+  }
+  if (!_schedulerStarted && process.env.BAZILION_SCHEDULER !== 'off') {
+    _schedulerStarted = true
+    startScheduler()
+  }
+  return { db: _db, paths: _paths, authToken: _authToken }
+}

package/apps/daemon/src/lib/messaging-host.ts

@@ -0,0 +1,34 @@
+// Daemon-side `MessagingHost` implementation backed by the local SQLite handle.
+//
+// Two consumers:
+//   1. In-process callers (compact / context / truncate endpoints) that build
+//      a Bazilion session for inspection and want messaging tools enumerated
+//      with the same shape the chat path sees.
+//   2. The IPC handler that services messaging requests issued by worker
+//      subprocesses. Workers no longer hold a SQLite handle of their own —
+//      they call `process.send({type: 'rpc', ...})` and the parent dispatches
+//      through this host.
+
+import { agentRepo, type BazilionDb, messageRepo } from '../core/index.ts'
+import type { MessagingHost } from '../runtime/index.ts'
+
+export function createDbMessagingHost(db: BazilionDb): MessagingHost {
+  return {
+    agentExists(agentId) {
+      return agentRepo.get(db, agentId) !== null
+    },
+    sendMessage(input) {
+      const m = messageRepo.send(db, input)
+      return { messageId: m.id }
+    },
+    listInbox(agentId, opts) {
+      return messageRepo.listInbox(db, agentId, opts)
+    },
+    markRead(messageId) {
+      messageRepo.markRead(db, messageId)
+    },
+    findReplies(agentId, replyTo) {
+      return messageRepo.findReplies(db, agentId, replyTo)
+    },
+  }
+}

package/apps/daemon/src/lib/middleware-auth.ts

@@ -0,0 +1,52 @@
+// Hono auth + first-run gate middleware.
+//
+// Mirrors what apps/web/src/middleware.ts used to do for `/api/*` paths,
+// but framework-typed for Hono. Web SSR auth (login redirect, welcome
+// redirect) stays in the Astro app's own middleware — the daemon only
+// returns JSON status codes; the web app translates those to redirects.
+
+import type { Context, Next } from 'hono'
+import { getCookie } from 'hono/cookie'
+import { isSetupComplete } from '../core/index.ts'
+import { extractBearer, isValidToken } from './auth.ts'
+import { getCtx } from './ctx.ts'
+
+/** Reachable without a token. The login route mints them; health is a probe. */
+const PUBLIC_PATHS = new Set(['/api/login', '/api/health'])
+
+/**
+ * Once authenticated, these paths still pass through the first-run gate so
+ * users can finish their initial setup. Everything else 409s until the user
+ * has at least one enabled provider with ≥1 curated model.
+ */
+const SETUP_OPEN_PREFIXES = ['/api/config', '/api/auth', '/api/health']
+
+function isSetupOpen(path: string): boolean {
+  for (const prefix of SETUP_OPEN_PREFIXES) {
+    if (path === prefix || path.startsWith(`${prefix}/`)) return true
+  }
+  return false
+}
+
+// biome-ignore lint/suspicious/noConfusingVoidType: hono's Next() returns Promise<void>; the union is the framework's middleware contract.
+export async function authMiddleware(c: Context, next: Next): Promise<Response | void> {
+  const path = c.req.path
+  if (PUBLIC_PATHS.has(path)) {
+    await next()
+    return
+  }
+
+  const bearer = extractBearer(c.req.header('authorization'))
+  const cookie = getCookie(c, 'bz_token')
+  const token = bearer ?? cookie
+
+  if (!token || !isValidToken(token)) {
+    return c.json({ error: 'unauthorized' }, 401)
+  }
+
+  if (!isSetupOpen(path) && !isSetupComplete(getCtx().db)) {
+    return c.json({ error: 'setup incomplete' }, 409)
+  }
+
+  await next()
+}