bazilion 0.0.0

package/apps/cli/src/index.ts

@@ -0,0 +1,196 @@
+#!/usr/bin/env -S tsx
+import { defineCommand, runCommand, showUsage } from 'citty'
+import { ApiClientError } from './client.ts'
+import { agentCommand } from './commands/agent.ts'
+import { authCommand } from './commands/auth.ts'
+import { backupCommand } from './commands/backup.ts'
+import { completionCommand } from './commands/completion.ts'
+import { configCommand } from './commands/config.ts'
+import { doctorCommand } from './commands/doctor.ts'
+import { groupCommand } from './commands/group.ts'
+import { inboxCommand } from './commands/inbox.ts'
+import { loginCommand } from './commands/login.ts'
+import { memoryCommand } from './commands/memory.ts'
+import { profileCommand } from './commands/profile.ts'
+import { providerCommand } from './commands/provider.ts'
+import { sendCommand } from './commands/send.ts'
+import { serveCommand } from './commands/serve.ts'
+import { skillCommand } from './commands/skill.ts'
+import { tokenCommand } from './commands/token.ts'
+import { triggerCommand } from './commands/trigger.ts'
+import { uninstallCommand } from './commands/uninstall.ts'
+
+const main = defineCommand({
+  meta: {
+    name: 'bazilion',
+    version: '0.0.0',
+    description: 'Multi-agent runtime',
+  },
+  subCommands: {
+    login: loginCommand,
+    profile: profileCommand,
+    group: groupCommand,
+    agent: agentCommand,
+    skill: skillCommand,
+    memory: memoryCommand,
+    provider: providerCommand,
+    send: sendCommand,
+    inbox: inboxCommand,
+    config: configCommand,
+    serve: serveCommand,
+    doctor: doctorCommand,
+    backup: backupCommand,
+    trigger: triggerCommand,
+    token: tokenCommand,
+    auth: authCommand,
+    uninstall: uninstallCommand,
+  },
+})
+
+// Mutate the command tree after definition so `completion` can introspect its
+// own siblings without a circular import. Cast is safe — citty keeps the
+// object reference on `main` after defineCommand, and we know its shape.
+;(main.subCommands as Record<string, unknown>).completion = completionCommand(main as never)
+
+// Resolve `bazilion <a> <b> --help` to the right subcommand for showUsage.
+// citty's built-in version is private, so we re-implement it for plain
+// subCommands objects (the shape we use throughout the tree).
+type AnyCmd = Parameters<typeof showUsage>[0]
+type CmdWithSubs = AnyCmd & { subCommands?: Record<string, AnyCmd> }
+async function resolveSubCommand(
+  cmd: CmdWithSubs,
+  rawArgs: string[],
+  parent?: AnyCmd,
+): Promise<[AnyCmd, AnyCmd | undefined]> {
+  const subs = cmd.subCommands
+  if (subs && Object.keys(subs).length > 0) {
+    const idx = rawArgs.findIndex((a) => !a.startsWith('-'))
+    const name = idx >= 0 ? rawArgs[idx] : undefined
+    if (name && subs[name]) {
+      return resolveSubCommand(subs[name] as CmdWithSubs, rawArgs.slice(idx + 1), cmd)
+    }
+  }
+  return [cmd, parent]
+}
+
+function printError(err: unknown): void {
+  if (err instanceof ApiClientError) {
+    console.error(`error: ${err.body.error}`)
+    if (err.status === 401) {
+      console.error('  hint: token mismatch. Check ~/.bazilion/auth.json "token"')
+      console.error('        or re-run "bazilion login" for a remote server.')
+    } else if (err.status === 403) {
+      console.error('  hint: request was rejected by the server. If you hit this from a')
+      console.error('        fresh CLI build, check that BAZILION_SERVER matches the')
+      console.error('        server origin exactly (scheme + host + port).')
+    }
+    return
+  }
+  const msg = err instanceof Error ? err.message : String(err)
+  console.error(`error: ${msg}`)
+  // Friendly hints for the most common connection failures. node's fetch
+  // wraps the syscall error in err.cause.code, so we peek there too.
+  const cause = err instanceof Error ? (err as { cause?: { code?: string } }).cause : undefined
+  const code = cause?.code
+  if (code === 'ECONNREFUSED' || /ECONNREFUSED/.test(msg)) {
+    console.error('  hint: the bazilion server is not running. Start it with "bazilion serve"')
+    console.error('        or point BAZILION_SERVER at a running instance.')
+  } else if (code === 'ENOTFOUND' || /ENOTFOUND/.test(msg)) {
+    console.error('  hint: host not found. Check BAZILION_SERVER / ~/.bazilion/auth.json.')
+  }
+}
+
+/**
+ * Top-level `bazilion --help` renders a categorized layout instead of citty's
+ * default `sub1|sub2|…` pipe-soup USAGE line. Subcommand `--help` still uses
+ * citty's built-in renderer.
+ */
+function printTopLevelHelp(): void {
+  console.log('Multi-agent runtime (bazilion v0.0.0)')
+  console.log('')
+  console.log('USAGE bazilion <command> [args]')
+  console.log('')
+  const groups: { title: string; items: [string, string][] }[] = [
+    {
+      title: 'setup',
+      items: [
+        ['serve', 'Start the bazilion daemon (auto-bootstraps ~/.bazilion on first run)'],
+        ['doctor', 'Diagnose your bazilion install'],
+        ['uninstall', 'Wipe bazilion state from ~/.bazilion (or BAZILION_HOME)'],
+      ],
+    },
+    {
+      title: 'catalog',
+      items: [
+        ['profile', 'Manage profiles (templates agents are spawned from)'],
+        ['group', 'Manage groups (collaboration context — filesystem root + USER.md + roster)'],
+        ['skill', 'Manage the skill library'],
+        ['provider', 'Manage and test LLM providers'],
+        ['config', 'Manage service config (credentials + URLs/IDs)'],
+        ['auth', 'OAuth provider sign-in (ChatGPT account, …)'],
+      ],
+    },
+    {
+      title: 'agents',
+      items: [
+        ['agent', 'Spawn, list, chat, archive agents'],
+        ['memory', "Read/write a group's shared memory"],
+        ['send', 'Send a message from one agent to another'],
+        ['inbox', 'Inspect agent inboxes'],
+        ['trigger', 'Manage agent heartbeats / cron triggers'],
+      ],
+    },
+    {
+      title: 'ops',
+      items: [['backup', 'Download a tar.gz backup of ~/.bazilion']],
+    },
+    {
+      title: 'remote',
+      items: [
+        ['login', 'Save a remote bazilion server + token pair to auth.json'],
+        ['token', 'Manage web tokens for API/CLI clients'],
+      ],
+    },
+    {
+      title: 'shell',
+      items: [['completion', 'Print shell completion script (bash | zsh | fish)']],
+    },
+  ]
+  const nameWidth = 12
+  for (const g of groups) {
+    console.log(`  ${g.title}`)
+    for (const [name, desc] of g.items) {
+      console.log(`    ${name.padEnd(nameWidth)}${desc}`)
+    }
+    console.log('')
+  }
+  console.log('Use `bazilion <command> --help` for more information about a command.')
+}
+
+async function entry(): Promise<void> {
+  const rawArgs = process.argv.slice(2)
+  try {
+    if (rawArgs.includes('--help') || rawArgs.includes('-h')) {
+      // For the top-level `bazilion --help`, render our grouped layout.
+      // Subcommand help still goes through citty (preserves native formatting).
+      const firstPositional = rawArgs.find((a) => !a.startsWith('-'))
+      if (!firstPositional) {
+        printTopLevelHelp()
+        process.exit(0)
+      }
+      const [target, parent] = await resolveSubCommand(main as CmdWithSubs, rawArgs)
+      await showUsage(target, parent)
+      process.exit(0)
+    }
+    if (rawArgs.length === 1 && (rawArgs[0] === '--version' || rawArgs[0] === '-v')) {
+      console.log('0.0.0')
+      return
+    }
+    await runCommand(main, { rawArgs })
+  } catch (err) {
+    printError(err)
+    process.exit(1)
+  }
+}
+
+entry()

package/apps/cli/src/paths.ts

@@ -0,0 +1,12 @@
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+export interface CliPaths {
+  home: string
+  authFile: string
+}
+
+export function resolveCliPaths(home?: string): CliPaths {
+  const root = home ?? process.env.BAZILION_HOME ?? join(homedir(), '.bazilion')
+  return { home: root, authFile: join(root, 'auth.json') }
+}

package/apps/cli/test/agent.test.ts

@@ -0,0 +1,213 @@
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
+import { extractAgentId } from './helpers.ts'
+import { startTestServer, type TestServer } from './server-fixture.ts'
+
+// Scheduler disabled — this suite exercises agent-CRUD only (spawn / show /
+// skill / move / archive / delete). Running the scheduler alongside adds
+// tick-rate DB reads and potential background worker spawns for any
+// leftover unread-inbox state from prior tests, which can push a busy
+// full-suite run past the 30s per-test timeout.
+let server: TestServer
+beforeAll(async () => {
+  server = await startTestServer({ BAZILION_SCHEDULER: 'off' })
+})
+afterAll(() => server.stop())
+beforeEach(() => server.reset())
+
+test('scaffold profile, spawn three agents, inspect', async () => {
+  let r = await server.cli([
+    'profile',
+    'create',
+    'p',
+    '--model',
+    'anthropic:claude-opus-4-6',
+    '--skills',
+    's1,s2',
+  ])
+  expect(r.exitCode).toBe(0)
+
+  await server.cli(['group', 'add', 'g1'])
+  await server.cli(['group', 'add', 'g2'])
+
+  // A1: group g1, default skills
+  r = await server.cli(['agent', 'spawn', '--profile', 'p', '--name', 'A1', '--group', 'g1'])
+  expect(r.exitCode).toBe(0)
+  const id1 = extractAgentId(r.stdout)
+
+  // A2: group g2, attach an extra skill post-spawn
+  r = await server.cli(['agent', 'spawn', '--profile', 'p', '--name', 'A2', '--group', 'g2'])
+  expect(r.exitCode).toBe(0)
+  const id2 = extractAgentId(r.stdout)
+  await server.cli(['agent', 'skill', 'add', id2, 'extra'])
+
+  // A3: default-group fallback, default skills, model override
+  r = await server.cli([
+    'agent',
+    'spawn',
+    '--profile',
+    'p',
+    '--name',
+    'A3',
+    '--model',
+    'openai:gpt-5',
+  ])
+  expect(r.exitCode).toBe(0)
+  const id3 = extractAgentId(r.stdout)
+
+  // List sees all three
+  r = await server.cli(['agent', 'list'])
+  expect(r.stdout).toContain('A1')
+  expect(r.stdout).toContain('A2')
+  expect(r.stdout).toContain('A3')
+
+  // Show A1: inherits default skills s1,s2 and is in g1
+  r = await server.cli(['agent', 'show', id1])
+  expect(r.stdout).toContain('A1')
+  expect(r.stdout).toContain('group:')
+  expect(r.stdout).toContain('g1')
+  expect(r.stdout).toContain('s1')
+  expect(r.stdout).toContain('s2')
+
+  // Show A2: has 'extra' skill, in g2
+  r = await server.cli(['agent', 'show', id2])
+  expect(r.stdout).toContain('extra')
+  expect(r.stdout).toContain('g2')
+
+  // Show A3: model override + lands in the seeded default group
+  r = await server.cli(['agent', 'show', id3])
+  expect(r.stdout).toContain('openai:gpt-5')
+  expect(r.stdout).toContain('default')
+
+  // Archive A3 → list excludes it by default
+  r = await server.cli(['agent', 'archive', id3])
+  expect(r.exitCode).toBe(0)
+
+  r = await server.cli(['agent', 'list'])
+  expect(r.stdout).toContain('A1')
+  expect(r.stdout).toContain('A2')
+  expect(r.stdout).not.toContain('A3')
+
+  // --all reveals it again
+  r = await server.cli(['agent', 'list', '--all'])
+  expect(r.stdout).toContain('A3')
+})
+
+test('agent skill add/rm on the fly', async () => {
+  await server.cli(['profile', 'create', 'p', '--model', 'm'])
+  let r = await server.cli(['agent', 'spawn', '--profile', 'p'])
+  const id = extractAgentId(r.stdout)
+
+  await server.cli(['agent', 'skill', 'add', id, 'new-skill'])
+  r = await server.cli(['agent', 'show', id])
+  expect(r.stdout).toContain('new-skill')
+
+  await server.cli(['agent', 'skill', 'rm', id, 'new-skill'])
+  r = await server.cli(['agent', 'show', id])
+  expect(r.stdout).not.toContain('new-skill')
+})
+
+test('agent lifecycle: spawn -> archive -> unarchive -> delete', async () => {
+  await server.cli(['profile', 'create', 'p', '--model', 'm'])
+  let r = await server.cli(['agent', 'spawn', '--profile', 'p', '--name', 'lifecycle'])
+  const id = extractAgentId(r.stdout)
+
+  // archive -> hidden from default list, visible under --all
+  r = await server.cli(['agent', 'archive', id])
+  expect(r.exitCode).toBe(0)
+  r = await server.cli(['agent', 'list'])
+  expect(r.stdout).not.toContain('lifecycle')
+  r = await server.cli(['agent', 'list', '--all'])
+  expect(r.stdout).toContain('lifecycle')
+
+  // unarchive -> back in default list
+  r = await server.cli(['agent', 'unarchive', id])
+  expect(r.exitCode).toBe(0)
+  r = await server.cli(['agent', 'list'])
+  expect(r.stdout).toContain('lifecycle')
+
+  // double unarchive is rejected (already idle)
+  r = await server.cli(['agent', 'unarchive', id])
+  expect(r.exitCode).not.toBe(0)
+  expect(r.stderr + r.stdout).toContain('not archived')
+
+  // delete -> gone completely
+  r = await server.cli(['agent', 'delete', id])
+  expect(r.exitCode).toBe(0)
+  r = await server.cli(['agent', 'list', '--all'])
+  expect(r.stdout).not.toContain('lifecycle')
+
+  // second delete fails
+  r = await server.cli(['agent', 'delete', id])
+  expect(r.exitCode).not.toBe(0)
+})
+
+test('deleting an agent with a mailbox history succeeds', async () => {
+  await server.cli(['profile', 'create', 'p', '--model', 'm'])
+  let r = await server.cli(['agent', 'spawn', '--profile', 'p', '--name', 'sender'])
+  const a = extractAgentId(r.stdout)
+  r = await server.cli(['agent', 'spawn', '--profile', 'p', '--name', 'receiver'])
+  const b = extractAgentId(r.stdout)
+
+  await server.cli(['send', a, b, 'hello'])
+  await server.cli(['send', b, a, 'hi back'])
+
+  // Delete the receiver — would fail before the FK-aware delete fix
+  r = await server.cli(['agent', 'delete', b])
+  expect(r.exitCode).toBe(0)
+
+  // Sender still exists; their inbox is now empty (message from b was purged)
+  r = await server.cli(['inbox', 'list', a])
+  expect(r.stdout).toContain('(inbox empty)')
+})
+
+test('agent commands accept an unambiguous UUID prefix (8 chars)', async () => {
+  await server.cli(['profile', 'create', 'p', '--model', 'm'])
+  const r = await server.cli(['agent', 'spawn', '--profile', 'p', '--name', 'prefixed'])
+  const fullId = extractAgentId(r.stdout)
+  const prefix = fullId.slice(0, 8)
+
+  // show
+  const show = await server.cli(['agent', 'show', prefix])
+  expect(show.exitCode).toBe(0)
+  expect(show.stdout).toContain('prefixed')
+
+  // archive/unarchive via prefix
+  const archR = await server.cli(['agent', 'archive', prefix])
+  expect(archR.exitCode).toBe(0)
+  const unarchR = await server.cli(['agent', 'unarchive', prefix])
+  expect(unarchR.exitCode).toBe(0)
+
+  // bogus prefix still 404s cleanly
+  const bad = await server.cli(['agent', 'show', 'zzzzzzzz'])
+  expect(bad.exitCode).not.toBe(0)
+})
+
+test('agent list short format shows 8-char prefix, --long shows full id + profile', async () => {
+  await server.cli(['profile', 'create', 'myprofile', '--model', 'm'])
+  const r = await server.cli(['agent', 'spawn', '--profile', 'myprofile', '--name', 'alpha'])
+  const fullId = extractAgentId(r.stdout)
+
+  const short = await server.cli(['agent', 'list'])
+  expect(short.stdout).toContain(fullId.slice(0, 8))
+  expect(short.stdout).toContain('alpha')
+  // Short form omits the profile column
+  expect(short.stdout).not.toContain('myprofile')
+
+  const long = await server.cli(['agent', 'list', '--long'])
+  expect(long.stdout).toContain(fullId)
+  expect(long.stdout).toContain('myprofile')
+})
+
+test('agent move changes group membership', async () => {
+  await server.cli(['profile', 'create', 'p', '--model', 'm'])
+  let r = await server.cli(['agent', 'spawn', '--profile', 'p', '--name', 'wanderer'])
+  const id = extractAgentId(r.stdout)
+
+  await server.cli(['group', 'add', 'elsewhere'])
+
+  r = await server.cli(['agent', 'move', id, 'elsewhere'])
+  expect(r.exitCode).toBe(0)
+
+  r = await server.cli(['agent', 'show', id])
+  expect(r.stdout).toContain('elsewhere')
+})

package/apps/cli/test/backup.test.ts

@@ -0,0 +1,95 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
+import { makeHome, runCli, type TestHome } from './helpers.ts'
+import { startTestServer, type TestServer } from './server-fixture.ts'
+
+let server: TestServer
+beforeAll(async () => {
+  server = await startTestServer()
+})
+afterAll(() => server.stop())
+beforeEach(() => server.reset())
+
+test('backup create downloads a tar.gz with the home contents', async () => {
+  writeFileSync(join(server.home, 'marker.txt'), 'hello')
+  const out = join(tmpdir(), `bz-backup-${Date.now()}.tar.gz`)
+
+  const res = await server.cli(['backup', 'create', out])
+  expect(res.exitCode).toBe(0)
+  expect(res.stdout).toContain('done')
+  expect(existsSync(out)).toBe(true)
+  expect(statSync(out).size).toBeGreaterThan(0)
+
+  rmSync(out, { force: true })
+})
+
+test('backup restore extracts the tar.gz into a fresh home', async () => {
+  writeFileSync(join(server.home, 'marker.txt'), 'restored-value')
+  const archive = join(tmpdir(), `bz-backup-${Date.now()}.tar.gz`)
+  await server.cli(['backup', 'create', archive])
+
+  // Restore into an empty dir. `runCli` doesn't need a server for this — the
+  // restore path is pure-offline — but we pass a valid home so the `--home`
+  // flag gets exercised.
+  const target: TestHome = { home: join(tmpdir(), `bz-restore-${Date.now()}`), cleanup() {} }
+  mkdirSync(target.home, { recursive: true })
+  const res = await runCli(['backup', 'restore', archive, '--home', target.home], target.home)
+  expect(res.exitCode).toBe(0)
+  expect(res.stdout).toContain('restored to')
+  expect(existsSync(join(target.home, 'marker.txt'))).toBe(true)
+  expect(readFileSync(join(target.home, 'marker.txt'), 'utf8')).toBe('restored-value')
+  expect(existsSync(join(target.home, 'bazilion.db'))).toBe(true)
+
+  rmSync(archive, { force: true })
+  rmSync(target.home, { recursive: true, force: true })
+})
+
+test('backup restore refuses a non-empty target without --force', async () => {
+  const archive = join(tmpdir(), `bz-backup-${Date.now()}.tar.gz`)
+  await server.cli(['backup', 'create', archive])
+
+  const target = makeHome()
+  // `makeHome` returns an empty dir; drop a file so restore sees non-empty.
+  writeFileSync(join(target.home, 'stray.txt'), 'do not destroy')
+  const res = await runCli(['backup', 'restore', archive, '--home', target.home], target.home)
+  expect(res.exitCode).not.toBe(0)
+  expect(res.stderr + res.stdout).toMatch(/not empty.*--force/)
+  // File still there
+  expect(existsSync(join(target.home, 'stray.txt'))).toBe(true)
+
+  rmSync(archive, { force: true })
+  target.cleanup()
+})
+
+test('backup restore --force overwrites a non-empty target', async () => {
+  writeFileSync(join(server.home, 'fresh.txt'), 'from-backup')
+  const archive = join(tmpdir(), `bz-backup-${Date.now()}.tar.gz`)
+  await server.cli(['backup', 'create', archive])
+
+  const target = makeHome()
+  writeFileSync(join(target.home, 'stray.txt'), 'old data')
+  const res = await runCli(
+    ['backup', 'restore', archive, '--home', target.home, '--force'],
+    target.home,
+  )
+  expect(res.exitCode).toBe(0)
+  // The stray file is gone, backup content landed
+  expect(existsSync(join(target.home, 'stray.txt'))).toBe(false)
+  expect(existsSync(join(target.home, 'fresh.txt'))).toBe(true)
+
+  rmSync(archive, { force: true })
+  target.cleanup()
+})
+
+test('backup restore errors clearly on a missing file', async () => {
+  const target = makeHome()
+  const res = await runCli(
+    ['backup', 'restore', '/definitely/not/a/real/path.tar.gz', '--home', target.home],
+    target.home,
+  )
+  expect(res.exitCode).not.toBe(0)
+  expect(res.stderr + res.stdout).toMatch(/backup file not found/)
+  target.cleanup()
+})