bazilion 0.0.0 → 0.1.0

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

@@ -1,264 +0,0 @@
-// Per-service field registry — the shape of the /config page.
-//
-// Each entry describes one "thing" the user might configure: an LLM provider
-// (Anthropic, LM Studio, …) or an ancillary service (Brave Search, SearXNG).
-// Fields know which storage backend they live in: `secret` → the encrypted
-// `secrets` table, `config` → the plaintext `config` table. The registry is
-// the single source of truth for the UI layout and for the generic
-// field-write endpoint's dispatch.
-//
-// When adding a new provider or service, append an entry here and the
-// config page + CLI pick it up automatically.
-
-export type FieldKind = 'secret' | 'config'
-
-export interface ServiceField {
-  /** Env var name — canonical key in both stores. */
-  envVar: string
-  kind: FieldKind
-  label: string
-  placeholder?: string
-  description?: string
-}
-
-export type ServiceCategory = 'provider' | 'service'
-
-export interface ServiceDef {
-  /** Matches the provider-registry key for providers (e.g. 'anthropic'). */
-  id: string
-  displayName: string
-  category: ServiceCategory
-  /** Sign-up link, docs, or 1-line description shown on the card. */
-  hint?: string
-  fields: ServiceField[]
-}
-
-/**
- * One-liner: what's shown on each service card.
- * Order here is the display order on the config page.
- */
-export const SERVICES: ServiceDef[] = [
-  // --- LLM providers (configured via API keys / URLs) ---
-  {
-    id: 'anthropic',
-    displayName: 'Anthropic',
-    category: 'provider',
-    hint: 'Claude models · console.anthropic.com',
-    fields: [
-      { envVar: 'ANTHROPIC_API_KEY', kind: 'secret', label: 'API key', placeholder: 'sk-ant-...' },
-      {
-        envVar: 'ANTHROPIC_OAUTH_TOKEN',
-        kind: 'secret',
-        label: 'OAuth token (alternative to API key)',
-        description: 'Takes precedence over ANTHROPIC_API_KEY when set',
-      },
-    ],
-  },
-  {
-    id: 'openai',
-    displayName: 'OpenAI',
-    category: 'provider',
-    hint: 'GPT models · platform.openai.com',
-    fields: [{ envVar: 'OPENAI_API_KEY', kind: 'secret', label: 'API key', placeholder: 'sk-...' }],
-  },
-  {
-    id: 'openai-codex',
-    displayName: 'OpenAI ChatGPT (OAuth)',
-    category: 'provider',
-    hint: 'Use your ChatGPT Plus/Pro/Team account (same login as Codex CLI)',
-    // No form fields — credentials come from an OAuth flow. The /config page
-    // renders a Connect/Disconnect card using /api/auth/openai instead of the
-    // standard field inputs.
-    fields: [],
-  },
-  {
-    id: 'google',
-    displayName: 'Google (Gemini)',
-    category: 'provider',
-    hint: 'Gemini models · ai.google.dev (free tier available)',
-    fields: [
-      { envVar: 'GEMINI_API_KEY', kind: 'secret', label: 'API key', placeholder: 'AIza...' },
-    ],
-  },
-  {
-    id: 'google-vertex',
-    displayName: 'Google Vertex AI',
-    category: 'provider',
-    hint: 'Authenticates via `gcloud auth application-default login`',
-    fields: [
-      {
-        envVar: 'GOOGLE_CLOUD_PROJECT',
-        kind: 'config',
-        label: 'GCP project ID',
-        placeholder: 'my-project-123456',
-      },
-      {
-        envVar: 'GOOGLE_CLOUD_LOCATION',
-        kind: 'config',
-        label: 'GCP region',
-        placeholder: 'us-central1',
-      },
-    ],
-  },
-  {
-    id: 'azure-openai',
-    displayName: 'Azure OpenAI',
-    category: 'provider',
-    fields: [{ envVar: 'AZURE_OPENAI_API_KEY', kind: 'secret', label: 'API key' }],
-  },
-  {
-    id: 'bedrock',
-    displayName: 'Amazon Bedrock',
-    category: 'provider',
-    hint: 'Authenticates via AWS SDK env (AWS_PROFILE or AWS_ACCESS_KEY_ID/SECRET)',
-    fields: [],
-  },
-  {
-    id: 'mistral',
-    displayName: 'Mistral',
-    category: 'provider',
-    hint: 'mistral.ai',
-    fields: [{ envVar: 'MISTRAL_API_KEY', kind: 'secret', label: 'API key' }],
-  },
-  {
-    id: 'groq',
-    displayName: 'Groq',
-    category: 'provider',
-    hint: 'Fast inference · groq.com',
-    fields: [{ envVar: 'GROQ_API_KEY', kind: 'secret', label: 'API key' }],
-  },
-  {
-    id: 'cerebras',
-    displayName: 'Cerebras',
-    category: 'provider',
-    fields: [{ envVar: 'CEREBRAS_API_KEY', kind: 'secret', label: 'API key' }],
-  },
-  {
-    id: 'xai',
-    displayName: 'xAI',
-    category: 'provider',
-    hint: 'Grok · x.ai',
-    fields: [{ envVar: 'XAI_API_KEY', kind: 'secret', label: 'API key' }],
-  },
-  {
-    id: 'zai',
-    displayName: 'zAI',
-    category: 'provider',
-    fields: [{ envVar: 'ZAI_API_KEY', kind: 'secret', label: 'API key' }],
-  },
-  {
-    id: 'huggingface',
-    displayName: 'Hugging Face',
-    category: 'provider',
-    hint: 'Inference endpoints · huggingface.co',
-    fields: [{ envVar: 'HF_TOKEN', kind: 'secret', label: 'Access token', placeholder: 'hf_...' }],
-  },
-  {
-    id: 'openrouter',
-    displayName: 'OpenRouter',
-    category: 'provider',
-    hint: 'Proxy for 200+ models · openrouter.ai',
-    fields: [
-      { envVar: 'OPENROUTER_API_KEY', kind: 'secret', label: 'API key', placeholder: 'sk-or-...' },
-    ],
-  },
-  {
-    id: 'vercel-ai-gateway',
-    displayName: 'Vercel AI Gateway',
-    category: 'provider',
-    fields: [
-      { envVar: 'AI_GATEWAY_API_KEY', kind: 'secret', label: 'API key' },
-      {
-        envVar: 'AI_GATEWAY_BASE_URL',
-        kind: 'config',
-        label: 'Base URL (optional)',
-        placeholder: 'https://ai-gateway.vercel.sh/v1',
-      },
-    ],
-  },
-  {
-    id: 'lmstudio',
-    displayName: 'LM Studio',
-    category: 'provider',
-    hint: 'Local inference · lmstudio.ai',
-    fields: [
-      {
-        envVar: 'LMSTUDIO_URL',
-        kind: 'config',
-        label: 'Endpoint URL',
-        placeholder: 'http://127.0.0.1:1234/v1',
-      },
-      {
-        envVar: 'LMSTUDIO_API_KEY',
-        kind: 'secret',
-        label: 'API key (rarely needed)',
-      },
-    ],
-  },
-  {
-    id: 'ollama',
-    displayName: 'Ollama',
-    category: 'provider',
-    hint: 'Local inference · ollama.com',
-    fields: [
-      {
-        envVar: 'OLLAMA_URL',
-        kind: 'config',
-        label: 'Endpoint URL',
-        placeholder: 'http://127.0.0.1:11434/v1',
-      },
-      {
-        envVar: 'OLLAMA_API_KEY',
-        kind: 'secret',
-        label: 'API key (rarely needed)',
-      },
-    ],
-  },
-
-  // --- Ancillary services (web search, etc) ---
-  {
-    id: 'brave-search',
-    displayName: 'Brave Search',
-    category: 'service',
-    hint: 'Web search tool · free tier at brave.com/search/api/',
-    fields: [{ envVar: 'BRAVE_API_KEY', kind: 'secret', label: 'API key', placeholder: 'BSA...' }],
-  },
-  {
-    id: 'searxng',
-    displayName: 'SearXNG',
-    category: 'service',
-    hint: 'Self-hosted meta-search engine · searxng.org',
-    fields: [
-      {
-        envVar: 'SEARXNG_URL',
-        kind: 'config',
-        label: 'Instance URL',
-        placeholder: 'https://searxng.example.com',
-      },
-    ],
-  },
-]
-
-/**
- * Fast lookup: envVar → the field definition + owning service.
- * Rebuilt once at module init — the list is static.
- */
-const FIELD_INDEX: Map<string, { service: ServiceDef; field: ServiceField }> = (() => {
-  const m = new Map<string, { service: ServiceDef; field: ServiceField }>()
-  for (const service of SERVICES) {
-    for (const field of service.fields) {
-      m.set(field.envVar, { service, field })
-    }
-  }
-  return m
-})()
-
-export function findFieldByEnvVar(
-  envVar: string,
-): { service: ServiceDef; field: ServiceField } | undefined {
-  return FIELD_INDEX.get(envVar)
-}
-
-export function servicesByCategory(category: ServiceCategory): ServiceDef[] {
-  return SERVICES.filter((s) => s.category === category)
-}

package/apps/daemon/src/core/skills/discover.ts

@@ -1,28 +0,0 @@
-import { existsSync, readdirSync } from 'node:fs'
-import { join } from 'node:path'
-import type { Paths } from '../paths.ts'
-
-export interface DiscoveredSkill {
-  name: string
-  dir: string
-  skillFile: string
-}
-
-/**
- * Walk the bazilion skill library and return every directory that contains a
- * SKILL.md file. Pure filesystem read — does not parse the markdown.
- */
-export function discoverSkills(paths: Paths): DiscoveredSkill[] {
-  if (!existsSync(paths.skillsDir)) return []
-
-  const entries = readdirSync(paths.skillsDir, { withFileTypes: true })
-  const skills: DiscoveredSkill[] = []
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue
-    const dir = join(paths.skillsDir, entry.name)
-    const skillFile = join(dir, 'SKILL.md')
-    if (!existsSync(skillFile)) continue
-    skills.push({ name: entry.name, dir, skillFile })
-  }
-  return skills.sort((a, b) => a.name.localeCompare(b.name))
-}

package/apps/daemon/src/core/skills/import.ts

@@ -1,136 +0,0 @@
-import { cpSync, existsSync, mkdtempSync, readdirSync, rmSync, statSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { basename, join, resolve, sep } from 'node:path'
-import AdmZip from 'adm-zip'
-import type { Paths } from '../paths.ts'
-import { parseSkillFile } from './parse.ts'
-
-export interface ImportSkillsInput {
-  /**
-   * Absolute path to either:
-   *   - a single skill folder (contains SKILL.md),
-   *   - a parent directory containing multiple skill folders,
-   *   - a `.zip` file whose top level holds one-folder-per-skill (or a single
-   *     wrapping folder that holds them).
-   */
-  source: string
-  /** overwrite existing target skills */
-  force?: boolean
-}
-
-export interface ImportResult {
-  imported: string[]
-  skipped: { name: string; reason: string }[]
-}
-
-/**
- * Extract a zip archive into a fresh temp dir with a zip-slip guard — every
- * entry's resolved path must stay under the extraction root. Returns both the
- * mkdtemp root (for cleanup) and the effective source path to hand to the
- * importer. When the archive is wrapped in a single top-level directory
- * (common with GitHub-style archives), we descend into it so `source` lines
- * up with the "parent-of-skill-dirs" shape the importer already understands.
- */
-function extractZipSafely(zipPath: string): { root: string; effectiveSource: string } {
-  const root = mkdtempSync(join(tmpdir(), 'bazilion-skill-zip-'))
-  try {
-    const zip = new AdmZip(zipPath)
-    for (const entry of zip.getEntries()) {
-      const rawName = entry.entryName
-      if (rawName.startsWith('/') || rawName.startsWith('\\')) {
-        throw new Error(`zip entry has absolute path: ${rawName}`)
-      }
-      const resolved = resolve(root, rawName)
-      if (resolved !== root && !resolved.startsWith(root + sep)) {
-        throw new Error(`zip entry escapes extraction root: ${rawName}`)
-      }
-    }
-    zip.extractAllTo(root, true)
-  } catch (err) {
-    rmSync(root, { recursive: true, force: true })
-    throw err
-  }
-
-  // Unwrap a single top-level folder if present — the importer's
-  // "source-is-a-directory" cases (single-skill dir vs. parent-of-skills dir)
-  // both apply equally well to the unwrapped path.
-  let effectiveSource = root
-  const topEntries = readdirSync(root, { withFileTypes: true })
-  if (topEntries.length === 1 && topEntries[0]?.isDirectory()) {
-    effectiveSource = join(root, topEntries[0].name)
-  }
-  return { root, effectiveSource }
-}
-
-export function importSkills(paths: Paths, input: ImportSkillsInput): ImportResult {
-  const rawSource = resolve(input.source)
-  if (!existsSync(rawSource)) {
-    throw new Error(`source does not exist: ${rawSource}`)
-  }
-
-  let source = rawSource
-  let tempRoot: string | null = null
-  const sourceStat = statSync(rawSource)
-  if (sourceStat.isFile()) {
-    if (!rawSource.toLowerCase().endsWith('.zip')) {
-      throw new Error(`source file must be a .zip archive: ${rawSource}`)
-    }
-    const { root, effectiveSource } = extractZipSafely(rawSource)
-    tempRoot = root
-    source = effectiveSource
-  } else if (!sourceStat.isDirectory()) {
-    throw new Error(`source is not a directory: ${rawSource}`)
-  }
-
-  try {
-    return importSkillsFromDir(paths, source, input)
-  } finally {
-    if (tempRoot) rmSync(tempRoot, { recursive: true, force: true })
-  }
-}
-
-function importSkillsFromDir(paths: Paths, source: string, input: ImportSkillsInput): ImportResult {
-  const candidates: { name: string; dir: string }[] = []
-
-  // Two shapes are accepted:
-  //   1. source is itself a single skill dir (contains SKILL.md)
-  //   2. source is a parent containing multiple skill dirs
-  if (existsSync(join(source, 'SKILL.md'))) {
-    candidates.push({ name: basename(source), dir: source })
-  } else {
-    const entries = readdirSync(source, { withFileTypes: true })
-    for (const e of entries) {
-      if (!e.isDirectory()) continue
-      const skillDir = join(source, e.name)
-      if (!existsSync(join(skillDir, 'SKILL.md'))) continue
-      candidates.push({ name: e.name, dir: skillDir })
-    }
-  }
-
-  if (candidates.length === 0) {
-    throw new Error(`no skills found in ${source}`)
-  }
-
-  // Validate every SKILL.md before touching the target dir.
-  for (const c of candidates) {
-    parseSkillFile(join(c.dir, 'SKILL.md'))
-  }
-
-  const imported: string[] = []
-  const skipped: { name: string; reason: string }[] = []
-
-  for (const c of candidates) {
-    const target = join(paths.skillsDir, c.name)
-    if (existsSync(target) && !input.force) {
-      skipped.push({
-        name: c.name,
-        reason: 'already exists (use --force to overwrite)',
-      })
-      continue
-    }
-    cpSync(c.dir, target, { recursive: true, force: !!input.force })
-    imported.push(c.name)
-  }
-
-  return { imported, skipped }
-}

package/apps/daemon/src/core/skills/parse.ts

@@ -1,52 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { parse as parseYaml } from 'yaml'
-
-/**
- * Standard agent-skill frontmatter. Required fields are typed; the rest is open
- * (skill formats may add fields like `allowed-tools`, `homepage`, etc.).
- */
-export interface SkillFrontmatter {
-  name: string
-  description: string
-  [key: string]: unknown
-}
-
-export interface ParsedSkill {
-  frontmatter: SkillFrontmatter
-  body: string
-  raw: string
-}
-
-const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/
-
-export function parseSkillContent(raw: string): ParsedSkill {
-  const m = raw.match(FRONTMATTER_RE)
-  if (!m) {
-    throw new Error('SKILL.md missing YAML frontmatter (expected leading "---")')
-  }
-  const yamlBlock = m[1] ?? ''
-  const body = m[2] ?? ''
-
-  let fm: unknown
-  try {
-    fm = parseYaml(yamlBlock)
-  } catch (err) {
-    throw new Error(`SKILL.md frontmatter is not valid YAML: ${(err as Error).message}`)
-  }
-  if (!fm || typeof fm !== 'object' || Array.isArray(fm)) {
-    throw new Error('SKILL.md frontmatter must be a YAML object')
-  }
-  const fmObj = fm as Record<string, unknown>
-  if (typeof fmObj.name !== 'string' || fmObj.name.length === 0) {
-    throw new Error('SKILL.md frontmatter missing required "name"')
-  }
-  if (typeof fmObj.description !== 'string' || fmObj.description.length === 0) {
-    throw new Error('SKILL.md frontmatter missing required "description"')
-  }
-  return { frontmatter: fmObj as SkillFrontmatter, body, raw }
-}
-
-export function parseSkillFile(path: string): ParsedSkill {
-  const raw = readFileSync(path, 'utf8')
-  return parseSkillContent(raw)
-}

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

@@ -1,50 +0,0 @@
-import type { BazilionDb } from '../db/client.ts'
-import type { Paths } from '../paths.ts'
-import * as agentRepo from '../repos/agents.ts'
-import { discoverSkills } from './discover.ts'
-import { type ParsedSkill, parseSkillFile } from './parse.ts'
-
-export interface ResolvedSkill {
-  name: string
-  dir: string
-  parsed: ParsedSkill
-}
-
-export interface ResolvedSkillSet {
-  /** skills attached to the agent that exist and parse correctly */
-  resolved: ResolvedSkill[]
-  /** attached skill names that are missing from the library or fail to parse */
-  missing: { name: string; reason: string }[]
-}
-
-/**
- * Given an agent, return the parsed skills currently attached to it. Skill
- * attachments live in `agent_skills`; the source of truth for content is
- * `~/.bazilion/skills/<name>/SKILL.md`.
- */
-export function resolveAgentSkills(
-  db: BazilionDb,
-  paths: Paths,
-  agentId: string,
-): ResolvedSkillSet {
-  const attached = agentRepo.listAttachedSkills(db, agentId)
-  const discovered = new Map(discoverSkills(paths).map((s) => [s.name, s]))
-
-  const resolved: ResolvedSkill[] = []
-  const missing: { name: string; reason: string }[] = []
-
-  for (const name of attached) {
-    const ds = discovered.get(name)
-    if (!ds) {
-      missing.push({ name, reason: 'not in library' })
-      continue
-    }
-    try {
-      const parsed = parseSkillFile(ds.skillFile)
-      resolved.push({ name, dir: ds.dir, parsed })
-    } catch (err) {
-      missing.push({ name, reason: (err as Error).message })
-    }
-  }
-  return { resolved, missing }
-}

package/apps/daemon/src/index.ts

@@ -1,45 +0,0 @@
-// Daemon entry point. Reads HOST/PORT env, boots the Hono app, and waits on
-// SIGINT/SIGTERM for shutdown.
-//
-// This process is the single owner of `~/.bazilion`. The web app, CLI, and
-// mobile clients all talk to it over HTTP via @bazilion/client.
-
-import { serve } from '@hono/node-server'
-import { createApp } from './app.ts'
-import { getCtx } from './lib/ctx.ts'
-
-const host = process.env.HOST ?? '127.0.0.1'
-const port = Number.parseInt(process.env.PORT ?? '4321', 10)
-
-// Eagerly bootstrap ~/.bazilion (mkdir, openDb, runMigrations, mint token,
-// write auth.json) before binding the port. Otherwise the first request
-// would race with bootstrap and the operator wouldn't see the bootstrap
-// message until something actually hits the daemon.
-getCtx()
-
-const app = createApp()
-
-const server = serve({ fetch: app.fetch, hostname: host, port }, (info) => {
-  console.log(`bazilion daemon listening at http://${info.address}:${info.port}`)
-  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('')
-  }
-})
-
-const shutdown = (signal: NodeJS.Signals): void => {
-  console.log(`\nbazilion daemon caught ${signal}, shutting down…`)
-  server.close((err) => {
-    if (err) {
-      console.error('shutdown error:', err)
-      process.exit(1)
-    }
-    process.exit(0)
-  })
-}
-
-process.on('SIGINT', () => shutdown('SIGINT'))
-process.on('SIGTERM', () => shutdown('SIGTERM'))

package/apps/daemon/src/lib/agent-cancel.ts

@@ -1,48 +0,0 @@
-// In-memory registry of agents currently running a turn and their
-// AbortControllers. The chat / scheduler / inbox-wake paths register before
-// they spawn a worker; the cancel route looks the agent up and calls
-// `abort()`. Doubles as the "is this agent busy?" probe the scheduler uses
-// to skip overlapping inbox-wakes and triggers.
-//
-// Pinned to `globalThis` via a well-known Symbol so there is exactly one
-// instance per process even if a bundler ever splits this module across
-// chunks. Two different Map instances would make registrations invisible to
-// the cancel side.
-
-const REGISTRY_KEY = Symbol.for('bazilion.agent-cancel.registry')
-
-interface Registry {
-  active: Map<string, AbortController>
-}
-
-function registry(): Registry {
-  const g = globalThis as unknown as Record<symbol, Registry | undefined>
-  let r = g[REGISTRY_KEY]
-  if (!r) {
-    r = { active: new Map() }
-    g[REGISTRY_KEY] = r
-  }
-  return r
-}
-
-export function registerAgent(agentId: string, controller: AbortController): void {
-  registry().active.set(agentId, controller)
-}
-
-export function unregisterAgent(agentId: string): void {
-  registry().active.delete(agentId)
-}
-
-/** Returns true if the agent had an active turn that was aborted, false otherwise. */
-export function cancelAgent(agentId: string): boolean {
-  const { active } = registry()
-  const c = active.get(agentId)
-  if (!c) return false
-  c.abort()
-  active.delete(agentId)
-  return true
-}
-
-export function isActiveAgent(agentId: string): boolean {
-  return registry().active.has(agentId)
-}

package/apps/daemon/src/lib/agent-id.ts

@@ -1,13 +0,0 @@
-import { agentRepo, type BazilionDb } from '../core/index.ts'
-
-/**
- * Expand an agent ID prefix (from URL params) to the full UUID.
- *
- * Returns the resolved full ID when the prefix is exact or uniquely resolves;
- * returns the raw input otherwise so the caller's existing "not found" branch
- * fires with the original value in the error message.
- */
-export function resolveAgentIdParam(db: BazilionDb, raw: string | undefined): string {
-  if (!raw) return ''
-  return agentRepo.resolveId(db, raw) ?? raw
-}