bazilion 0.0.0 → 0.1.0

package/apps/cli/test/trigger.test.ts

@@ -1,245 +0,0 @@
-import { createServer, type ServerResponse } from 'node:http'
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
-import { extractAgentId } from './helpers.ts'
-import { startTestServer, type TestServer } from './server-fixture.ts'
-
-interface MockLlm {
-  url: string
-  push(responses: unknown[]): void
-  reset(): void
-  stop(): Promise<void>
-  callCount(): number
-}
-
-interface Canned {
-  choices: Array<{
-    message: { role?: string; content?: string | null }
-    finish_reason?: string
-  }>
-}
-
-function writeSse(res: ServerResponse, canned: Canned): void {
-  res.writeHead(200, {
-    'content-type': 'text/event-stream',
-    'cache-control': 'no-cache',
-    connection: 'keep-alive',
-  })
-  const msg = canned.choices[0]?.message ?? {}
-  const finish = canned.choices[0]?.finish_reason ?? 'stop'
-  res.write(
-    `data: ${JSON.stringify({
-      id: 'mock',
-      object: 'chat.completion.chunk',
-      choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
-    })}\n\n`,
-  )
-  if (typeof msg.content === 'string' && msg.content.length > 0) {
-    res.write(
-      `data: ${JSON.stringify({
-        id: 'mock',
-        object: 'chat.completion.chunk',
-        choices: [{ index: 0, delta: { content: msg.content }, finish_reason: null }],
-      })}\n\n`,
-    )
-  }
-  res.write(
-    `data: ${JSON.stringify({
-      id: 'mock',
-      object: 'chat.completion.chunk',
-      choices: [{ index: 0, delta: {}, finish_reason: finish }],
-    })}\n\n`,
-  )
-  res.write('data: [DONE]\n\n')
-  res.end()
-}
-
-function startLmStudioMock(): Promise<MockLlm> {
-  const queue: unknown[] = []
-  let calls = 0
-  const server = createServer((_req, res) => {
-    calls++
-    if (queue.length === 0) {
-      // Default response so we never block — the scheduler may fire more times
-      // than the test pushed responses for, and we don't want to deadlock.
-      writeSse(res, {
-        choices: [
-          { message: { role: 'assistant', content: 'default-pong' }, finish_reason: 'stop' },
-        ],
-      })
-      return
-    }
-    const item = queue.shift() as Canned
-    writeSse(res, item)
-  })
-  return new Promise((resolve) => {
-    server.listen(0, () => {
-      const addr = server.address()
-      if (!addr || typeof addr === 'string') throw new Error('unexpected server address')
-      resolve({
-        url: `http://localhost:${addr.port}/v1`,
-        push(items) {
-          queue.push(...items)
-        },
-        reset() {
-          queue.length = 0
-          calls = 0
-        },
-        stop: () => new Promise<void>((r) => server.close(() => r())),
-        callCount: () => calls,
-      })
-    })
-  })
-}
-
-let mock: MockLlm
-let server: TestServer
-
-beforeAll(async () => {
-  mock = await startLmStudioMock()
-  server = await startTestServer({
-    LMSTUDIO_URL: mock.url,
-    // Drive the scheduler fast so the test doesn't wait 5s per tick.
-    BAZILION_SCHEDULER_TICK_MS: '200',
-  })
-})
-afterAll(async () => {
-  await server.stop()
-  await mock.stop()
-})
-// Reset order matters: wipe DB (kills any active triggers) *before* zeroing
-// the mock's call counter, so a tick mid-reset can't increment `calls` after
-// we've cleared it. The scheduler has nothing to fire after the DB wipe.
-beforeEach(() => {
-  server.reset()
-  mock.reset()
-})
-
-async function spawnAgent(): Promise<string> {
-  await server.cli(['profile', 'create', 'p', '--model', 'lmstudio:test-model'])
-  const r = await server.cli(['agent', 'spawn', '--profile', 'p'])
-  return extractAgentId(r.stdout)
-}
-
-test('trigger add/list round-trip', async () => {
-  const agentId = await spawnAgent()
-  const add = await server.cli([
-    'trigger',
-    'add',
-    agentId,
-    '--every',
-    '60',
-    '--message',
-    'tick',
-    '--disabled',
-  ])
-  expect(add.exitCode).toBe(0)
-  expect(add.stdout).toMatch(/every 60s\tdisabled/)
-
-  const list = await server.cli(['trigger', 'list', agentId])
-  expect(list.exitCode).toBe(0)
-  expect(list.stdout).toMatch(/every 60s/)
-  expect(list.stdout).toMatch(/last: \(never\)/)
-})
-
-test('trigger enable/disable toggles state', async () => {
-  const agentId = await spawnAgent()
-  const add = await server.cli([
-    'trigger',
-    'add',
-    agentId,
-    '--every',
-    '60',
-    '--message',
-    'tick',
-    '--disabled',
-  ])
-  const [id] = add.stdout.trim().split('\t') as [string]
-  expect(id).toBeTruthy()
-
-  await server.cli(['trigger', 'enable', id])
-  let list = await server.cli(['trigger', 'list', agentId])
-  expect(list.stdout).toMatch(/enabled/)
-
-  await server.cli(['trigger', 'disable', id])
-  list = await server.cli(['trigger', 'list', agentId])
-  expect(list.stdout).toMatch(/disabled/)
-})
-
-test('trigger rm deletes the trigger', async () => {
-  const agentId = await spawnAgent()
-  const add = await server.cli([
-    'trigger',
-    'add',
-    agentId,
-    '--every',
-    '60',
-    '--message',
-    'tick',
-    '--disabled',
-  ])
-  const [id] = add.stdout.trim().split('\t') as [string]
-  await server.cli(['trigger', 'rm', id])
-  const list = await server.cli(['trigger', 'list', agentId])
-  expect(list.stdout).toContain('(no triggers)')
-})
-
-test('enabled interval trigger fires and updates last_fired_at', async () => {
-  const agentId = await spawnAgent()
-
-  // intervalSec=1 → first fire happens ~1s after creation, scheduler ticks every 200ms.
-  const add = await server.cli([
-    'trigger',
-    'add',
-    agentId,
-    '--every',
-    '1',
-    '--message',
-    'hello from cron',
-  ])
-  expect(add.exitCode).toBe(0)
-
-  // Wait up to 15s for `last_fired_at` to flip from never to a timestamp —
-  // the scheduler bumps it before it kicks the worker.
-  let fired = false
-  for (let i = 0; i < 150; i++) {
-    const list = await server.cli(['trigger', 'list', agentId])
-    if (!/last: \(never\)/.test(list.stdout)) {
-      fired = true
-      break
-    }
-    await new Promise((r) => setTimeout(r, 100))
-  }
-  expect(fired).toBe(true)
-})
-
-test('cron trigger with invalid expression is rejected', async () => {
-  const agentId = await spawnAgent()
-  const r = await server.cli([
-    'trigger',
-    'add',
-    agentId,
-    '--cron',
-    'not-a-cron',
-    '--message',
-    'nope',
-  ])
-  expect(r.exitCode).not.toBe(0)
-  expect(r.stderr + r.stdout).toMatch(/invalid cron/i)
-})
-
-test('trigger add rejects both --every and --cron', async () => {
-  const agentId = await spawnAgent()
-  const r = await server.cli([
-    'trigger',
-    'add',
-    agentId,
-    '--every',
-    '60',
-    '--cron',
-    '* * * * *',
-    '--message',
-    'hi',
-  ])
-  expect(r.exitCode).not.toBe(0)
-  expect(r.stderr + r.stdout).toMatch(/exactly one of --every/)
-})

package/apps/cli/tsconfig.json

@@ -1,4 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "include": ["src/**/*"]
-}

package/apps/daemon/package.json

@@ -1,31 +0,0 @@
-{
-  "name": "@bazilion/daemon",
-  "version": "0.0.0",
-  "private": true,
-  "type": "module",
-  "bin": {
-    "bazilion-daemon": "./src/index.ts"
-  },
-  "scripts": {
-    "dev": "tsx src/index.ts",
-    "start": "node --experimental-strip-types src/index.ts"
-  },
-  "dependencies": {
-    "@bazilion/api-types": "workspace:*",
-    "@hono/node-server": "^1.13.0",
-    "@mariozechner/pi-agent-core": "^0.69.0",
-    "@mariozechner/pi-ai": "^0.69.0",
-    "@mariozechner/pi-coding-agent": "^0.69.0",
-    "@mozilla/readability": "^0.6.0",
-    "@tobilu/qmd": "^2.1.0",
-    "adm-zip": "^0.5.17",
-    "hono": "^4.6.0",
-    "linkedom": "^0.18.12",
-    "typebox": "^1.1.32",
-    "undici": "^8.1.0",
-    "yaml": "^2.6.0"
-  },
-  "devDependencies": {
-    "@types/adm-zip": "^0.5.8"
-  }
-}

package/apps/daemon/src/app.ts

@@ -1,41 +0,0 @@
-// Hono app factory.
-//
-// Returns a fully-wired Hono app: middleware (auth + first-run gate) +
-// routes. Kept as a factory so tests can build one with a dedicated DB
-// without touching the global ctx singleton.
-
-import { Hono } from 'hono'
-import { authMiddleware } from './lib/middleware-auth.ts'
-import { agentsRouter } from './routes/agents.ts'
-import { authRouter } from './routes/auth-login.ts'
-import { configRouter } from './routes/config.ts'
-import { groupsRouter } from './routes/groups.ts'
-import { messagesRouter } from './routes/messages.ts'
-import { miscRouter } from './routes/misc.ts'
-import { profilesRouter } from './routes/profiles.ts'
-import { skillsRouter } from './routes/skills.ts'
-import { triggersRouter } from './routes/triggers.ts'
-
-export function createApp(): Hono {
-  const app = new Hono()
-
-  // Auth + first-run gate runs before every route. Public paths (/api/login,
-  // /api/health) and the setup-open prefixes (/api/config, /api/auth) are
-  // whitelisted inside the middleware itself.
-  app.use('*', authMiddleware)
-
-  app.route('/api/agents', agentsRouter)
-  app.route('/api/groups', groupsRouter)
-  app.route('/api/profiles', profilesRouter)
-  app.route('/api/skills', skillsRouter)
-  app.route('/api/triggers', triggersRouter)
-  app.route('/api/messages', messagesRouter)
-  app.route('/api/config', configRouter)
-  // miscRouter exposes /backup, /tokens, /tokens/:id directly under /api —
-  // mounted at the API root so each handler can use its full path.
-  // authRouter likewise: /auth/openai*, /providers/test, /login.
-  app.route('/api', miscRouter)
-  app.route('/api', authRouter)
-
-  return app
-}

package/apps/daemon/src/core/agent/archive.ts

@@ -1,8 +0,0 @@
-import type { BazilionDb } from '../db/client.ts'
-import * as agentRepo from '../repos/agents.ts'
-
-export function archiveAgent(db: BazilionDb, id: string): void {
-  const agent = agentRepo.get(db, id)
-  if (!agent) throw new Error(`agent not found: ${id}`)
-  agentRepo.archive(db, agent.id)
-}

package/apps/daemon/src/core/agent/delete.ts

@@ -1,30 +0,0 @@
-import { existsSync, rmSync } from 'node:fs'
-import type { BazilionDb } from '../db/client.ts'
-import * as agentRepo from '../repos/agents.ts'
-
-export function deleteAgent(db: BazilionDb, id: string): void {
-  const agent = agentRepo.get(db, id)
-  if (!agent) throw new Error(`agent not found: ${id}`)
-  const fullId = agent.id
-
-  db.raw.transaction(() => {
-    // messages.from_agent_id and to_agent_id reference agents(id) with no ON
-    // DELETE rule, and messages.reply_to references messages(id) the same way,
-    // so a naive DELETE of the agent fails if it has any mailbox history.
-    // Null out inbound reply pointers to this agent's messages, then purge the
-    // messages themselves, then let agentRepo.remove cascade the rest
-    // (agent_skills, runs, events). agents.group_id is `ON DELETE RESTRICT`
-    // from the group side, but the agent row itself goes away freely.
-    db.raw.run(
-      `UPDATE messages SET reply_to = NULL
-         WHERE reply_to IN (SELECT id FROM messages WHERE from_agent_id = ? OR to_agent_id = ?)`,
-      [fullId, fullId],
-    )
-    db.raw.run('DELETE FROM messages WHERE from_agent_id = ? OR to_agent_id = ?', [fullId, fullId])
-    agentRepo.remove(db, fullId)
-  })()
-
-  if (existsSync(agent.dir)) {
-    rmSync(agent.dir, { recursive: true, force: true })
-  }
-}

package/apps/daemon/src/core/agent/resolve.ts

@@ -1,31 +0,0 @@
-import type { ResolvedAgent } from '@bazilion/api-types'
-import type { BazilionDb } from '../db/client.ts'
-import type { Paths } from '../paths.ts'
-import * as agentRepo from '../repos/agents.ts'
-import * as groupRepo from '../repos/groups.ts'
-import * as profileRepo from '../repos/profiles.ts'
-
-export function resolveAgent(db: BazilionDb, paths: Paths, agentId: string): ResolvedAgent {
-  // `agentRepo.get` accepts either a full UUID or an unambiguous prefix.
-  const agent = agentRepo.get(db, agentId)
-  if (!agent) throw new Error(`agent not found: ${agentId}`)
-
-  const profile = profileRepo.get(db, agent.profileId)
-  if (!profile) {
-    throw new Error(`profile not found for agent ${agentId}: ${agent.profileId}`)
-  }
-
-  const group = groupRepo.get(db, agent.groupId, paths)
-  if (!group) {
-    throw new Error(`group not found for agent ${agentId}: ${agent.groupId}`)
-  }
-
-  return {
-    agent,
-    profile,
-    model: agent.modelOverride ?? profile.defaultModel,
-    reasoningLevel: agent.reasoningLevel,
-    group,
-    skills: agentRepo.listAttachedSkills(db, agentId),
-  }
-}

package/apps/daemon/src/core/agent/spawn.ts

@@ -1,95 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import { mkdirSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-import type { Agent, ReasoningLevel } from '@bazilion/api-types'
-import type { BazilionDb } from '../db/client.ts'
-import type { Paths } from '../paths.ts'
-import { loadProfile } from '../profile/load.ts'
-import { DEFAULT_GROUP_ID } from '../profile/seed.ts'
-import * as agentRepo from '../repos/agents.ts'
-import * as groupRepo from '../repos/groups.ts'
-import { discoverSkills } from '../skills/discover.ts'
-
-export interface SpawnAgentInput {
-  profileId: string
-  name?: string
-  modelOverride?: string | null
-  reasoningLevel?: ReasoningLevel
-  /**
-   * Group the new agent joins. One agent belongs to exactly one group. When
-   * omitted, falls back to the seeded 'default' group — the same fallback
-   * used everywhere we need a sensible cwd. Must refer to an existing group.
-   */
-  groupId?: string
-}
-
-export function spawnAgent(db: BazilionDb, paths: Paths, input: SpawnAgentInput): Agent {
-  const loaded = loadProfile(db, input.profileId)
-  const id = randomUUID()
-  const dir = paths.agentDir(id)
-  // Agent's private home: identity files + sessions. Memory now lives at
-  // the group level (`groups/<slug>/memory/`), shared by all member agents,
-  // so we no longer create per-agent memory dirs here.
-  mkdirSync(dir, { recursive: true })
-  mkdirSync(join(dir, 'sessions'), { recursive: true })
-
-  // Copy profile templates so the agent can diverge per-instance.
-  writeFileSync(join(dir, 'SOUL.md'), loaded.files.soul)
-  writeFileSync(join(dir, 'IDENTITY.md'), loaded.files.identity)
-  if (loaded.files.bootstrap !== null) {
-    writeFileSync(join(dir, 'BOOTSTRAP.md'), loaded.files.bootstrap)
-  }
-  if (loaded.files.agents !== null) {
-    writeFileSync(join(dir, 'AGENTS.md'), loaded.files.agents)
-  }
-  if (loaded.files.tools !== null) {
-    writeFileSync(join(dir, 'TOOLS.md'), loaded.files.tools)
-  }
-  if (loaded.files.heartbeat !== null) {
-    writeFileSync(join(dir, 'HEARTBEAT.md'), loaded.files.heartbeat)
-  }
-
-  const reasoningLevel: ReasoningLevel = input.reasoningLevel ?? 'medium'
-
-  // Resolve group: explicit input wins; otherwise fall back to the seeded
-  // 'default'. If neither exists, error out — an agent can't live without a
-  // group (the FK `agents.group_id REFERENCES groups(id)` enforces it too).
-  const groupId = input.groupId ?? DEFAULT_GROUP_ID
-  const group = groupRepo.get(db, groupId, paths)
-  if (!group) {
-    throw new Error(
-      `spawnAgent: group "${groupId}" does not exist. Pass an explicit --group or complete first-run setup first.`,
-    )
-  }
-
-  const agentJson = {
-    profileId: input.profileId,
-    name: input.name ?? loaded.profile.name,
-    modelOverride: input.modelOverride ?? null,
-    reasoningLevel,
-    groupId: group.id,
-  }
-  writeFileSync(join(dir, 'agent.json'), `${JSON.stringify(agentJson, null, 2)}\n`)
-
-  const agent = agentRepo.insert(db, {
-    id,
-    profileId: input.profileId,
-    name: agentJson.name,
-    modelOverride: agentJson.modelOverride,
-    reasoningLevel,
-    status: 'idle',
-    dir,
-    groupId: group.id,
-  })
-
-  // Skills come from the profile only — `skills_mode='all'` attaches every
-  // installed skill, `'selected'` attaches the profile's default list.
-  // Per-agent skill changes happen post-spawn via `agent skill add/rm`.
-  const skills =
-    loaded.profile.skillsMode === 'all'
-      ? discoverSkills(paths).map((s) => s.name)
-      : loaded.defaultSkills
-  for (const s of skills) agentRepo.attachSkill(db, id, s)
-
-  return agent
-}

package/apps/daemon/src/core/agent/unarchive.ts

@@ -1,11 +0,0 @@
-import type { BazilionDb } from '../db/client.ts'
-import * as agentRepo from '../repos/agents.ts'
-
-export function unarchiveAgent(db: BazilionDb, id: string): void {
-  const agent = agentRepo.get(db, id)
-  if (!agent) throw new Error(`agent not found: ${id}`)
-  if (agent.status !== 'archived') {
-    throw new Error(`agent is not archived (status: ${agent.status})`)
-  }
-  agentRepo.unarchive(db, agent.id)
-}

package/apps/daemon/src/core/availableModels.ts

@@ -1,58 +0,0 @@
-// Enumerates models that agents are actually allowed to use right now:
-// every curated model of every currently-enabled provider. Drives the model
-// dropdowns on the profile and agent forms.
-//
-// A provider must be both (a) toggled on in `provider_state` AND (b) have
-// at least one curated entry in `provider_models` to show up here. Drop a
-// provider off either side and it disappears from the list without a UI
-// edit — the dropdowns are entirely data-driven.
-
-import type { BazilionDb } from './db/client.ts'
-import * as providerModelRepo from './repos/providerModels.ts'
-import * as providerStateRepo from './repos/providerState.ts'
-
-export interface AvailableModel {
-  provider: string
-  model: string
-  /** The `provider:model` string used as the form value and in model resolution. */
-  value: string
-}
-
-/**
- * Flat list of `{provider, model, value}` for every curated model of every
- * enabled provider. Iteration order: providers as they're stored in
- * `provider_state` (by insertion time), models as curated (preserving the
- * admin's ordering from the textarea).
- */
-export function listAvailableModels(db: BazilionDb): AvailableModel[] {
-  const enabled = providerStateRepo.listEnabled(db)
-  const out: AvailableModel[] = []
-  for (const provider of enabled) {
-    for (const model of providerModelRepo.list(db, provider)) {
-      out.push({ provider, model, value: `${provider}:${model}` })
-    }
-  }
-  return out
-}
-
-/**
- * Same as `listAvailableModels` but grouped by provider — the shape the web
- * dropdowns consume directly via `<optgroup>`.
- */
-export function groupAvailableModels(db: BazilionDb): { provider: string; models: string[] }[] {
-  const enabled = providerStateRepo.listEnabled(db)
-  const groups: { provider: string; models: string[] }[] = []
-  for (const provider of enabled) {
-    const models = providerModelRepo.list(db, provider)
-    if (models.length > 0) groups.push({ provider, models })
-  }
-  return groups
-}
-
-/**
- * True once the user has at least one usable model — i.e. at least one enabled
- * provider with at least one curated model. Gates the first-run flow.
- */
-export function isSetupComplete(db: BazilionDb): boolean {
-  return listAvailableModels(db).length > 0
-}

package/apps/daemon/src/core/db/client.ts

@@ -1,113 +0,0 @@
-import { DatabaseSync, type SQLInputValue } from 'node:sqlite'
-
-export interface QueryStmt<RowType, ParamsType extends unknown[]> {
-  get(...params: ParamsType): RowType | null
-  all(...params: ParamsType): RowType[]
-  run(...params: ParamsType): { changes: number; lastInsertRowid: number | bigint }
-}
-
-export interface QueryableDatabase {
-  query<RowType, ParamsType extends unknown[]>(sql: string): QueryStmt<RowType, ParamsType>
-  run(sql: string, params?: unknown[]): { changes: number; lastInsertRowid: number | bigint }
-  exec(sql: string): void
-  transaction<T>(fn: () => T): () => T
-}
-
-export interface BazilionDb {
-  raw: QueryableDatabase
-  close(): void
-}
-
-function wrap(rawDb: DatabaseSync): QueryableDatabase {
-  const cache = new Map<string, ReturnType<DatabaseSync['prepare']>>()
-  function getStmt(sql: string) {
-    let s = cache.get(sql)
-    if (!s) {
-      s = rawDb.prepare(sql)
-      cache.set(sql, s)
-    }
-    return s
-  }
-
-  return {
-    query<R, P extends unknown[]>(sql: string): QueryStmt<R, P> {
-      const stmt = getStmt(sql)
-      return {
-        get(...params: P): R | null {
-          const result = stmt.get(...(params as SQLInputValue[]))
-          return (result as R | undefined) ?? null
-        },
-        all(...params: P): R[] {
-          return stmt.all(...(params as SQLInputValue[])) as R[]
-        },
-        run(...params: P) {
-          return stmt.run(...(params as SQLInputValue[])) as {
-            changes: number
-            lastInsertRowid: number | bigint
-          }
-        },
-      }
-    },
-    run(sql, params) {
-      const stmt = getStmt(sql)
-      return stmt.run(...((params ?? []) as SQLInputValue[])) as {
-        changes: number
-        lastInsertRowid: number | bigint
-      }
-    },
-    exec(sql) {
-      rawDb.exec(sql)
-    },
-    // node:sqlite has no callable `transaction` wrapper; use manual BEGIN/COMMIT/ROLLBACK.
-    transaction<T>(fn: () => T): () => T {
-      return () => {
-        rawDb.exec('BEGIN')
-        try {
-          const result = fn()
-          rawDb.exec('COMMIT')
-          return result
-        } catch (err) {
-          rawDb.exec('ROLLBACK')
-          throw err
-        }
-      }
-    },
-  }
-}
-
-function applyPragmas(rawDb: DatabaseSync, includeWal: boolean): void {
-  if (includeWal) {
-    try {
-      rawDb.exec('PRAGMA journal_mode = WAL')
-    } catch {
-      // some sqlite builds reject WAL on :memory: — ignore
-    }
-  }
-  rawDb.exec('PRAGMA foreign_keys = ON')
-}
-
-export function openDb(path: string): BazilionDb {
-  const raw = new DatabaseSync(path)
-  applyPragmas(raw, true)
-  return {
-    raw: wrap(raw),
-    close() {
-      raw.close()
-    },
-  }
-}
-
-export function openInMemoryDb(): BazilionDb {
-  const raw = new DatabaseSync(':memory:')
-  applyPragmas(raw, false)
-  return {
-    raw: wrap(raw),
-    close() {
-      raw.close()
-    },
-  }
-}
-
-export function inTx<T>(db: BazilionDb, fn: () => T): T {
-  return db.raw.transaction(fn)()
-}