bazilion 0.0.0

package/packages/api-types/src/index.ts

@@ -0,0 +1,488 @@
+// Wire-shape package. Hermetic: depends on nothing from the daemon, so every
+// client (web, mobile, cli, future SDKs) can pull in API shapes without
+// dragging Node-only code (node:sqlite, undici, pi-ai, the worker spawner)
+// into its TS check graph or runtime bundle. The daemon imports its entity
+// and wire types FROM here.
+
+export type {
+  Agent,
+  AgentIdentityFile,
+  AgentSkillAttachment,
+  AgentStatus,
+  AgentTrigger,
+  Group,
+  LoadedProfile,
+  Message,
+  OpenAICodexStatus,
+  Profile,
+  ReasoningLevel,
+  ResolvedAgent,
+  SkillMeta,
+  SkillsMode,
+  Timestamp,
+  TriggerKind,
+  WebToken,
+} from './entities.ts'
+export { REASONING_LEVELS } from './entities.ts'
+export type {
+  ChatFrame,
+  ProviderMessage,
+  Role,
+  SessionEvent,
+  ToolCall,
+  ToolDef,
+} from './events.ts'
+export type { MemoryEntry, MemoryHit } from './memory.ts'
+
+import type { AgentTrigger, Message, ReasoningLevel, WebToken } from './entities.ts'
+
+export interface ApiError {
+  error: string
+  code?: string
+}
+
+// --- agents ---
+
+export interface ListAgentsQuery {
+  includeArchived?: boolean
+}
+
+export interface SpawnAgentRequest {
+  profileId: string
+  name?: string
+  model?: string
+  reasoningLevel?: ReasoningLevel
+  /** Group the new agent joins. Falls back to the seeded 'default' group when omitted. */
+  groupId?: string
+}
+
+export interface UpdateAgentRequest {
+  modelOverride?: string | null
+  reasoningLevel?: ReasoningLevel
+}
+
+export interface AttachSkillRequest {
+  skill: string
+}
+
+/** Body for `PATCH /api/agents/:id/group`: move the agent to a new group. */
+export interface MoveAgentRequest {
+  groupId: string
+}
+
+export interface SendMessageRequest {
+  from: string
+  payload: { text: string }
+  replyTo?: string
+}
+
+export interface ListInboxQuery {
+  unread?: boolean
+}
+
+export interface ListInboxResponse {
+  messages: Message[]
+}
+
+export interface UpdateMessageRequest {
+  read: true
+}
+
+// --- profiles ---
+
+export interface UpdateProfileRequest {
+  name?: string
+  defaultModel?: string
+  skillsMode?: 'all' | 'selected'
+  defaultSkills?: string[]
+}
+
+export interface CreateProfileRequest {
+  id: string
+  name?: string
+  defaultModel: string
+  skillsMode?: 'all' | 'selected'
+  defaultSkills?: string[]
+  /** Initial SOUL.md content. Falls back to the built-in template when omitted. */
+  soul?: string
+  /** Initial IDENTITY.md content. Falls back to the built-in template when omitted. */
+  identity?: string
+  /** Initial BOOTSTRAP.md content. Omit for default; pass null to skip bootstrap entirely. */
+  bootstrap?: string | null
+  /** Initial AGENTS.md content. Omit to skip; pass a string to seed the file. */
+  agents?: string
+  /** Initial TOOLS.md content. Omit to skip; pass a string to seed the file. */
+  tools?: string
+  /** Initial HEARTBEAT.md content. Omit to skip; pass a string to seed the file. */
+  heartbeat?: string
+}
+
+// --- groups ---
+
+export interface RegisterGroupRequest {
+  /** Slug (lowercase, digits, hyphens). Becomes the row id AND the directory
+   * name under `~/.bazilion/groups/<slug>/`. */
+  id: string
+  /** Optional human-readable label. Defaults to `id`. */
+  name?: string
+  /**
+   * Optional symlink target. When set, the daemon materializes the group
+   * slot as a symlink to this absolute path instead of as a real directory
+   * — useful for "agents working on my existing project tree." Target must
+   * exist and be a directory.
+   */
+  link?: string
+}
+
+/** Body for `PUT /api/groups/:id/user-md`. */
+export interface SetGroupUserMdRequest {
+  userMd: string
+}
+
+// --- skills (write) ---
+
+export interface ImportSkillsRequest {
+  source: string
+  force?: boolean
+}
+
+export interface ImportSkillsResponse {
+  imported: string[]
+  skipped: { name: string; reason: string }[]
+}
+
+// --- providers (write) ---
+
+export interface ProviderTestRequest {
+  model: string
+  message?: string
+}
+
+export interface ProviderTestResponse {
+  content: string
+  usage?: {
+    promptTokens: number
+    completionTokens: number
+  }
+}
+
+// --- chat streaming ---
+
+export interface ChatRequest {
+  message: string
+}
+
+// --- profile files ---
+
+export type ProfileFileName =
+  | 'profile.json'
+  | 'SOUL.md'
+  | 'IDENTITY.md'
+  | 'BOOTSTRAP.md'
+  | 'AGENTS.md'
+  | 'TOOLS.md'
+  | 'HEARTBEAT.md'
+
+export const PROFILE_FILES: ProfileFileName[] = [
+  'profile.json',
+  'SOUL.md',
+  'IDENTITY.md',
+  'BOOTSTRAP.md',
+  'AGENTS.md',
+  'TOOLS.md',
+  'HEARTBEAT.md',
+]
+
+export interface FileContentResponse {
+  content: string
+}
+
+export interface PutFileRequest {
+  content: string
+}
+
+// --- skills ---
+
+export interface SkillInfo {
+  name: string
+  description: string
+  source: string | null
+  importedAt: number | null
+  parseError?: string
+}
+
+export interface ResolvedSkillsResponse {
+  resolved: SkillInfo[]
+  missing: { name: string; reason: string }[]
+}
+
+export interface TruncateChatRequest {
+  /** Number of leading messages to preserve; everything after is dropped. */
+  keepCount: number
+}
+
+export interface TruncateChatResponse {
+  before: number
+  after: number
+}
+
+/**
+ * Lightweight "has anything new happened on this agent's session?" probe.
+ * Polled by the web chat UI to detect out-of-band activity (inbox-wakes,
+ * scheduled triggers, turns run from another tab) so it can prompt the user
+ * to refresh — the session JSONL is append-only, so either a new filename or
+ * a bigger byte-count means new entries landed.
+ */
+export interface SessionHeadResponse {
+  /** Basename of the most-recent `.jsonl` session file, or `null` if none. */
+  file: string | null
+  /** Byte size of that file (monotonically increasing while in use). */
+  size: number
+}
+
+export interface ContextFileEntry {
+  /** Basename of the injected profile file (e.g. SOUL.md). */
+  name: string
+  /** Full character count of the file's contribution to the system prompt. */
+  chars: number
+  /** Rough token estimate (chars / 4). */
+  tokens: number
+}
+
+export interface ContextToolEntry {
+  name: string
+  /** JSON schema char size (what the provider sees as tool definitions). */
+  schemaChars: number
+  /** Description char size. */
+  descriptionChars: number
+  /** Count of top-level properties on the input schema, when shaped like JSONSchema. */
+  paramCount: number | null
+}
+
+export interface ContextSkillEntry {
+  name: string
+  /** Char count of the skill block injected into the system prompt (currently just the name). */
+  blockChars: number
+}
+
+export interface ContextGroupEntry {
+  id: string
+  name: string
+  path: string
+  userMdChars: number
+}
+
+export interface ContextHistoryBreakdown {
+  /** Count of `message` entries. */
+  messageEntries: number
+  /** Count of `compaction` entries (summarization boundaries). */
+  compactionEntries: number
+  /** Char sum of message `content` fields (LLM input surface). */
+  chars: number
+  /** Raw wire size of the serialized log on disk. */
+  bytes: number
+  /** Rough token estimate (chars / 4) for history alone. */
+  tokensEstimate: number
+}
+
+export interface ChatContextResponse {
+  /** Agent being reported on. */
+  agentId: string
+  /** provider:model string the agent currently resolves to. */
+  model: string
+  systemPrompt: {
+    chars: number
+    tokens: number
+    /** Per-file breakdown of profile markdown sources (AGENTS.md, SOUL.md, TOOLS.md, IDENTITY.md, HEARTBEAT.md, BOOTSTRAP.md). */
+    files: ContextFileEntry[]
+    /** Char count of the skill-list text rendered into the system prompt. */
+    skillsListChars: number
+    /** Char count of the group block rendered into the system prompt. */
+    groupListChars: number
+    /** Char count of the USER.md block (0 when the group's userMd is empty). */
+    userMdChars: number
+    /** Fixed memory-hint block the runtime always appends. */
+    memoryHintChars: number
+  }
+  tools: {
+    count: number
+    listChars: number
+    schemaChars: number
+    entries: ContextToolEntry[]
+  }
+  skills: {
+    count: number
+    entries: ContextSkillEntry[]
+  }
+  group: ContextGroupEntry
+  history: ContextHistoryBreakdown
+  /** Sum of system prompt + tool schemas + history, in chars + tokens. */
+  totals: { chars: number; tokens: number }
+}
+
+export interface ChatCompactRequest {
+  /** Number of trailing message entries to keep verbatim. Default 10. */
+  keepTail?: number
+  /** Optional freeform guidance prepended to the summarizer system prompt. */
+  customInstructions?: string
+}
+
+export interface ChatCompactResponse {
+  /** Entry count before compaction. */
+  before: number
+  /** Entry count after compaction (1 compaction + `keptTail` messages). */
+  after: number
+  /** Message entries summarized into the compaction (the head that was dropped). */
+  summarized: number
+  /** Message entries preserved verbatim after the compaction boundary. */
+  keptTail: number
+  /** Rough token estimate of the log before compaction. */
+  tokensBefore: number
+  /** Rough token estimate of the log after compaction. */
+  tokensAfter: number
+  /** The summary text produced by the model. */
+  summary: string
+}
+
+// --- triggers (heartbeats / cron) ---
+
+export interface CreateTriggerRequest {
+  kind: 'interval' | 'cron'
+  /** required when kind='interval' */
+  intervalSec?: number
+  /** required when kind='cron' — 5-field expression ("m h dom mon dow") */
+  cronExpr?: string
+  /** injected as the user message when the trigger fires */
+  message: string
+  enabled?: boolean
+}
+
+export interface UpdateTriggerRequest {
+  enabled?: boolean
+}
+
+export interface CreateTriggerResponse {
+  trigger: AgentTrigger
+}
+
+export interface UpdateTriggerResponse {
+  trigger: AgentTrigger
+}
+
+export interface ListTriggersResponse {
+  triggers: AgentTrigger[]
+}
+
+// --- config page (providers + services + fields) ---
+
+/** Per-field UI + storage descriptor — source-of-truth is SERVICES in apps/daemon/src/core/services.ts. */
+export interface ServiceFieldState {
+  envVar: string
+  kind: 'secret' | 'config'
+  label: string
+  placeholder?: string
+  description?: string
+  /** True when the field has a non-empty value in its storage backend. */
+  set: boolean
+  /** For `kind: 'config'` (plaintext): the actual value. Omitted for secrets. */
+  value?: string
+  /** For `kind: 'secret'`: a truncated preview like "sk-abc…" so the UI can confirm something is stored. Omitted when unset. */
+  preview?: string
+}
+
+export interface ServiceCard {
+  id: string
+  displayName: string
+  /** Present for category==='provider' cards — tracks whether the pi-adapter sees it as configured. */
+  enabled?: boolean
+  envHint?: string
+  hint?: string
+  fields: ServiceFieldState[]
+}
+
+export interface ProviderConfigEntry extends ServiceCard {
+  enabled: boolean
+  envHint: string
+  /** Static catalog from pi-ai's typed model list — empty for providers not in the catalog. */
+  catalog: string[]
+  /** Live `/v1/models` query — omitted when the provider doesn't expose one. */
+  live?: { models: string[]; error?: string }
+  /** Curated models the admin has selected — drives the dropdowns in profile/agent forms. */
+  curated: string[]
+}
+
+export interface ProviderConfigResponse {
+  providers: ProviderConfigEntry[]
+}
+
+export interface ServiceConfigResponse {
+  services: ServiceCard[]
+}
+
+export interface SetFieldRequest {
+  value: string
+}
+
+export interface SetProviderModelsRequest {
+  models: string[]
+}
+
+export interface SetProviderModelsResponse {
+  models: string[]
+}
+
+export interface SetProviderEnabledRequest {
+  enabled: boolean
+}
+
+export interface SetProviderEnabledResponse {
+  name: string
+  enabled: boolean
+}
+
+// --- web tokens ---
+
+export interface CreateTokenRequest {
+  label: string
+}
+
+export interface CreateTokenResponse {
+  /** Plaintext token — returned exactly once. */
+  token: string
+  meta: WebToken
+}
+
+export interface ListTokensResponse {
+  tokens: WebToken[]
+}
+
+// --- health (doctor) ---
+
+export interface HealthReport {
+  ok: boolean
+  home: string
+  paths: {
+    home: boolean
+    db: boolean
+    auth: boolean
+    profiles: boolean
+    agents: boolean
+    skills: boolean
+  }
+  database:
+    | { ok: true; profiles: number; activeAgents: number; totalAgents: number; groups: number }
+    | { ok: false; error: string }
+    | null
+  skills: { installed: number; parseErrors: number }
+  providers: {
+    /** Names of cloud providers with credentials configured (e.g. ['anthropic', 'groq']). */
+    configured: string[]
+    lmstudio: { baseURL: string; hasKey: boolean }
+    ollama: { baseURL: string }
+  }
+  webSearch: { bravePreview: string | null; searxngUrl: string | null }
+  openclaw: { path: string; exists: boolean }
+  triggers: { active: number; disabled: number }
+  tokens: { active: number }
+  scheduler: { enabled: boolean; tickMs: number }
+}

package/packages/api-types/src/memory.ts

@@ -0,0 +1,15 @@
+// Wire shapes for the per-group memory store. The `MemoryBackend` interface
+// itself stays in apps/daemon/src/runtime/memory (it has methods and is
+// server-internal); these are the values that cross the HTTP wire.
+
+export interface MemoryEntry {
+  key: string
+  content: string
+  updatedAt: number
+}
+
+export interface MemoryHit {
+  key: string
+  snippet: string
+  score: number
+}

package/packages/client/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@bazilion/client",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@bazilion/api-types": "workspace:*"
+  }
+}

package/packages/client/src/index.ts

@@ -0,0 +1,117 @@
+import type { ApiError } from '@bazilion/api-types'
+
+export type TokenSource = string | (() => string | Promise<string>)
+
+export interface ClientConfig {
+  serverUrl: string
+  /**
+   * Bearer token (or supplier for lazy / rotating credentials). The package
+   * sends it as `Authorization: Bearer <token>` and also stamps `Origin:
+   * <serverUrl>` to pass Astro's `security.checkOrigin` gate on non-GET
+   * requests. Pass a function to support token rotation (OAuth refresh,
+   * mobile keychain reads) — it is invoked on every request.
+   */
+  token: TokenSource
+}
+
+export class ApiClientError extends Error {
+  status: number
+  body: ApiError
+  constructor(status: number, body: ApiError) {
+    super(`${status}: ${body.error}`)
+    this.status = status
+    this.body = body
+  }
+}
+
+async function resolveToken(src: TokenSource): Promise<string> {
+  return typeof src === 'function' ? await src() : src
+}
+
+export function createClient(cfg: ClientConfig) {
+  async function authHeaders(): Promise<Record<string, string>> {
+    const token = await resolveToken(cfg.token)
+    return {
+      authorization: `Bearer ${token}`,
+      // Astro 6 enabled `security.checkOrigin` by default for server mode:
+      // any state-changing request without an `Origin` matching the server
+      // host is rejected with 403. Browsers set this automatically; `fetch`
+      // in Node / React Native does not. Stamping the server's own URL is
+      // always valid for a legitimate client.
+      origin: cfg.serverUrl,
+    }
+  }
+
+  async function request<T>(method: string, path: string, body?: unknown): Promise<T> {
+    const headers: Record<string, string> = { ...(await authHeaders()) }
+    if (body !== undefined) headers['content-type'] = 'application/json'
+    const res = await fetch(`${cfg.serverUrl}${path}`, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+    })
+    if (!res.ok) {
+      const err = (await res.json().catch(() => ({ error: res.statusText }))) as ApiError
+      throw new ApiClientError(res.status, err)
+    }
+    if (res.status === 204) return undefined as T
+    return (await res.json()) as T
+  }
+
+  // Multipart POST — lets the runtime set its own `content-type: multipart/form-data;
+  // boundary=…` header. Reusing `request()` would stomp that with JSON, so
+  // we keep a separate path.
+  async function postMultipart<T>(path: string, form: FormData): Promise<T> {
+    const res = await fetch(`${cfg.serverUrl}${path}`, {
+      method: 'POST',
+      headers: { ...(await authHeaders()) },
+      body: form,
+    })
+    if (!res.ok) {
+      const err = (await res.json().catch(() => ({ error: res.statusText }))) as ApiError
+      throw new ApiClientError(res.status, err)
+    }
+    if (res.status === 204) return undefined as T
+    return (await res.json()) as T
+  }
+
+  async function* stream<T>(method: string, path: string, body?: unknown): AsyncGenerator<T> {
+    const headers: Record<string, string> = { ...(await authHeaders()) }
+    if (body !== undefined) headers['content-type'] = 'application/json'
+    const res = await fetch(`${cfg.serverUrl}${path}`, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+    })
+    if (!res.ok || !res.body) {
+      const err = (await res.json().catch(() => ({ error: res.statusText }))) as ApiError
+      throw new ApiClientError(res.status, err)
+    }
+    const reader = res.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      buffer += decoder.decode(value, { stream: true })
+      const lines = buffer.split('\n')
+      buffer = lines.pop() ?? ''
+      for (const line of lines) {
+        if (line.trim()) yield JSON.parse(line) as T
+      }
+    }
+    if (buffer.trim()) yield JSON.parse(buffer) as T
+  }
+
+  return {
+    get: <T>(p: string) => request<T>('GET', p),
+    post: <T>(p: string, b?: unknown) => request<T>('POST', p, b),
+    postMultipart,
+    put: <T>(p: string, b?: unknown) => request<T>('PUT', p, b),
+    patch: <T>(p: string, b?: unknown) => request<T>('PATCH', p, b),
+    del: <T>(p: string) => request<T>('DELETE', p),
+    stream,
+  }
+}
+
+export type BazilionClient = ReturnType<typeof createClient>

package/pnpm-workspace.yaml

@@ -0,0 +1,3 @@
+packages:
+  - 'apps/*'
+  - 'packages/*'

package/tsconfig.base.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ESNext"],
+    "types": ["node"],
+
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "forceConsistentCasingInFileNames": true,
+
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "allowImportingTsExtensions": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  }
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.base.json",
+  "include": [
+    "apps/cli/src/**/*.ts",
+    "apps/cli/test/**/*.ts",
+    "apps/daemon/src/**/*.ts",
+    "apps/daemon/test/**/*.ts",
+    "packages/**/src/**/*.ts"
+  ],
+  "exclude": ["**/node_modules", "**/dist", "apps/web/**"]
+}

package/vitest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    include: ['apps/*/test/**/*.test.ts', 'packages/*/test/**/*.test.ts'],
+    passWithNoTests: true,
+    // CLI integration tests spawn the daemon as a subprocess per test file.
+    // 30s is generous for cold start; if it's slower, we want to see it fail
+    // quickly and diagnose the real cause rather than silently stall the suite.
+    hookTimeout: 30_000,
+    // Some CLI tests chain 10+ subprocess calls (each ~200–400 ms). Vitest's
+    // 5s default testTimeout is below the realistic ceiling, so give them the
+    // same 30s budget as hooks. Real hangs still show up quickly.
+    testTimeout: 30_000,
+    pool: 'forks',
+    poolOptions: {
+      forks: {
+        maxForks: 8,
+      },
+    },
+  },
+})