bazilion 0.0.0

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

@@ -0,0 +1,24 @@
+import type { Message, SendMessageRequest } from '@bazilion/api-types'
+import { defineCommand } from 'citty'
+import { createClient } from '../client.ts'
+
+export const sendCommand = defineCommand({
+  meta: {
+    name: 'send',
+    description: 'Send a message from one agent to another',
+  },
+  args: {
+    from: { type: 'positional', required: true, description: 'Sender agent id' },
+    to: { type: 'positional', required: true, description: 'Recipient agent id' },
+    message: { type: 'positional', required: true, description: 'Message text' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const body: SendMessageRequest = {
+      from: args.from,
+      payload: { text: args.message },
+    }
+    const msg = await client.post<Message>(`/api/agents/${args.to}/messages`, body)
+    console.log(`sent message ${msg.id}`)
+  },
+})

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

@@ -0,0 +1,89 @@
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { defineCommand } from 'citty'
+
+// apps/cli/src/commands/serve.ts → apps/daemon/src/index.ts
+const daemonEntry = join(import.meta.dirname, '..', '..', '..', 'daemon', 'src', 'index.ts')
+
+export const serveCommand = defineCommand({
+  meta: {
+    name: 'serve',
+    description: 'Start the bazilion daemon (HTTP API)',
+  },
+  args: {
+    port: { type: 'string', description: 'Port (default 4321)' },
+    host: {
+      type: 'string',
+      description: 'Host (default 127.0.0.1). Put a TLS proxy in front before binding 0.0.0.0',
+    },
+  },
+  async run({ args }) {
+    if (!existsSync(daemonEntry)) {
+      throw new Error(
+        `bazilion daemon not found at ${daemonEntry}. Are you running from a development checkout?`,
+      )
+    }
+
+    const env: NodeJS.ProcessEnv = { ...process.env }
+    if (args.port) env.PORT = args.port
+    if (args.host) env.HOST = args.host
+
+    const host = args.host ?? '127.0.0.1'
+    const port = args.port ?? '4321'
+
+    if (host !== '127.0.0.1' && host !== 'localhost' && host !== '::1') {
+      console.error('')
+      console.error(`⚠ binding to ${host} — the daemon is now reachable beyond loopback.`)
+      console.error('  anyone on this network who has a valid token can reach every API.')
+      console.error('  put a TLS proxy in front for untrusted networks.')
+      console.error('')
+    }
+
+    console.log(`starting bazilion daemon at http://${host}:${port}`)
+    console.log('(web UI runs separately: cd apps/web && pnpm dev)')
+
+    // Spawn the daemon under tsx. Stdio inherited so the daemon's startup log
+    // and any console.error go to the user's terminal directly. The daemon
+    // installs its own SIGINT/SIGTERM handlers and shuts the HTTP server
+    // gracefully — we just need to keep this process alive long enough for it.
+    //
+    // No vite anywhere in this tree → the daemon never flips the TTY into raw
+    // mode, so the post-Ctrl+C arrow-key-echo bug is gone by construction.
+    const proc = spawn('node', ['--import', 'tsx/esm', daemonEntry], {
+      env,
+      stdio: 'inherit',
+    })
+
+    let signalled = false
+    const onSigterm = (): void => {
+      signalled = true
+      try {
+        proc.kill('SIGTERM')
+      } catch {}
+    }
+    // SIGINT from the kernel (Ctrl+C) goes to the foreground pgroup, so the
+    // daemon already gets it directly — we just have to stay alive.
+    process.on('SIGINT', () => {
+      signalled = true
+    })
+    process.on('SIGTERM', onSigterm)
+
+    await new Promise<void>((resolve, reject) => {
+      proc.on('error', (err) => reject(err))
+      proc.on('close', (code) => {
+        // signalled exits get translated to 0 so the outer `pnpm tsx … serve`
+        // wrapper doesn't print `ELIFECYCLE Command failed` after a clean Ctrl+C.
+        if (signalled) {
+          process.exitCode = 0
+          resolve()
+        } else if (code === 0 || code === null) {
+          resolve()
+        } else {
+          process.exitCode = code
+          resolve()
+        }
+      })
+    })
+  },
+})

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

@@ -0,0 +1,120 @@
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { basename, resolve } from 'node:path'
+import type {
+  ImportSkillsRequest,
+  ImportSkillsResponse,
+  ResolvedSkillsResponse,
+  SkillInfo,
+} from '@bazilion/api-types'
+import { defineCommand } from 'citty'
+import { createClient } from '../client.ts'
+import { columnize } from '../columnize.ts'
+
+const listCmd = defineCommand({
+  meta: { name: 'list', description: 'List installed skills (or those attached to an agent)' },
+  args: {
+    agent: { type: 'string', description: 'Filter to skills attached to this agent' },
+  },
+  async run({ args }) {
+    const client = createClient()
+
+    if (args.agent) {
+      const set = await client.get<ResolvedSkillsResponse>(`/api/agents/${args.agent}/skills`)
+      if (set.resolved.length === 0 && set.missing.length === 0) {
+        console.log('(no skills attached to this agent)')
+        return
+      }
+      const rows = set.resolved.map((s) => [s.name, s.description])
+      for (const line of columnize(rows)) console.log(line)
+      for (const m of set.missing) {
+        console.log(`(missing: ${m.name} — ${m.reason})`)
+      }
+      return
+    }
+
+    const skills = await client.get<SkillInfo[]>('/api/skills')
+    if (skills.length === 0) {
+      console.log('(no skills installed; use "bazilion skill import" to add some)')
+      return
+    }
+    const rows = skills.map((s) => [
+      s.name,
+      s.parseError ? `(parse error: ${s.parseError})` : s.description,
+    ])
+    for (const line of columnize(rows)) console.log(line)
+  },
+})
+
+const importCmd = defineCommand({
+  meta: {
+    name: 'import',
+    description: 'Import skills from openclaw, a directory, or a local .zip archive',
+  },
+  args: {
+    from: {
+      type: 'string',
+      required: true,
+      description:
+        'Source: "openclaw", a filesystem path on the server, or a local .zip file to upload',
+    },
+    force: { type: 'boolean', description: 'Overwrite existing skills' },
+  },
+  async run({ args }) {
+    const client = createClient()
+
+    // Auto-detect local .zip uploads: if `--from` points at an existing local
+    // file ending in .zip, stream it to the server as multipart. Otherwise
+    // fall through to the legacy JSON path (server reads the source directly).
+    const absFrom = resolve(args.from)
+    const isLocalZip =
+      args.from.toLowerCase().endsWith('.zip') && existsSync(absFrom) && statSync(absFrom).isFile()
+
+    let result: ImportSkillsResponse
+    if (isLocalZip) {
+      const bytes = readFileSync(absFrom)
+      const file = new File([bytes], basename(absFrom), { type: 'application/zip' })
+      const fd = new FormData()
+      fd.set('file', file)
+      if (args.force) fd.set('force', 'true')
+      result = await client.postMultipart<ImportSkillsResponse>('/api/skills/import', fd)
+    } else {
+      const body: ImportSkillsRequest = {
+        source: args.from,
+        force: args.force,
+      }
+      result = await client.post<ImportSkillsResponse>('/api/skills/import', body)
+    }
+
+    if (result.imported.length === 0 && result.skipped.length === 0) {
+      console.log('(nothing to import)')
+      return
+    }
+    for (const name of result.imported) {
+      console.log(`imported ${name}`)
+    }
+    for (const s of result.skipped) {
+      console.log(`skipped ${s.name}: ${s.reason}`)
+    }
+  },
+})
+
+const rmCmd = defineCommand({
+  meta: { name: 'rm', description: 'Remove an installed skill' },
+  args: {
+    name: { type: 'positional', required: true },
+  },
+  async run({ args }) {
+    const client = createClient()
+    await client.del(`/api/skills/${encodeURIComponent(args.name)}`)
+    console.log(`removed skill ${args.name}`)
+  },
+})
+
+export const skillCommand = defineCommand({
+  meta: { name: 'skill', description: 'Manage the skill library' },
+  subCommands: {
+    list: listCmd,
+    import: importCmd,
+    rm: rmCmd,
+  },
+})

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

@@ -0,0 +1,148 @@
+import { networkInterfaces } from 'node:os'
+import type {
+  CreateTokenRequest,
+  CreateTokenResponse,
+  ListTokensResponse,
+  WebToken,
+} from '@bazilion/api-types'
+import { defineCommand } from 'citty'
+import qrcode from 'qrcode-terminal'
+import { readAuthFile } from '../auth-file.ts'
+import { createClient, loadClientConfig } from '../client.ts'
+import { columnize } from '../columnize.ts'
+import { resolveCliPaths } from '../paths.ts'
+
+function tokenRow(t: WebToken): string[] {
+  const last = t.lastUsedAt ? new Date(t.lastUsedAt).toISOString() : '(never)'
+  const state = t.revokedAt ? 'revoked' : 'active'
+  return [t.id, state, t.label, `last: ${last}`]
+}
+
+/**
+ * Best-effort LAN host detection for QR pairing. A phone can't reach
+ * `127.0.0.1`, so when the server URL is loopback we swap in a routable
+ * interface address. Multi-NIC machines get a warning listing every
+ * candidate — the user can override with --server.
+ */
+function detectLanOrigin(port: string): { origin: string; warning?: string } | null {
+  const candidates: string[] = []
+  for (const ifs of Object.values(networkInterfaces())) {
+    for (const i of ifs ?? []) {
+      if (i.family === 'IPv4' && !i.internal) candidates.push(i.address)
+    }
+  }
+  const [first, ...rest] = candidates
+  if (!first) return null
+  const origin = `http://${first}:${port}`
+  return rest.length > 0
+    ? { origin, warning: `multiple LAN IPs found (${candidates.join(', ')}) — using ${first}` }
+    : { origin }
+}
+
+function resolveQrServer(override: string | undefined): string {
+  if (override) return override.replace(/\/$/, '')
+
+  const cfg = loadClientConfig()
+  const current = new URL(cfg.serverUrl)
+  const isLoopback =
+    current.hostname === '127.0.0.1' ||
+    current.hostname === 'localhost' ||
+    current.hostname === '::1'
+
+  if (!isLoopback) return cfg.serverUrl.replace(/\/$/, '')
+
+  const detected = detectLanOrigin(current.port || '4321')
+  if (!detected) {
+    throw new Error(
+      'server URL is loopback-only and no LAN interface was found. ' +
+        'Pass --server http://<host>:<port> so the mobile client knows where to connect.',
+    )
+  }
+  if (detected.warning) console.warn(`⚠ ${detected.warning}`)
+  return detected.origin
+}
+
+const createCmd = defineCommand({
+  meta: { name: 'create', description: 'Mint a new web token (shown once)' },
+  args: {
+    label: { type: 'positional', required: true, description: 'Human-readable label' },
+    qr: {
+      type: 'boolean',
+      description: 'Also render a pairing QR code for mobile clients (bazilion://pair?...)',
+    },
+    server: {
+      type: 'string',
+      description:
+        'Server URL to embed in the pairing QR (default: detect LAN IP; ignored without --qr)',
+    },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const body: CreateTokenRequest = { label: args.label }
+    const res = await client.post<CreateTokenResponse>('/api/tokens', body)
+    console.log(`id:    ${res.meta.id}`)
+    console.log(`label: ${res.meta.label}`)
+    console.log(`token: ${res.token}`)
+    console.log('')
+    console.log('store the token now — it is not recoverable later.')
+
+    if (!args.qr) return
+
+    const serverUrl = resolveQrServer(args.server)
+    const pairUrl = `bazilion://pair?server=${encodeURIComponent(serverUrl)}&token=${encodeURIComponent(res.token)}`
+    console.log('')
+    console.log(`pairing URL: ${pairUrl}`)
+    console.log('')
+    qrcode.generate(pairUrl, { small: true }, (qr) => console.log(qr))
+  },
+})
+
+const listCmd = defineCommand({
+  meta: { name: 'list', description: 'List web tokens' },
+  args: {
+    all: { type: 'boolean', description: 'Include revoked tokens' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const qs = args.all ? '?includeRevoked=1' : ''
+    const { tokens } = await client.get<ListTokensResponse>(`/api/tokens${qs}`)
+    if (tokens.length === 0) {
+      console.log('(no tokens)')
+      return
+    }
+    for (const line of columnize(tokens.map(tokenRow))) console.log(line)
+  },
+})
+
+const showLocalCmd = defineCommand({
+  meta: {
+    name: 'show-local',
+    description: 'Print the bootstrap web token stored in ~/.bazilion/auth.json',
+  },
+  run() {
+    const paths = resolveCliPaths()
+    console.log(readAuthFile(paths.authFile).token)
+  },
+})
+
+const revokeCmd = defineCommand({
+  meta: { name: 'revoke', description: 'Revoke a web token' },
+  args: {
+    id: { type: 'positional', required: true },
+  },
+  async run({ args }) {
+    const client = createClient()
+    await client.del(`/api/tokens/${args.id}`)
+    console.log(`revoked token ${args.id}`)
+  },
+})
+
+export const tokenCommand = defineCommand({
+  meta: { name: 'token', description: 'Manage web tokens for API/CLI clients' },
+  subCommands: {
+    create: createCmd,
+    list: listCmd,
+    revoke: revokeCmd,
+    'show-local': showLocalCmd,
+  },
+})

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

@@ -0,0 +1,129 @@
+import type {
+  AgentTrigger,
+  CreateTriggerRequest,
+  CreateTriggerResponse,
+  ListTriggersResponse,
+  UpdateTriggerRequest,
+} 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: 'Add a heartbeat / cron trigger to an agent' },
+  args: {
+    agent: { type: 'positional', required: true },
+    every: {
+      type: 'string',
+      description: 'Interval in seconds (e.g. --every 300 = every 5 minutes)',
+    },
+    cron: {
+      type: 'string',
+      description: 'Cron expression (5 fields: minute hour dom month dow)',
+    },
+    message: {
+      type: 'string',
+      required: true,
+      description: 'Message to inject when the trigger fires',
+    },
+    disabled: { type: 'boolean', description: 'Create in disabled state' },
+  },
+  async run({ args }) {
+    if (!args.every === !args.cron) {
+      throw new Error('specify exactly one of --every <seconds> or --cron "<expr>"')
+    }
+    const client = createClient()
+    const body: CreateTriggerRequest = args.every
+      ? {
+          kind: 'interval',
+          intervalSec: Number(args.every),
+          message: args.message,
+          enabled: !args.disabled,
+        }
+      : {
+          kind: 'cron',
+          cronExpr: args.cron as string,
+          message: args.message,
+          enabled: !args.disabled,
+        }
+    const res = await client.post<CreateTriggerResponse>(`/api/agents/${args.agent}/triggers`, body)
+    const t = res.trigger
+    const spec = t.kind === 'interval' ? `every ${t.intervalSec}s` : `cron "${t.cronExpr}"`
+    console.log(`${t.id}\t${spec}\t${t.enabled ? 'enabled' : 'disabled'}`)
+  },
+})
+
+function triggerRow(t: AgentTrigger): string[] {
+  const spec = t.kind === 'interval' ? `every ${t.intervalSec}s` : `cron "${t.cronExpr}"`
+  const last = t.lastFiredAt ? new Date(t.lastFiredAt).toISOString() : '(never)'
+  const state = t.enabled ? 'enabled' : 'disabled'
+  const msgPreview = t.message.length > 60 ? `${t.message.slice(0, 60)}…` : t.message
+  return [t.id, state, spec, `last: ${last}`, `"${msgPreview}"`]
+}
+
+const listCmd = defineCommand({
+  meta: { name: 'list', description: 'List triggers for an agent' },
+  args: {
+    agent: { type: 'positional', required: true },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const { triggers } = await client.get<ListTriggersResponse>(
+      `/api/agents/${args.agent}/triggers`,
+    )
+    if (triggers.length === 0) {
+      console.log('(no triggers)')
+      return
+    }
+    for (const line of columnize(triggers.map(triggerRow))) console.log(line)
+  },
+})
+
+const rmCmd = defineCommand({
+  meta: { name: 'rm', description: 'Delete a trigger' },
+  args: {
+    id: { type: 'positional', required: true },
+  },
+  async run({ args }) {
+    const client = createClient()
+    await client.del(`/api/triggers/${args.id}`)
+    console.log(`removed trigger ${args.id}`)
+  },
+})
+
+const enableCmd = defineCommand({
+  meta: { name: 'enable', description: 'Enable a trigger' },
+  args: {
+    id: { type: 'positional', required: true },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const body: UpdateTriggerRequest = { enabled: true }
+    await client.patch(`/api/triggers/${args.id}`, body)
+    console.log(`enabled trigger ${args.id}`)
+  },
+})
+
+const disableCmd = defineCommand({
+  meta: { name: 'disable', description: 'Disable a trigger' },
+  args: {
+    id: { type: 'positional', required: true },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const body: UpdateTriggerRequest = { enabled: false }
+    await client.patch(`/api/triggers/${args.id}`, body)
+    console.log(`disabled trigger ${args.id}`)
+  },
+})
+
+export const triggerCommand = defineCommand({
+  meta: { name: 'trigger', description: 'Manage agent heartbeats / cron triggers' },
+  subCommands: {
+    add: addCmd,
+    list: listCmd,
+    rm: rmCmd,
+    enable: enableCmd,
+    disable: disableCmd,
+  },
+})

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

@@ -0,0 +1,156 @@
+import { existsSync, readdirSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { defineCommand } from 'citty'
+import { resolveCliPaths } from '../paths.ts'
+
+// Line-buffered stdin reader. `node:readline/promises` drops data after EOF
+// on piped input (a known Node quirk with back-to-back `question()` calls),
+// so we read chunks ourselves and emit one line per call.
+function makeLineReader(): () => Promise<string> {
+  let buffer = ''
+  let ended = false
+  const queue: ((line: string) => void)[] = []
+
+  const tryDeliver = (): void => {
+    while (queue.length > 0) {
+      const nlIdx = buffer.indexOf('\n')
+      if (nlIdx === -1) {
+        if (ended) {
+          const resolve = queue.shift()
+          resolve?.(buffer)
+          buffer = ''
+        } else {
+          return
+        }
+      } else {
+        const line = buffer.slice(0, nlIdx)
+        buffer = buffer.slice(nlIdx + 1)
+        const resolve = queue.shift()
+        resolve?.(line)
+      }
+    }
+  }
+
+  process.stdin.setEncoding('utf8')
+  process.stdin.on('data', (chunk) => {
+    buffer += chunk
+    tryDeliver()
+  })
+  process.stdin.on('end', () => {
+    ended = true
+    tryDeliver()
+  })
+
+  return () =>
+    new Promise<string>((resolve) => {
+      queue.push(resolve)
+      tryDeliver()
+    })
+}
+
+async function askYes(readLine: () => Promise<string>, prompt: string): Promise<boolean> {
+  process.stdout.write(`${prompt} [y/N] `)
+  const answer = (await readLine()).trim().toLowerCase()
+  return answer === 'y' || answer === 'yes'
+}
+
+function removePath(p: string): boolean {
+  if (!existsSync(p)) return false
+  rmSync(p, { recursive: true, force: true })
+  return true
+}
+
+export const uninstallCommand = defineCommand({
+  meta: {
+    name: 'uninstall',
+    description: 'Wipe bazilion state from ~/.bazilion (or BAZILION_HOME)',
+  },
+  args: {
+    home: { type: 'string', description: 'Override BAZILION_HOME' },
+    yes: {
+      type: 'boolean',
+      description: 'Skip confirmations (data tier only unless --all is set)',
+    },
+    all: {
+      type: 'boolean',
+      description: 'Also remove configs, logs, and skills (full wipe)',
+    },
+  },
+  async run({ args }) {
+    const paths = resolveCliPaths(args.home)
+    const dbFile = join(paths.home, 'bazilion.db')
+    const profilesDir = join(paths.home, 'profiles')
+    const agentsDir = join(paths.home, 'agents')
+    const groupsDir = join(paths.home, 'groups')
+    const skillsDir = join(paths.home, 'skills')
+    const logsDir = join(paths.home, 'logs')
+
+    if (!existsSync(paths.home)) {
+      console.log(`nothing to remove: ${paths.home} does not exist`)
+      return
+    }
+
+    console.log(`about to uninstall bazilion at ${paths.home}`)
+    console.log('')
+
+    const dataTargets = [
+      dbFile,
+      `${dbFile}-wal`,
+      `${dbFile}-shm`,
+      profilesDir,
+      agentsDir,
+      groupsDir,
+    ]
+
+    const needsPrompt = !args.yes
+    const readLine = needsPrompt ? makeLineReader() : null
+    const wipeData =
+      args.yes ||
+      (await askYes(
+        readLine as () => Promise<string>,
+        'remove DB + agent / profile / workspace data?',
+      ))
+    if (!wipeData) {
+      console.log('aborted')
+      process.stdin.pause()
+      return
+    }
+
+    // Tier 2: ask only after data wipe is confirmed — configs/logs/skills are
+    // reusable across reinstalls, so the two-tier split lets an operator
+    // factory-reset agents while keeping credentials + imported skills.
+    const wipeAll =
+      args.all ||
+      (args.yes
+        ? false
+        : await askYes(
+            readLine as () => Promise<string>,
+            'also remove configs, logs, and skills? (full wipe of ~/.bazilion)',
+          ))
+
+    process.stdin.pause()
+
+    for (const p of dataTargets) {
+      if (removePath(p)) console.log(`removed ${p}`)
+    }
+
+    if (wipeAll) {
+      const configTargets = [paths.authFile, logsDir, skillsDir]
+      for (const p of configTargets) {
+        if (removePath(p)) console.log(`removed ${p}`)
+      }
+      // If nothing else is left in $BAZILION_HOME, drop the empty dir too so
+      // a subsequent `bazilion serve` re-bootstraps into a truly fresh home.
+      if (readdirSync(paths.home).length === 0) {
+        rmSync(paths.home, { recursive: true, force: true })
+        console.log(`removed ${paths.home}`)
+      } else {
+        console.log(`${paths.home} still has unmanaged files; left in place`)
+      }
+    } else {
+      console.log('')
+      console.log('kept: auth.json, logs/, skills/')
+      console.log(`re-run 'bazilion serve' to recreate the DB when you're ready.`)
+    }
+  },
+})