bazilion 0.0.0 → 0.1.0

package/apps/cli/src/index.ts

@@ -1,196 +0,0 @@
-#!/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

@@ -1,12 +0,0 @@
-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

@@ -1,213 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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()
-})