@polderlabs/bizar 4.4.13 → 4.5.1

package/bizar-dash/src/server/routes/_shared.mjs

@@ -148,6 +148,22 @@ export const DEFAULT_SETTINGS = {
     baseUrl: 'https://www.minimax.io',
     chatBaseUrl: 'https://api.minimax.io/v1',
   },
+  // v5.0.0 — Headroom context compression integration.
+  // Headroom sits between opencode and LLM providers, compressing tool
+  // outputs, logs, RAG chunks, and conversation history by 60–95%.
+  headroom: {
+    enabled: true,
+    autoInstall: true,
+    port: 8787,
+    host: '127.0.0.1',
+    outputShaper: false,
+    telemetry: false,
+    budget: 0,
+    backend: 'anthropic',
+    autoStart: true,
+    autoWrap: true,
+    routeAllProviders: true,
+  },
 };
 
 /**
@@ -174,6 +190,7 @@ export function mergeSettings(existing) {
   merged.agents = { ...DEFAULT_SETTINGS.agents, ...(existing.agents || {}) };
   merged.systemLlm = { ...DEFAULT_SETTINGS.systemLlm, ...(existing.systemLlm || {}) };
   merged.minimax = { ...DEFAULT_SETTINGS.minimax, ...(existing.minimax || {}) };
+  merged.headroom = { ...DEFAULT_SETTINGS.headroom, ...(existing.headroom || {}) };
   // Always use the package version — never let user settings override it
   merged.about.version = DEFAULT_SETTINGS.about.version;
   return merged;

package/bizar-dash/src/server/routes/config.mjs

@@ -8,6 +8,8 @@
  * /api/config/providers (POST)          — add
  * /api/config/providers/:id (PUT)       — update
  * /api/config/providers/:id (DELETE)    — remove
+ * /api/config/providers/auto (POST)     — add with key, auto-discover models
+ *                                          + apply systemLlm config
  * /api/config/mcps                      — list MCP servers
  * /api/config/mcps (POST)               — add
  * /api/config/mcps/:id (PUT)            — update
@@ -22,7 +24,12 @@
 import { Router } from 'express';
 import { existsSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { providersStore, mcpsStore } from '../providers-store.mjs';
+import {
+  providersStore,
+  mcpsStore,
+  loadConfig,
+  saveConfig,
+} from '../providers-store.mjs';
 import { OPENCODE_JSON, atomicWriteJson, safeReadJSON, wrap } from './_shared.mjs';
 
 /**
@@ -101,11 +108,55 @@ export function createConfigRouter({ state, watcher }) {
     res.status(204).end();
   }));
 
+  // v4.4.14 — "Add with key" — the user pastes a key, we figure out the
+  // rest. Auto-discovers the live model list (probes /v1/models), writes
+  // the full provider block, and (if requested) applies the system LLM
+  // config so the rest of the dashboard's /api/llm/* calls hit this
+  // provider+model.
+  router.post('/config/providers/auto', wrap(async (req, res) => {
+    const body = req.body || {};
+    const result = await providersStore.addWithAuto({
+      id: typeof body.id === 'string' ? body.id.trim() : undefined,
+      name: typeof body.name === 'string' ? body.name.trim() : undefined,
+      apiKey: typeof body.apiKey === 'string' ? body.apiKey : '',
+      groupId: typeof body.groupId === 'string' ? body.groupId : 'default',
+      setAsSystemLlm: body.setAsSystemLlm !== false,
+      preferredModel: typeof body.preferredModel === 'string' ? body.preferredModel : undefined,
+      systemLlmModel: typeof body.systemLlmModel === 'string' ? body.systemLlmModel : undefined,
+    });
+    if (!result.ok) {
+      res.status(result.error === 'unknown_provider' ? 400 : 400).json(result);
+      return;
+    }
+    res.status(201).json(result);
+  }));
+
   // ── /api/config/mcps ───────────────────────────────────────────────────
   router.get('/config/mcps', wrap(async (_req, res) => {
     res.json({ mcps: mcpsStore.list() });
   }));
 
+  // v4.4.14 — System LLM settings. The dashboard reads / writes the
+  // opencode.json#systemLlm block via this thin surface. The block
+  // controls which provider+model is used for the dashboard's own
+  // /api/llm/* calls (auto-title, enhance-prompt, summarization).
+  router.get('/llm/system-llm', wrap(async (_req, res) => {
+    const cfg = loadConfig();
+    res.json(cfg.systemLlm || { enabled: false, provider: null, model: null });
+  }));
+
+  router.put('/llm/system-llm', wrap(async (req, res) => {
+    const cfg = loadConfig();
+    const body = req.body || {};
+    cfg.systemLlm = {
+      enabled: body.enabled !== false,
+      provider: typeof body.provider === 'string' ? body.provider : (cfg.systemLlm?.provider || null),
+      model: typeof body.model === 'string' ? body.model : (cfg.systemLlm?.model || null),
+    };
+    saveConfig(cfg);
+    res.json(cfg.systemLlm);
+  }));
+
   router.post('/config/mcps', wrap(async (req, res) => {
     const mcp = mcpsStore.add(req.body || {});
     res.status(201).json(mcp);

package/bizar-dash/src/server/routes/env-vars.mjs

@@ -0,0 +1,165 @@
+/**
+ * src/server/routes/env-vars.mjs
+ *
+ * v1 — Bizar env vars stored in ~/.config/bizar/env.json (mode 0600).
+ *
+ * Endpoints:
+ *   GET    /api/env-vars           — list all (masked values)
+ *   POST   /api/env-vars           — create {name, value}
+ *   PUT    /api/env-vars/:name     — update {value}
+ *   DELETE /api/env-vars/:name     — remove + delete from process.env
+ *   POST   /api/env-vars/:name/test — {referenced, inProcessEnv}
+ *
+ * Name must match /^BIZAR_[A-Z0-9_]+$/.
+ * On startup, loadEnvJson() sets process.env[name] = value for every entry.
+ */
+import { Router } from 'express';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { wrap } from './_shared.mjs';
+
+const HOME = homedir();
+const BIZAR_DIR = join(HOME, '.config', 'bizar');
+const ENV_FILE = join(BIZAR_DIR, 'env.json');
+
+// Lazy-load store
+let _store = null;
+
+function readStore() {
+  if (_store !== null) return _store;
+  if (!existsSync(ENV_FILE)) {
+    _store = {};
+    return _store;
+  }
+  try {
+    _store = JSON.parse(readFileSync(ENV_FILE, 'utf8')) || {};
+  } catch {
+    _store = {};
+  }
+  return _store;
+}
+
+function writeStore(store) {
+  mkdirSync(BIZAR_DIR, { recursive: true });
+  const tmp = `${ENV_FILE}.tmp.${process.pid}`;
+  writeFileSync(tmp, JSON.stringify(store, null, 2) + '\n', { mode: 0o600 });
+  renameSync(tmp, ENV_FILE);
+  _store = store;
+}
+
+/**
+ * Load env.json into process.env at startup.
+ * Called once from server.mjs after createApiRouter().
+ */
+export function loadEnvJson() {
+  const store = readStore();
+  for (const [name, entry] of Object.entries(store)) {
+    if (name.startsWith('BIZAR_')) {
+      process.env[name] = entry.value;
+    }
+  }
+}
+
+/** Reset in-memory store — used by tests to ensure isolation between test cases. */
+export function resetStore() {
+  _store = null;
+}
+
+/** Mask a value — return last 4 chars, prefixed with ***. */
+function mask(value) {
+  if (!value || value.length <= 4) return '****';
+  return '*'.repeat(Math.max(0, value.length - 4)) + value.slice(-4);
+}
+
+const NAME_RE = /^BIZAR_[A-Z0-9_]+$/;
+
+export function createEnvVarsRouter() {
+  const router = Router();
+
+  // GET /api/env-vars — list all (masked)
+  router.get('/env-vars', wrap(async (_req, res) => {
+    const store = readStore();
+    const list = Object.entries(store).map(([name, entry]) => ({
+      name,
+      value: mask(entry.value),
+      createdAt: entry.createdAt,
+      source: entry.source,
+    }));
+    res.json(list);
+  }));
+
+  // POST /api/env-vars — create
+  router.post('/env-vars', wrap(async (req, res) => {
+    const { name, value } = req.body || {};
+    if (!name || typeof name !== 'string') {
+      res.status(400).json({ error: 'name_required', message: 'name is required' });
+      return;
+    }
+    if (!NAME_RE.test(name)) {
+      res.status(400).json({
+        error: 'invalid_name',
+        message: 'name must match /^BIZAR_[A-Z0-9_]+$/',
+      });
+      return;
+    }
+    if (!value || typeof value !== 'string') {
+      res.status(400).json({ error: 'value_required', message: 'value is required' });
+      return;
+    }
+    const store = readStore();
+    if (store[name]) {
+      res.status(409).json({ error: 'already_exists', message: `${name} already exists` });
+      return;
+    }
+    const entry = { value, createdAt: new Date().toISOString(), source: 'dashboard' };
+    store[name] = entry;
+    writeStore(store);
+    process.env[name] = value;
+    res.status(201).json({ name, value: mask(value), createdAt: entry.createdAt, source: entry.source });
+  }));
+
+  // PUT /api/env-vars/:name — update
+  router.put('/env-vars/:name', wrap(async (req, res) => {
+    const { name } = req.params;
+    const { value } = req.body || {};
+    if (!value || typeof value !== 'string') {
+      res.status(400).json({ error: 'value_required', message: 'value is required' });
+      return;
+    }
+    const store = readStore();
+    if (!store[name]) {
+      res.status(404).json({ error: 'not_found', message: `${name} not found` });
+      return;
+    }
+    store[name] = { ...store[name], value };
+    writeStore(store);
+    process.env[name] = value;
+    res.json({ name, value: mask(value), createdAt: store[name].createdAt, source: store[name].source });
+  }));
+
+  // DELETE /api/env-vars/:name — remove
+  router.delete('/env-vars/:name', wrap(async (req, res) => {
+    const { name } = req.params;
+    const store = readStore();
+    if (!store[name]) {
+      res.status(404).json({ error: 'not_found', message: `${name} not found` });
+      return;
+    }
+    delete store[name];
+    writeStore(store);
+    delete process.env[name];
+    res.json({ ok: true });
+  }));
+
+  // POST /api/env-vars/:name/test — check if referenced
+  router.post('/env-vars/:name/test', wrap(async (req, res) => {
+    const { name } = req.params;
+    const store = readStore();
+    const inProcessEnv = name in process.env;
+    // Conservative: we don't statically analyze code, so referenced = inProcessEnv for now
+    res.json({ referenced: inProcessEnv, inProcessEnv });
+  }));
+
+  return router;
+}

package/bizar-dash/src/server/routes/headroom.mjs

@@ -0,0 +1,126 @@
+/**
+ * src/server/routes/headroom.mjs
+ *
+ * v1.0.0 — REST endpoints for Headroom management.
+ *
+ * Mounted at /api/headroom/* by api.mjs.
+ */
+import { Router } from 'express';
+import {
+  getHeadroomStatus,
+  getHeadroomStats,
+  installHeadroom,
+  wrapOpencode,
+  unwrapOpencode,
+  startProxy,
+  stopProxy,
+  getOpencodeConfig,
+  headroomStartupHook,
+} from '../headroom.mjs';
+import { wrap } from './_shared.mjs';
+
+export function createHeadroomRouter() {
+  const router = Router();
+
+  // GET /api/headroom/status
+  router.get('/status', wrap(async (_req, res) => {
+    const status = await getHeadroomStatus();
+    res.json(status);
+  }));
+
+  // GET /api/headroom/stats?hours=24
+  router.get('/stats', wrap(async (req, res) => {
+    const hours = Math.max(1, Math.min(parseInt(req.query.hours, 10) || 24, 720));
+    const stats = await getHeadroomStats({ hours });
+    res.json(stats);
+  }));
+
+  // POST /api/headroom/install
+  router.post('/install', wrap(async (req, res) => {
+    const { force = false } = req.body || {};
+    const result = await installHeadroom({ force: Boolean(force) });
+    res.json(result);
+  }));
+
+  // POST /api/headroom/wrap
+  router.post('/wrap', wrap(async (req, res) => {
+    const { port } = req.body || {};
+    const result = await wrapOpencode({
+      port: port ? Math.max(1, Math.min(parseInt(port, 10), 65535)) : 8787,
+    });
+    res.json(result);
+  }));
+
+  // POST /api/headroom/unwrap
+  router.post('/unwrap', wrap(async (_req, res) => {
+    const result = await unwrapOpencode();
+    res.json(result);
+  }));
+
+  // POST /api/headroom/proxy/start
+  router.post('/proxy/start', wrap(async (req, res) => {
+    const { port, host } = req.body || {};
+    const result = await startProxy({
+      port: port ? Math.max(1, Math.min(parseInt(port, 10), 65535)) : 8787,
+      host: typeof host === 'string' && host ? host : '127.0.0.1',
+    });
+    res.json(result);
+  }));
+
+  // POST /api/headroom/proxy/stop
+  router.post('/proxy/stop', wrap(async (_req, res) => {
+    const result = await stopProxy();
+    res.json(result);
+  }));
+
+  // GET /api/headroom/opencode-config
+  router.get('/opencode-config', wrap(async (_req, res) => {
+    const config = await getOpencodeConfig();
+    res.json(config);
+  }));
+
+  // POST /api/headroom/auto-route — configure all providers to route through Headroom
+  router.post('/auto-route', wrap(async (_req, res) => {
+    const { loadConfig, saveConfig } = await import('../providers-store.mjs');
+    const cfg = loadConfig();
+    const headroomPort = 8787;
+    const proxyUrl = `http://127.0.0.1:${headroomPort}/v1`;
+
+    // For each provider, prepend the headroom proxy URL to baseURL
+    const providers = cfg.provider || {};
+    let changed = 0;
+    for (const [id, p] of Object.entries(providers)) {
+      if (!p || typeof p !== 'object') continue;
+      const baseURL = p.baseURL || p.options?.baseURL || '';
+      // Only update if not already routed
+      if (baseURL && !baseURL.includes('127.0.0.1:8787') && !baseURL.includes('localhost:8787')) {
+        const newBaseURL = `${proxyUrl}/${baseURL.replace(/^https?:\/\//, '')}`;
+        if (p.options) {
+          providers[id] = { ...p, options: { ...p.options, baseURL: newBaseURL } };
+        } else {
+          providers[id] = { ...p, baseURL: newBaseURL };
+        }
+        changed++;
+      }
+    }
+    cfg.provider = providers;
+    saveConfig(cfg);
+
+    res.json({ ok: true, changed, message: `Updated ${changed} provider(s) to route through Headroom proxy.` });
+  }));
+
+  // POST /api/headroom/startup-hook — trigger the startup hook programmatically
+  router.post('/startup-hook', wrap(async (_req, res) => {
+    const { readSettings } = await import('./_shared.mjs');
+    const settings = readSettings();
+    const headroomSettings = settings?.data?.headroom;
+    if (!headroomSettings) {
+      res.status(400).json({ error: 'bad_request', message: 'Headroom settings not found in settings.json' });
+      return;
+    }
+    const result = await headroomStartupHook(headroomSettings);
+    res.json(result);
+  }));
+
+  return router;
+}

package/bizar-dash/src/server/routes/lightrag.mjs

@@ -0,0 +1,154 @@
+/**
+ * src/server/routes/lightrag.mjs
+ *
+ * v4.6.0 — LightRAG settings endpoints.
+ *
+ * Mounted at /api/lightrag/*. Used by the Settings view (handled by
+ * the sibling thor-settings agent) to surface and override the
+ * free-tier opencode Zen defaults that lightrag starts with.
+ *
+ * Endpoints:
+ *   GET  /lightrag/defaults      — current default models + provenance
+ *   PUT  /lightrag/defaults      — set env-var overrides (process-scoped, not persisted)
+ *   GET  /lightrag/status        — current running config (delegates to resolveLightRAGConfig)
+ *
+ * The PUT endpoint mutates `process.env` for the lifetime of the
+ * dashboard server process. We do NOT persist this to disk because:
+ *   1. env-var overrides are conventionally process-scoped, and
+ *   2. the proper way to persist is via PUT /api/memory/config which
+ *      writes to .bizar/memory.json (see routes/memory.mjs).
+ */
+import { Router } from 'express';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  getDefaultLightRAGConfig,
+  LIGHTRAG_DEFAULT_LLM,
+  LIGHTRAG_DEFAULT_EMBEDDING,
+} from '../memory-store.mjs';
+import { resolveLightRAGConfig } from '../memory-lightrag.mjs';
+import { wrap } from './_shared.mjs';
+
+/**
+ * @param {object} deps
+ * @param {string} deps.projectRoot
+ * @returns {import('express').Router}
+ */
+export function createLightragRouter({ projectRoot }) {
+  const router = Router();
+
+  // GET /api/lightrag/defaults — current defaults + where they came from.
+  router.get('/lightrag/defaults', wrap(async (_req, res) => {
+    const cfg = getDefaultLightRAGConfig();
+    res.json({
+      llm: cfg.llm,
+      embedding: cfg.embedding,
+      source: cfg.source,
+      llmSource: cfg.llmSource,
+      embeddingSource: cfg.embeddingSource,
+      builtin: {
+        llm: LIGHTRAG_DEFAULT_LLM,
+        embedding: LIGHTRAG_DEFAULT_EMBEDDING,
+      },
+      envVars: {
+        BIZAR_LIGHTRAG_LLM: process.env.BIZAR_LIGHTRAG_LLM || null,
+        BIZAR_LIGHTRAG_EMBEDDING: process.env.BIZAR_LIGHTRAG_EMBEDDING || null,
+      },
+    });
+  }));
+
+  // PUT /api/lightrag/defaults — set env-var overrides.
+  // Body: { llm?: string, embedding?: string }
+  // Both fields are optional; only the supplied ones are set. To clear
+  // an override, send an empty string ''.
+  router.put('/lightrag/defaults', wrap(async (req, res) => {
+    const body = req.body || {};
+    const updates = {};
+    if (Object.prototype.hasOwnProperty.call(body, 'llm')) {
+      const v = typeof body.llm === 'string' ? body.llm.trim() : '';
+      if (v) {
+        process.env.BIZAR_LIGHTRAG_LLM = v;
+        updates.llm = v;
+      } else {
+        delete process.env.BIZAR_LIGHTRAG_LLM;
+        updates.llmCleared = true;
+      }
+    }
+    if (Object.prototype.hasOwnProperty.call(body, 'embedding')) {
+      const v = typeof body.embedding === 'string' ? body.embedding.trim() : '';
+      if (v) {
+        process.env.BIZAR_LIGHTRAG_EMBEDDING = v;
+        updates.embedding = v;
+      } else {
+        delete process.env.BIZAR_LIGHTRAG_EMBEDDING;
+        updates.embeddingCleared = true;
+      }
+    }
+    const next = getDefaultLightRAGConfig();
+    res.json({
+      ok: true,
+      applied: updates,
+      llm: next.llm,
+      embedding: next.embedding,
+      source: next.source,
+    });
+  }));
+
+  // GET /api/lightrag/status — current resolved config + server status.
+  // Mirrors /api/memory/lightrag/status but is the canonical surface
+  // for the Settings view.
+  router.get('/lightrag/status', wrap(async (_req, res) => {
+    const cfg = resolveLightRAGConfig(projectRoot);
+    const pidFile = join(cfg.workingDir, 'lightrag.pid');
+    let pid = null;
+    let alive = false;
+    if (existsSync(pidFile)) {
+      try {
+        pid = parseInt(readFileSync(pidFile, 'utf8').trim(), 10);
+        if (Number.isFinite(pid) && pid > 0) {
+          try {
+            process.kill(pid, 0);
+            alive = true;
+          } catch {
+            alive = false;
+          }
+        } else {
+          pid = null;
+        }
+      } catch {
+        pid = null;
+      }
+    }
+
+    const logFile = join(cfg.workingDir, 'lightrag.log');
+    const logTail = [];
+    if (existsSync(logFile)) {
+      try {
+        const content = readFileSync(logFile, 'utf8');
+        const lines = content.split('\n');
+        logTail.push(...lines.slice(-30));
+      } catch { /* ignore */ }
+    }
+
+    let logSize = 0;
+    try {
+      if (existsSync(logFile)) logSize = statSync(logFile).size;
+    } catch { /* ignore */ }
+
+    res.json({
+      running: alive,
+      pid: alive ? pid : null,
+      host: cfg.host,
+      port: cfg.port,
+      llmBinding: cfg.llmBinding,
+      embeddingBinding: cfg.embeddingBinding,
+      llmModel: cfg.llmModel,
+      embeddingModel: cfg.embeddingModel,
+      workingDir: cfg.workingDir,
+      logSize,
+      logTail,
+    });
+  }));
+
+  return router;
+}