bazilion 0.0.0

package/apps/cli/src/commands/backup.ts

@@ -0,0 +1,135 @@
+import { spawn } from 'node:child_process'
+import { createWriteStream, existsSync, mkdirSync, readdirSync, rmSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+import { defineCommand } from 'citty'
+import { loadClientConfig } from '../client.ts'
+import { resolveCliPaths } from '../paths.ts'
+
+const createCmd = defineCommand({
+  meta: { name: 'create', description: 'Download a tar.gz backup of ~/.bazilion from the server' },
+  args: {
+    output: {
+      type: 'positional',
+      required: false,
+      description: 'Output file path (default: ./bazilion-backup-YYYY-MM-DD.tar.gz)',
+    },
+  },
+  async run({ args }) {
+    const cfg = loadClientConfig()
+    const date = new Date().toISOString().slice(0, 10)
+    const outAbs = resolve(args.output ?? `bazilion-backup-${date}.tar.gz`)
+
+    console.log(`downloading backup → ${outAbs}`)
+    const res = await fetch(`${cfg.serverUrl}/api/backup`, {
+      headers: { authorization: `Bearer ${cfg.token}`, origin: cfg.serverUrl },
+    })
+    if (!res.ok || !res.body) {
+      let err: string = res.statusText
+      try {
+        const body = (await res.json()) as { error?: string }
+        err = body.error ?? err
+      } catch {}
+      throw new Error(`backup failed: ${err}`)
+    }
+    await pipeline(Readable.fromWeb(res.body), createWriteStream(outAbs))
+    console.log('done')
+  },
+})
+
+/**
+ * Offline restore. Server must be stopped first — SQLite's DB files would get
+ * corrupted if the running daemon has them open while tar overwrites them.
+ * We check the default loopback port as a best-effort safety net.
+ */
+async function probeServerRunning(port: number): Promise<boolean> {
+  try {
+    const ctrl = new AbortController()
+    const timer = setTimeout(() => ctrl.abort(), 500)
+    // /login is unauthenticated (see middleware.ts PUBLIC_PATHS) — any response
+    // means something is listening on the port.
+    const res = await fetch(`http://127.0.0.1:${port}/login`, { signal: ctrl.signal })
+    clearTimeout(timer)
+    return res.status >= 200 && res.status < 600
+  } catch {
+    return false
+  }
+}
+
+const restoreCmd = defineCommand({
+  meta: {
+    name: 'restore',
+    description: 'Extract a backup tar.gz into ~/.bazilion (offline; server must be stopped)',
+  },
+  args: {
+    file: {
+      type: 'positional',
+      required: true,
+      description: 'Path to tar.gz backup file',
+    },
+    home: { type: 'string', description: 'Override BAZILION_HOME' },
+    force: {
+      type: 'boolean',
+      description: 'Overwrite existing non-empty home (destroys existing data)',
+    },
+  },
+  async run({ args }) {
+    const file = resolve(args.file)
+    if (!existsSync(file)) throw new Error(`backup file not found: ${file}`)
+
+    const paths = resolveCliPaths(args.home)
+    const targetHome = paths.home
+
+    // Only probe for a running server when restoring to the default home —
+    // an explicit `--home` points somewhere the running daemon isn't using,
+    // so there's no DB-corruption risk to warn about. `--force` bypasses
+    // the probe either way.
+    const defaultHome = !args.home && !process.env.BAZILION_HOME
+    if (defaultHome && !args.force && (await probeServerRunning(4321))) {
+      throw new Error(
+        'bazilion server appears to be running on :4321 — stop it first (DB ' +
+          'corruption risk), or pass --force to override.',
+      )
+    }
+
+    if (existsSync(targetHome)) {
+      const entries = readdirSync(targetHome)
+      if (entries.length > 0) {
+        if (!args.force) {
+          throw new Error(
+            `${targetHome} is not empty. Pass --force to overwrite (destroys existing data).`,
+          )
+        }
+        rmSync(targetHome, { recursive: true, force: true })
+      }
+    }
+    mkdirSync(targetHome, { recursive: true })
+
+    console.log(`extracting ${file} → ${targetHome}`)
+    await new Promise<void>((res, rej) => {
+      const proc = spawn('tar', ['-xzf', file, '-C', targetHome], { stdio: 'inherit' })
+      proc.on('error', rej)
+      proc.on('exit', (code) => {
+        if (code === 0) res()
+        else rej(new Error(`tar exited with code ${code}`))
+      })
+    })
+
+    console.log(`restored to ${targetHome}`)
+    console.log('start the server with: bazilion serve  (migrations apply automatically)')
+  },
+})
+
+export const backupCommand = defineCommand({
+  meta: { name: 'backup', description: 'Create or restore a ~/.bazilion tar.gz backup' },
+  subCommands: {
+    create: createCmd,
+    restore: restoreCmd,
+  },
+  // `bazilion backup` with no positional falls through to citty's subcommand
+  // prompt ("No command specified"). The previous default (auto-download to
+  // cwd) double-fired when a subcommand was used because citty runs parent's
+  // `run` after the subcommand completes — explicit `create` / `restore` is
+  // the supported form now.
+})

package/apps/cli/src/commands/completion.ts

@@ -0,0 +1,155 @@
+import { defineCommand } from 'citty'
+
+interface CommandNode {
+  subCommands?: Record<string, CommandNode | Promise<CommandNode>>
+  args?: Record<string, { type?: string; alias?: string | string[] }>
+}
+
+interface Flatten {
+  /** full path e.g. ["agent", "chat"]; empty for the top-level root */
+  path: string[]
+  /** immediate subcommand names available at this path */
+  subs: string[]
+  /** flag tokens e.g. ["--profile", "--name", "--long", "-l"] */
+  flags: string[]
+}
+
+async function walk(cmd: CommandNode, path: string[], out: Flatten[]): Promise<void> {
+  const subsRaw = cmd.subCommands ?? {}
+  const subNames = Object.keys(subsRaw)
+  const flags = flagsOf(cmd.args ?? {})
+  out.push({ path, subs: subNames, flags })
+  for (const name of subNames) {
+    const v = subsRaw[name]
+    const sub = (await Promise.resolve(v)) as CommandNode
+    await walk(sub, [...path, name], out)
+  }
+}
+
+function flagsOf(args: Record<string, { type?: string; alias?: string | string[] }>): string[] {
+  const out: string[] = []
+  for (const [name, def] of Object.entries(args)) {
+    // Positionals don't get completed as flags.
+    if (def.type === 'positional') continue
+    out.push(`--${name}`)
+    const aliases = Array.isArray(def.alias) ? def.alias : def.alias ? [def.alias] : []
+    for (const a of aliases) out.push(a.length === 1 ? `-${a}` : `--${a}`)
+  }
+  return out
+}
+
+function bashScript(flat: Flatten[]): string {
+  const cases = flat
+    .map((f) => {
+      const key = f.path.length === 0 ? '""' : JSON.stringify(f.path.join(' '))
+      const words = [...f.subs, ...f.flags].join(' ')
+      return `    ${key})\n      COMPREPLY=($(compgen -W ${JSON.stringify(words)} -- "$cur"))\n      ;;`
+    })
+    .join('\n')
+  return `# bazilion bash completion. Install with:
+#   source <(bazilion completion bash)
+# or append to ~/.bashrc / ~/.bash_profile.
+_bazilion_completion() {
+  local cur prev cword
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  cword=$COMP_CWORD
+  # Build the current subcommand path by walking words[1..cword-1], skipping
+  # flags and their values. We don't try to parse flag arity — treating every
+  # flag as standalone is a good-enough approximation for completion.
+  local cmd=""
+  local i
+  for ((i=1; i<cword; i++)); do
+    local w="\${COMP_WORDS[i]}"
+    [[ "$w" == -* ]] && continue
+    cmd+="\${cmd:+ }$w"
+  done
+  case "$cmd" in
+${cases}
+    *)
+      COMPREPLY=()
+      ;;
+  esac
+}
+complete -F _bazilion_completion bazilion
+`
+}
+
+function zshScript(flat: Flatten[]): string {
+  // zsh bundles a bashcompinit shim; reusing the bash script sidesteps the
+  // cost of a native _arguments/_describe implementation while still giving
+  // users a working completion. Ships with a tiny preamble so zsh loads the
+  // bash compat helpers first.
+  const bash = bashScript(flat)
+  return `# bazilion zsh completion. Install with:
+#   source <(bazilion completion zsh)
+# If you don't already have bashcompinit loaded, this does it for you.
+autoload -U +X compinit && compinit
+autoload -U +X bashcompinit && bashcompinit
+${bash}`
+}
+
+function fishScript(flat: Flatten[]): string {
+  const lines: string[] = [
+    '# bazilion fish completion. Install with:',
+    '#   bazilion completion fish | source',
+    '# or write it to ~/.config/fish/completions/bazilion.fish',
+    '',
+    'complete -c bazilion -f',
+  ]
+  for (const f of flat) {
+    if (f.path.length === 0) {
+      for (const s of f.subs) lines.push(`complete -c bazilion -n '__fish_use_subcommand' -a ${s}`)
+      for (const fl of f.flags) {
+        const long = fl.startsWith('--') ? fl.slice(2) : ''
+        const short = !fl.startsWith('--') ? fl.slice(1) : ''
+        const parts: string[] = ["complete -c bazilion -n '__fish_use_subcommand'"]
+        if (short) parts.push(`-s ${short}`)
+        if (long) parts.push(`-l ${long}`)
+        lines.push(parts.join(' '))
+      }
+    } else {
+      // Guard this case on the joined path being the last N tokens in
+      // COMP_CWORDS — fish's __fish_seen_subcommand_from handles each token
+      // independently, so we require every path segment.
+      const guard = f.path.map((p) => `__fish_seen_subcommand_from ${p}`).join('; and ')
+      for (const s of f.subs) {
+        lines.push(`complete -c bazilion -n '${guard}' -a ${s}`)
+      }
+      for (const fl of f.flags) {
+        const long = fl.startsWith('--') ? fl.slice(2) : ''
+        const short = !fl.startsWith('--') ? fl.slice(1) : ''
+        const parts: string[] = [`complete -c bazilion -n '${guard}'`]
+        if (short) parts.push(`-s ${short}`)
+        if (long) parts.push(`-l ${long}`)
+        lines.push(parts.join(' '))
+      }
+    }
+  }
+  return `${lines.join('\n')}\n`
+}
+
+export function completionCommand(main: CommandNode) {
+  return defineCommand({
+    meta: {
+      name: 'completion',
+      description: 'Print a shell completion script (bash, zsh, or fish)',
+    },
+    args: {
+      shell: {
+        type: 'positional',
+        required: true,
+        description: 'bash | zsh | fish',
+      },
+    },
+    async run({ args }) {
+      const flat: Flatten[] = []
+      await walk(main, [], flat)
+      const shell = String(args.shell).toLowerCase()
+      if (shell === 'bash') console.log(bashScript(flat))
+      else if (shell === 'zsh') console.log(zshScript(flat))
+      else if (shell === 'fish') console.log(fishScript(flat))
+      else throw new Error(`unsupported shell: ${args.shell} (want bash | zsh | fish)`)
+    },
+  })
+}

package/apps/cli/src/commands/config.ts

@@ -0,0 +1,95 @@
+import type {
+  ProviderConfigResponse,
+  ServiceCard,
+  ServiceConfigResponse,
+  ServiceFieldState,
+  SetFieldRequest,
+} from '@bazilion/api-types'
+import { defineCommand } from 'citty'
+import { createClient } from '../client.ts'
+import { columnize } from '../columnize.ts'
+
+function displayValue(f: ServiceFieldState): string {
+  if (!f.set) return '(unset)'
+  if (f.kind === 'secret') return f.preview ?? '(set)'
+  return f.value ?? '(set)'
+}
+
+const listCmd = defineCommand({
+  meta: {
+    name: 'list',
+    description: 'List every configurable field (credentials + URLs) across all services',
+  },
+  async run() {
+    const client = createClient()
+    // Both endpoints return ServiceCard-shaped entries — merge and print.
+    const { providers } = await client.get<ProviderConfigResponse>('/api/config/providers')
+    const { services } = await client.get<ServiceConfigResponse>('/api/config/services')
+    const all: ServiceCard[] = [...providers, ...services]
+
+    const rows: string[][] = []
+    for (const svc of all) {
+      for (const f of svc.fields) {
+        rows.push([svc.id, f.envVar, f.kind, displayValue(f)])
+      }
+    }
+    if (rows.length === 0) {
+      console.log('(no fields registered)')
+      return
+    }
+    for (const line of columnize(rows)) console.log(line)
+  },
+})
+
+const setCmd = defineCommand({
+  meta: {
+    name: 'set',
+    description: 'Set a configurable field (auto-routes to secrets or plaintext store)',
+  },
+  args: {
+    envVar: {
+      type: 'positional',
+      required: true,
+      description: 'Env var name (e.g. ANTHROPIC_API_KEY, LMSTUDIO_URL)',
+    },
+    value: {
+      type: 'positional',
+      required: true,
+      description: 'New value (empty string clears the field)',
+    },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const body: SetFieldRequest = { value: args.value }
+    const state = await client.put<ServiceFieldState>(
+      `/api/config/fields/${encodeURIComponent(args.envVar)}`,
+      body,
+    )
+    console.log(`${state.envVar} (${state.kind}): ${displayValue(state)}`)
+  },
+})
+
+const rmCmd = defineCommand({
+  meta: { name: 'rm', description: 'Remove a configurable field value' },
+  args: {
+    envVar: { type: 'positional', required: true, description: 'Env var name to clear' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    await client.del(`/api/config/fields/${encodeURIComponent(args.envVar)}`)
+    console.log(`removed ${args.envVar}`)
+  },
+})
+
+export const configCommand = defineCommand({
+  meta: {
+    name: 'config',
+    description:
+      'Manage service configuration — credentials (encrypted) and URLs/IDs (plaintext), unified under one CLI',
+  },
+  subCommands: {
+    list: listCmd,
+    set: setCmd,
+    rm: rmCmd,
+  },
+})

package/apps/cli/src/commands/doctor.ts

@@ -0,0 +1,131 @@
+import type { HealthReport } from '@bazilion/api-types'
+import { defineCommand } from 'citty'
+import { createClient } from '../client.ts'
+
+export const doctorCommand = defineCommand({
+  meta: { name: 'doctor', description: 'Diagnose your bazilion install' },
+  async run() {
+    const client = createClient()
+    const r = await client.get<HealthReport>('/api/health')
+
+    function check(label: string, condition: boolean, hint?: string): void {
+      const mark = condition ? '✓' : '✗'
+      const tail = !condition && hint ? ` — ${hint}` : ''
+      console.log(`  ${mark} ${label}${tail}`)
+    }
+
+    console.log(`bazilion home: ${r.home}`)
+    console.log()
+    console.log('paths')
+    check('home dir exists', r.paths.home)
+    check('database exists', r.paths.db, 'run: bazilion serve (auto-bootstraps on first run)')
+    check('auth.json exists', r.paths.auth, 'run: bazilion serve (auto-bootstraps on first run)')
+    check('profiles dir exists', r.paths.profiles)
+    check('agents dir exists', r.paths.agents)
+    check('skills dir exists', r.paths.skills)
+
+    if (r.database) {
+      console.log()
+      console.log('database')
+      if (r.database.ok) {
+        console.log(`  ${r.database.profiles} profile(s)`)
+        console.log(
+          `  ${r.database.activeAgents} active agent(s) (${r.database.totalAgents} total)`,
+        )
+        console.log(`  ${r.database.groups} group(s)`)
+      } else {
+        check('open database', false, r.database.error)
+      }
+    }
+
+    console.log()
+    console.log('skills library')
+    console.log(`  ${r.skills.installed} skill(s) installed`)
+    if (r.skills.parseErrors > 0) {
+      check('all skills parse', false, `${r.skills.parseErrors} skill(s) have errors`)
+    }
+
+    console.log()
+    console.log('providers (at least one needed for chat)')
+    if (r.providers.configured.length === 0) {
+      console.log('  - no cloud providers configured')
+      console.log('    (set e.g. ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY)')
+    } else {
+      for (const name of r.providers.configured) {
+        console.log(`  ✓ ${name}`)
+      }
+    }
+    console.log(
+      `  ✓ lmstudio: ${r.providers.lmstudio.baseURL}${
+        r.providers.lmstudio.hasKey ? ' (api key set)' : ''
+      }`,
+    )
+    console.log(`  ✓ ollama:   ${r.providers.ollama.baseURL}`)
+
+    console.log()
+    console.log('web search (at least one needed for web_search tool)')
+    if (r.webSearch.bravePreview) {
+      console.log(`  ✓ Brave Search (BRAVE_API_KEY set, ${r.webSearch.bravePreview})`)
+    } else {
+      console.log('  - Brave Search (set BRAVE_API_KEY — free at https://brave.com/search/api/)')
+    }
+    if (r.webSearch.searxngUrl) {
+      console.log(`  ✓ SearXNG: ${r.webSearch.searxngUrl}`)
+    } else {
+      console.log('  - SearXNG (set SEARXNG_URL if you self-host one)')
+    }
+    if (!r.webSearch.bravePreview && !r.webSearch.searxngUrl) {
+      console.log('  ⚠ no search backend — web_search will error until one is configured')
+    }
+
+    console.log()
+    console.log('openclaw integration')
+    if (r.openclaw.exists) {
+      console.log(`  ✓ ${r.openclaw.path} found`)
+      console.log('    try: bazilion skill import --from openclaw')
+    } else {
+      console.log(`  - ${r.openclaw.path} not found (fine if you don't use OpenClaw)`)
+    }
+
+    console.log()
+    console.log('background jobs')
+    console.log(
+      `  ${r.scheduler.enabled ? '✓' : '-'} scheduler${
+        r.scheduler.enabled ? ` (tick ${r.scheduler.tickMs}ms)` : ' (BAZILION_SCHEDULER=off)'
+      }`,
+    )
+
+    console.log()
+    console.log('operational counts')
+    console.log(`  ${r.triggers.active} active trigger(s), ${r.triggers.disabled} disabled`)
+    console.log(`  ${r.tokens.active} active web token(s)`)
+
+    const anyCloudProvider = r.providers.configured.length > 0
+    const hasProfiles = (r.database?.ok ? r.database.profiles : 0) > 0
+    const hasAgents = (r.database?.ok ? r.database.totalAgents : 0) > 0
+
+    console.log()
+    if (!r.ok) {
+      console.log('issues found ✗')
+      process.exit(1)
+    }
+    // Install is structurally healthy. Differentiate "ready to use" from "just
+    // initialized" so a fresh install doesn't masquerade as fully configured.
+    // (Local providers — lmstudio/ollama — are reported with default URLs
+    // whether or not they're actually running, so we can only advise; cloud
+    // providers have api keys we can check.)
+    if (!hasProfiles || !hasAgents) {
+      console.log('install is healthy, but not yet ready to run ⚠')
+      const todo: string[] = []
+      if (!anyCloudProvider) {
+        todo.push('  - set a cloud api key (ANTHROPIC_API_KEY / OPENAI_API_KEY / GEMINI_API_KEY)')
+        todo.push('    or make sure LMStudio / Ollama is running locally')
+      }
+      if (!hasProfiles) todo.push('  - create a profile: bazilion profile create <id> --model …')
+      if (!hasAgents) todo.push('  - spawn an agent: bazilion agent spawn --profile <id>')
+      for (const line of todo) console.log(line)
+    } else {
+      console.log('all good ✓')
+    }
+  },
+})

package/apps/cli/src/commands/group.ts

@@ -0,0 +1,132 @@
+import { readFileSync } from 'node:fs'
+import { stdin } from 'node:process'
+import type { Group, RegisterGroupRequest, SetGroupUserMdRequest } from '@bazilion/api-types'
+import { defineCommand } from 'citty'
+import { createClient } from '../client.ts'
+import { columnize } from '../columnize.ts'
+
+const addCmd = defineCommand({
+  meta: {
+    name: 'add',
+    description:
+      'Register a group at ~/.bazilion/groups/<slug>/ (use --link to point at an existing tree)',
+  },
+  args: {
+    id: { type: 'positional', required: true, description: 'Group slug' },
+    name: { type: 'string', description: 'Display name (defaults to slug)' },
+    link: {
+      type: 'string',
+      description: 'Absolute path of an existing directory; the group slot becomes a symlink to it',
+    },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const body: RegisterGroupRequest = {
+      id: args.id,
+      ...(args.name ? { name: args.name } : {}),
+      ...(args.link ? { link: args.link } : {}),
+    }
+    const g = await client.post<Group>('/api/groups', body)
+    console.log(`registered group ${g.id} at ${g.path}`)
+  },
+})
+
+const listCmd = defineCommand({
+  meta: { name: 'list', description: 'List groups' },
+  async run() {
+    const client = createClient()
+    const list = await client.get<Group[]>('/api/groups')
+    if (list.length === 0) {
+      console.log('(no groups)')
+      return
+    }
+    const rows = list.map((g) => [g.id, g.path])
+    for (const line of columnize(rows)) console.log(line)
+  },
+})
+
+const rmCmd = defineCommand({
+  meta: { name: 'rm', description: 'Remove a group registration' },
+  args: {
+    id: { type: 'positional', required: true },
+  },
+  async run({ args }) {
+    const client = createClient()
+    await client.del(`/api/groups/${args.id}`)
+    console.log(`removed group ${args.id}`)
+  },
+})
+
+async function readStdin(): Promise<string> {
+  const chunks: Buffer[] = []
+  for await (const chunk of stdin) chunks.push(chunk as Buffer)
+  return Buffer.concat(chunks).toString('utf8')
+}
+
+const userMdShowCmd = defineCommand({
+  meta: { name: 'show', description: "Print the group's USER.md" },
+  args: { id: { type: 'positional', required: true } },
+  async run({ args }) {
+    const client = createClient()
+    const g = await client.get<Group>(`/api/groups/${args.id}`)
+    process.stdout.write(g.userMd)
+    if (g.userMd && !g.userMd.endsWith('\n')) process.stdout.write('\n')
+  },
+})
+
+const userMdSetCmd = defineCommand({
+  meta: {
+    name: 'set',
+    description: "Replace the group's USER.md (from --file, --from-stdin, or inline text)",
+  },
+  args: {
+    id: { type: 'positional', required: true },
+    file: { type: 'string', description: 'Read content from a file path' },
+    'from-stdin': { type: 'boolean', description: 'Read content from stdin' },
+    text: { type: 'string', description: 'Inline content' },
+  },
+  async run({ args }) {
+    let content: string
+    if (args['from-stdin']) content = await readStdin()
+    else if (args.file) content = readFileSync(args.file, 'utf8')
+    else if (args.text !== undefined) content = args.text
+    else {
+      console.error('group user-md set: provide --file, --from-stdin, or --text')
+      process.exit(2)
+    }
+    const client = createClient()
+    const body: SetGroupUserMdRequest = { userMd: content }
+    await client.put(`/api/groups/${args.id}/user-md`, body)
+    console.log(`updated USER.md for group ${args.id} (${content.length} bytes)`)
+  },
+})
+
+const userMdClearCmd = defineCommand({
+  meta: { name: 'clear', description: "Clear the group's USER.md to empty" },
+  args: { id: { type: 'positional', required: true } },
+  async run({ args }) {
+    const client = createClient()
+    const body: SetGroupUserMdRequest = { userMd: '' }
+    await client.put(`/api/groups/${args.id}/user-md`, body)
+    console.log(`cleared USER.md for group ${args.id}`)
+  },
+})
+
+const userMdCmd = defineCommand({
+  meta: { name: 'user-md', description: "View or edit a group's USER.md" },
+  subCommands: {
+    show: userMdShowCmd,
+    set: userMdSetCmd,
+    clear: userMdClearCmd,
+  },
+})
+
+export const groupCommand = defineCommand({
+  meta: { name: 'group', description: 'Manage groups (collaboration contexts)' },
+  subCommands: {
+    add: addCmd,
+    list: listCmd,
+    rm: rmCmd,
+    'user-md': userMdCmd,
+  },
+})