@polderlabs/bizar 10.2.0 → 10.4.0

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

@@ -1,126 +0,0 @@
-/**
- * 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,
-  wrapCline,
-  unwrapCline,
-  startProxy,
-  stopProxy,
-  getClineConfig,
-  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 wrapCline({
-      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 unwrapCline();
-    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/cline-config
-  router.get('/cline-config', wrap(async (_req, res) => {
-    const config = await getClineConfig();
-    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/web/v8/views/Headroom/HeadroomView.tsx

@@ -1,201 +0,0 @@
-import { useEffect, useState } from 'react';
-import { Network, Play, Square, Plug, Unplug, RotateCw, RefreshCw } from 'lucide-react';
-import { Stack } from '../../ui/primitives/Stack.js';
-import { Inline } from '../../ui/primitives/Inline.js';
-import { Grid } from '../../ui/primitives/Grid.js';
-import { ViewHeader } from '../../ui/data/ViewHeader.js';
-import { Card, CardBody } from '../../ui/data/Card.js';
-import { Badge } from '../../ui/data/Badge.js';
-import { Button } from '../../ui/controls/Button.js';
-import { Skeleton } from '../../ui/feedback/Skeleton.js';
-import { useFetch } from '../../data/useFetch.js';
-import { fetchJson, FetchError } from '../../data/fetcher.js';
-
-/**
- * HeadroomView — Sprint S35. Headroom proxy install + lifecycle.
- */
-
-type Status = 'installed' | 'not-installed' | 'running' | 'stopped';
-
-interface HeadroomStatus {
-  status: Status;
-  version?: string;
-  port?: number;
-  message?: string;
-}
-
-interface HeadroomStats {
-  hours?: number;
-  requests?: number;
-  tokensSaved?: number;
-  cacheHits?: number;
-  cacheMisses?: number;
-}
-
-export function HeadroomView(): JSX.Element {
-  const status = useFetch<HeadroomStatus>('/api/headroom/status');
-  const stats = useFetch<HeadroomStats>('/api/headroom/stats?hours=24');
-  const [busy, setBusy] = useState<string | null>(null);
-  const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    const id = setInterval(() => { void status.refetch(); }, 15_000);
-    return () => clearInterval(id);
-  }, [status]);
-
-  const install = async (): Promise<void> => {
-    setBusy('install');
-    setError(null);
-    try {
-      await fetchJson('/api/headroom/install', { method: 'POST', body: { force: false } });
-      void status.refetch();
-    } catch (err) {
-      setError(err instanceof FetchError ? err.message : (err as Error).message);
-    } finally {
-      setBusy(null);
-    }
-  };
-
-  const wrap = async (): Promise<void> => {
-    setBusy('wrap');
-    setError(null);
-    try {
-      await fetchJson('/api/headroom/wrap', { method: 'POST', body: { port: 8787 } });
-      void status.refetch();
-    } catch (err) {
-      setError(err instanceof FetchError ? err.message : (err as Error).message);
-    } finally {
-      setBusy(null);
-    }
-  };
-
-  const unwrap = async (): Promise<void> => {
-    setBusy('unwrap');
-    setError(null);
-    try {
-      await fetchJson('/api/headroom/unwrap', { method: 'POST' });
-      void status.refetch();
-    } catch (err) {
-      setError(err instanceof FetchError ? err.message : (err as Error).message);
-    } finally {
-      setBusy(null);
-    }
-  };
-
-  const start = async (): Promise<void> => {
-    setBusy('start');
-    setError(null);
-    try {
-      await fetchJson('/api/headroom/start', { method: 'POST' });
-      void status.refetch();
-    } catch (err) {
-      setError(err instanceof FetchError ? err.message : (err as Error).message);
-    } finally {
-      setBusy(null);
-    }
-  };
-
-  const stop = async (): Promise<void> => {
-    setBusy('stop');
-    setError(null);
-    try {
-      await fetchJson('/api/headroom/stop', { method: 'POST' });
-      void status.refetch();
-    } catch (err) {
-      setError(err instanceof FetchError ? err.message : (err as Error).message);
-    } finally {
-      setBusy(null);
-    }
-  };
-
-  const s = status.data;
-  const isInstalled = s && s.status !== 'not-installed';
-  const isRunning = s?.status === 'running';
-
-  return (
-    <Stack gap={5} data-testid="headroom-view">
-      <ViewHeader
-        title="Headroom"
-        description="Local proxy that reduces token cost via caching + batching. Install, wrap Cline, start/stop."
-        actions={
-          <Inline gap={2} align="center">
-            {error !== null && <span role="alert" style={{ color: 'var(--danger)', fontSize: 'var(--fs-12)' }}>{error}</span>}
-            <Button variant="ghost" onClick={() => { void status.refetch(); }} data-testid="headroom-refresh">
-              <RefreshCw size={14} aria-hidden /> Refresh
-            </Button>
-          </Inline>
-        }
-      />
-
-      <Card variant="elevated">
-        <CardBody>
-          {status.loading && !s ? (
-            <Skeleton style={{ height: 60 }} />
-          ) : (
-            <Inline align="center" justify="between" gap={3}>
-              <Stack gap={1}>
-                <Inline align="center" gap={2}>
-                  <Network size={16} aria-hidden />
-                  <strong>{s?.status ?? 'unknown'}</strong>
-                  {s?.version && <Badge tone="neutral">v{s.version}</Badge>}
-                  {s?.port && <Badge tone="info">port {s.port}</Badge>}
-                </Inline>
-                {s?.message && <span style={{ fontSize: 'var(--fs-12)', color: 'var(--fg-muted)' }}>{s.message}</span>}
-              </Stack>
-              <Inline gap={1} wrap={true}>
-                {!isInstalled && (
-                  <Button variant="primary" onClick={() => void install()} disabled={busy === 'install'} data-testid="headroom-install">
-                    <Plug size={12} aria-hidden /> {busy === 'install' ? 'Installing…' : 'Install'}
-                  </Button>
-                )}
-                {isInstalled && (
-                  <>
-                    <Button variant={isRunning ? 'secondary' : 'primary'} onClick={() => void (isRunning ? stop() : start())} disabled={busy === 'start' || busy === 'stop'} data-testid="headroom-toggle-running">
-                      {isRunning ? <Square size={12} aria-hidden /> : <Play size={12} aria-hidden />}
-                      {isRunning ? (busy === 'stop' ? 'Stopping…' : 'Stop') : (busy === 'start' ? 'Starting…' : 'Start')}
-                    </Button>
-                    <Button variant="ghost" onClick={() => void wrap()} disabled={busy === 'wrap'} data-testid="headroom-wrap">
-                      <RotateCw size={12} aria-hidden /> {busy === 'wrap' ? 'Wrapping…' : 'Wrap Cline'}
-                    </Button>
-                    <Button variant="ghost" onClick={() => void unwrap()} disabled={busy === 'unwrap'} data-testid="headroom-unwrap">
-                      <Unplug size={12} aria-hidden /> {busy === 'unwrap' ? 'Unwrapping…' : 'Unwrap'}
-                    </Button>
-                  </>
-                )}
-              </Inline>
-            </Inline>
-          )}
-        </CardBody>
-      </Card>
-
-      <Grid cols={3}>
-        <Card variant="default">
-          <CardBody>
-            <Stack gap={1}>
-              <span style={{ fontSize: 'var(--fs-12)', color: 'var(--fg-muted)' }}>Requests (24h)</span>
-              <strong style={{ fontFamily: 'var(--font-mono)', fontSize: 'var(--fs-18)' }}>{stats.data?.requests ?? 0}</strong>
-            </Stack>
-          </CardBody>
-        </Card>
-        <Card variant="default">
-          <CardBody>
-            <Stack gap={1}>
-              <span style={{ fontSize: 'var(--fs-12)', color: 'var(--fg-muted)' }}>Tokens saved</span>
-              <strong style={{ fontFamily: 'var(--font-mono)', fontSize: 'var(--fs-18)' }}>{stats.data?.tokensSaved ?? 0}</strong>
-            </Stack>
-          </CardBody>
-        </Card>
-        <Card variant="default">
-          <CardBody>
-            <Stack gap={1}>
-              <span style={{ fontSize: 'var(--fs-12)', color: 'var(--fg-muted)' }}>Cache hits / misses</span>
-              <strong style={{ fontFamily: 'var(--font-mono)', fontSize: 'var(--fs-18)' }}>
-                {stats.data?.cacheHits ?? 0} / {stats.data?.cacheMisses ?? 0}
-              </strong>
-            </Stack>
-          </CardBody>
-        </Card>
-      </Grid>
-    </Stack>
-  );
-}

package/bizar-dash/tests/graphify-mod-spawn.node.test.mjs

@@ -1,90 +0,0 @@
-/**
- * graphify-mod-spawn.node.test.mjs — regression test for the SIGPIPE crash.
- *
- * The graphify mod's route.mjs used to spawn the `graphify` CLI with
- * `spawnSync` + `stdio: 'inherit'`. That worked in a terminal, but the
- * dashboard is a background daemon with stdin=/dev/null and
- * stdout/stderr redirected to a log file. With `stdio: 'inherit'`, the
- * child inherits those descriptors; if anything closes or rotates them
- * mid-build, the kernel delivers SIGPIPE to the dashboard — silently
- * killing it. The user reported "building the graph crashed the dash".
- *
- * This test verifies the source file no longer contains the dangerous
- * pattern. We parse the file as text (the route.mjs is loaded by the
- * dashboard's vm sandbox, not directly importable here).
- *
- * Run with: node --test tests/graphify-mod-spawn.node.test.mjs
- */
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-
-// Test lives at bizar-dash/tests/, source is at the repo root.
-const REPO = resolve(import.meta.dirname, '..', '..');
-const SOURCE = join(REPO, 'mods-examples/graphify/route.mjs');
-
-describe('graphify mod — SIGPIPE-safe spawn', () => {
-  it('source file exists at the expected path', () => {
-    const text = readFileSync(SOURCE, 'utf8');
-    assert.ok(text.length > 100, 'source file should be substantial');
-  });
-
-  it('does NOT import spawnSync (causes blocking + stdio inheritance)', () => {
-    const text = readFileSync(SOURCE, 'utf8');
-    assert.ok(
-      !/\bspawnSync\b/.test(text),
-      'route.mjs must not import or call spawnSync — use async spawn instead',
-    );
-  });
-
-  it('does NOT use stdio: \'inherit\' (the SIGPIPE crash vector)', () => {
-    const text = readFileSync(SOURCE, 'utf8');
-    // Strip block comments and line comments before checking — we don't
-    // want the bug description itself to trip the test.
-    const stripped = text
-      .replace(/\/\*[\s\S]*?\*\//g, '')
-      .replace(/^\s*\/\/.*$/gm, '')
-      .replace(/`stdio:\s*'inherit'`/g, '');
-    // Look for the literal string in any quoting style.
-    const patterns = [
-      /stdio:\s*['"]inherit['"]/,
-      /stdio:\s*\[\s*['"]inherit['"]/,
-    ];
-    for (const pat of patterns) {
-      assert.ok(
-        !pat.test(stripped),
-        `route.mjs must not use stdio: 'inherit' — it propagates SIGPIPE to the dashboard`,
-      );
-    }
-  });
-
-  it('isolates the spawned child stdio with [\'ignore\', \'pipe\', \'pipe\']', () => {
-    const text = readFileSync(SOURCE, 'utf8');
-    assert.ok(
-      /stdio:\s*\[\s*['"]ignore['"]\s*,\s*['"]pipe['"]\s*,\s*['"]pipe['"]\s*\]/.test(text),
-      'spawn options should set stdio to [ignore, pipe, pipe] for SIGPIPE isolation',
-    );
-  });
-
-  it('runs graphify as an async spawn (not blocking)', () => {
-    const text = readFileSync(SOURCE, 'utf8');
-    // runGraphify should be declared `async function` and return a Promise.
-    assert.ok(
-      /async\s+function\s+runGraphify\s*\(/.test(text),
-      'runGraphify should be declared async so the dashboard event loop is not blocked',
-    );
-    assert.ok(
-      /return\s+new\s+Promise\s*\(/.test(text),
-      'runGraphify should return a Promise (async spawn lifecycle)',
-    );
-  });
-
-  it('forwards child stdout/stderr to the broadcast callback (no streaming lost)', () => {
-    const text = readFileSync(SOURCE, 'utf8');
-    assert.ok(
-      /broadcast\(\s*\{\s*type:\s*['"]graphify:build:log['"]/.test(text),
-      'runGraphify should call broadcast with graphify:build:log events so the dashboard UI keeps streaming',
-    );
-  });
-});

package/bizar-dash/tests/headroom-install.test.mjs

@@ -1,173 +0,0 @@
-/**
- * tests/headroom-install.test.mjs
- *
- * Tests for installHeadroom(), wrapCline(), unwrapCline(), startProxy(), stopProxy().
- * Uses real commands when available, mocks when not.
- */
-
-import { test, describe, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawn } from 'node:child_process';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { mkdirSync, rmSync, writeFileSync, existsSync, unlinkSync, readFileSync } from 'node:fs';
-import http from 'node:http';
-
-// ── Run command helper ──────────────────────────────────────────────────────
-
-function runCmd(cmd, args, opts = {}) {
-  return new Promise((resolve) => {
-    const child = spawn(cmd, args, { timeout: 5000, ...opts });
-    let stdout = '';
-    let stderr = '';
-    child.stdout?.on('data', (d) => { stdout += d.toString(); });
-    child.stderr?.on('data', (d) => { stderr += d.toString(); });
-    child.on('close', (code) => resolve({ stdout: stdout.trim(), stderr: stderr.trim(), exitCode: code ?? 0 }));
-    child.on('error', (err) => resolve({ stdout: '', stderr: err.message, exitCode: 1 }));
-  });
-}
-
-// ── Install tests ────────────────────────────────────────────────────────────
-
-test('installHeadroom returns correct shape', async () => {
-  const { installHeadroom } = await import('../src/server/headroom.mjs');
-  const result = await installHeadroom({ force: false });
-
-  assert.ok(typeof result.ok === 'boolean', 'ok is boolean');
-  assert.ok(typeof result.installed === 'boolean', 'installed is boolean');
-  assert.ok(typeof result.version === 'string' || result.version === null, 'version is string|null');
-  assert.ok(typeof result.method === 'string', 'method is string');
-});
-
-test('installHeadroom returns already-installed when headroom is on PATH', async () => {
-  const { installed } = await runCmd('headroom', ['--version']);
-  if (installed !== 0) {
-    // headroom not installed — skip
-    return;
-  }
-
-  const { installHeadroom } = await import('../src/server/headroom.mjs');
-  const result = await installHeadroom({ force: false });
-
-  assert.strictEqual(result.installed, true, 'should report already installed');
-  assert.strictEqual(result.method, 'already-installed', 'method should be already-installed');
-});
-
-test('installHeadroom.force reinstalls even when already installed', async () => {
-  const { installHeadroom } = await import('../src/server/headroom.mjs');
-  const result = await installHeadroom({ force: true });
-
-  // Returns the shape regardless of outcome
-  assert.ok(typeof result.ok === 'boolean', 'ok is boolean');
-  assert.ok(typeof result.installed === 'boolean', 'installed is boolean');
-  assert.ok(typeof result.method === 'string', 'method is string');
-});
-
-// ── Wrap / Unwrap tests ─────────────────────────────────────────────────────
-
-test('wrapCline returns correct shape', async () => {
-  const { wrapCline } = await import('../src/server/headroom.mjs');
-  const result = await wrapCline({ port: 8787 });
-
-  assert.ok(typeof result.ok === 'boolean', 'ok is boolean');
-  assert.ok(typeof result.port === 'number', 'port is number');
-  assert.ok(typeof result.log === 'string', 'log is string');
-  assert.strictEqual(result.port, 8787, 'port is 8787');
-});
-
-test('unwrapCline returns correct shape', async () => {
-  const { unwrapCline } = await import('../src/server/headroom.mjs');
-  const result = await unwrapCline();
-
-  assert.ok(typeof result.ok === 'boolean', 'ok is boolean');
-  assert.ok(typeof result.log === 'string', 'log is string');
-});
-
-// ── Proxy tests ─────────────────────────────────────────────────────────────
-
-test('startProxy returns correct shape', async () => {
-  const { startProxy } = await import('../src/server/headroom.mjs');
-  const result = await startProxy({ port: 18787, host: '127.0.0.1' });
-
-  assert.ok(typeof result.ok === 'boolean', 'ok is boolean');
-  assert.ok(typeof result.pid === 'number' || result.pid === null, 'pid is number|null');
-  assert.ok(typeof result.port === 'number', 'port is number');
-  assert.ok(typeof result.logPath === 'string', 'logPath is string');
-});
-
-test('stopProxy returns correct shape', async () => {
-  const { stopProxy } = await import('../src/server/headroom.mjs');
-  const result = await stopProxy();
-
-  assert.ok(typeof result.ok === 'boolean', 'ok is boolean');
-  assert.ok(Array.isArray(result.killed), 'killed is array');
-});
-
-// ── getClineConfig tests ──────────────────────────────────────────────────
-
-test('getClineConfig returns correct shape', async () => {
-  const { getClineConfig } = await import('../src/server/headroom.mjs');
-  const result = await getClineConfig();
-
-  assert.ok(typeof result.configPath === 'string', 'configPath is string');
-  assert.ok(typeof result.hasHeadroomProvider === 'boolean', 'hasHeadroomProvider is boolean');
-  assert.ok(result.configPath.includes('cline.json'), 'configPath points to cline.json');
-});
-
-// ── withHeadroomProxy tests ──────────────────────────────────────────────────
-
-test('withHeadroomProxy returns URL unchanged when disabled', async () => {
-  const { withHeadroomProxy } = await import('../src/server/headroom.mjs');
-  const url = 'https://api.anthropic.com/v1/messages';
-  // When headroom is not in settings (default), returns URL unchanged
-  const result = withHeadroomProxy(url, { port: 8787 });
-  // Result depends on settings — just verify it's a string
-  assert.ok(typeof result === 'string', 'result is string');
-  assert.ok(result.length > 0, 'result is non-empty');
-});
-
-// ── /api/headroom/install endpoint ──────────────────────────────────────────
-
-async function buildApp() {
-  const { createHeadroomRouter } = await import('../src/server/routes/headroom.mjs');
-  const express = (await import('express')).default;
-  const app = express();
-  app.use(express.json());
-  // Mount at /api/headroom so routes like /status become /api/headroom/status
-  app.use('/api/headroom', await createHeadroomRouter());
-  return app;
-}
-
-test('POST /api/headroom/install returns result', async () => {
-  const app = await buildApp();
-  const server = app.listen(0);
-  const { port } = server.address();
-
-  const httpPost = () =>
-    new Promise((resolve, reject) => {
-      const data = JSON.stringify({ force: false });
-      const req = http.request(
-        { hostname: 'localhost', port, path: '/api/headroom/install', method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } },
-        (res) => {
-          let body = '';
-          res.on('data', (c) => (body += c));
-          res.on('end', () => {
-            try { resolve({ status: res.statusCode, body: JSON.parse(body || '{}') }); }
-            catch { resolve({ status: res.statusCode, body }); }
-          });
-        },
-      );
-      req.on('error', reject);
-      req.write(data);
-      req.end();
-    });
-
-  try {
-    const res = await httpPost();
-    assert.strictEqual(res.status, 200, 'status should be 200');
-    assert.ok(typeof res.body.ok === 'boolean', 'ok is boolean');
-    assert.ok(typeof res.body.installed === 'boolean', 'installed is boolean');
-  } finally {
-    server.close();
-  }
-});