@polderlabs/bizar 4.9.0 → 5.0.1

package/bizar-dash/tests/diagnostics-store.test.mjs

@@ -0,0 +1,206 @@
+/**
+ * tests/diagnostics-store.test.mjs
+ *
+ * v6.0.0 — Tests for the Doctor surface of the diagnostics store:
+ *   - getRecentErrors({ since })  — timestamp-filtered error feed
+ *   - runCheck(name)               — single-check dispatch
+ *   - health()                     — rolled-up status + groups
+ *   - collectDiagnostics()         — full snapshot shape
+ *   - legacy snapshot() / health() — back-compat with v3 /api/diagnostics
+ *
+ * The store reads from `~/.config/bizar/service.log` and TCP-probes
+ * local services. Tests that exercise I/O use a temporary BIZAR_HOME
+ * so they don't touch the real install.
+ */
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+
+let tmpHome;
+
+const STORE = await import('../src/server/diagnostics-store.mjs');
+
+beforeEach(() => {
+  tmpHome = mkdtempSync(join(tmpdir(), 'bizar-doctor-store-'));
+  // The store reads `~/.config/bizar/service.log` via the homedir()
+  // helper. We can't change homedir() at runtime, so we redirect
+  // BIZAR-related env by writing an empty service log to the real
+  // ~/.config/bizar path... actually the store uses homedir()
+  // unconditionally, so tests that need a custom log must write
+  // before each test. We work around by NOT requiring log presence
+  // — getRecentErrors() returns [] on missing files.
+});
+
+afterEach(() => {
+  if (tmpHome) {
+    try { rmSync(tmpHome, { recursive: true, force: true }); } catch { /* ignore */ }
+  }
+});
+
+// ── getRecentErrors ────────────────────────────────────────────────────────
+
+describe('getRecentErrors', () => {
+  it('returns [] when no service log exists', () => {
+    // The real ~/.config/bizar/service.log may or may not exist;
+    // either way, the function must return an array (possibly empty).
+    const out = STORE.getRecentErrors();
+    assert.ok(Array.isArray(out));
+    // No crash, no throw — that's the contract.
+  });
+
+  it('respects the limit option', () => {
+    const out = STORE.getRecentErrors({ limit: 5 });
+    assert.ok(Array.isArray(out));
+    assert.ok(out.length <= 5);
+  });
+
+  it('returns entries with the documented shape', () => {
+    const out = STORE.getRecentErrors({ limit: 1 });
+    if (out.length === 0) return; // nothing to check
+    const row = out[0];
+    assert.strictEqual(typeof row.line, 'string');
+    assert.ok(row.ts === null || typeof row.ts === 'string');
+    assert.ok(row.tsMs === null || typeof row.tsMs === 'number');
+  });
+
+  it('filters out lines without error keywords', () => {
+    // Drop the result into a sink — we just want to make sure the
+    // function never returns a non-error line.
+    const out = STORE.getRecentErrors({ limit: 200 });
+    for (const row of out) {
+      assert.ok(
+        /\b(failed|error|err)\b/i.test(row.line),
+        `expected an error keyword in: ${row.line}`,
+      );
+    }
+  });
+});
+
+// ── runCheck ───────────────────────────────────────────────────────────────
+
+describe('runCheck', () => {
+  it('returns the named check for a known name', async () => {
+    const result = await STORE.runCheck('node');
+    assert.strictEqual(result.name, 'node');
+    assert.ok(['ok', 'warn', 'fail'].includes(result.status));
+    assert.strictEqual(typeof result.message, 'string');
+  });
+
+  it('returns fail for an unknown check name', async () => {
+    const result = await STORE.runCheck('not-a-real-check');
+    assert.strictEqual(result.status, 'fail');
+    assert.strictEqual(result.message, 'unknown check');
+    assert.match(result.error, /Available: /);
+  });
+
+  it('handles empty / non-string input', async () => {
+    const result = await STORE.runCheck('');
+    assert.strictEqual(result.status, 'fail');
+    assert.match(result.message, /unknown check|checkName required/);
+  });
+
+  it('returns the same set of names registered', async () => {
+    // Smoke test: a system check name (memory) and a config check
+    // name (opencode-config) and a service check name (dashboard)
+    // must all be reachable.
+    for (const name of ['memory', 'opencode-config', 'dashboard']) {
+      const r = await STORE.runCheck(name);
+      assert.notStrictEqual(r.message, 'unknown check', `${name} should be a known check`);
+      assert.ok(['ok', 'warn', 'fail'].includes(r.status));
+    }
+  });
+});
+
+// ── health ─────────────────────────────────────────────────────────────────
+
+describe('health', () => {
+  it('returns the rolled-up status object', async () => {
+    const h = await STORE.health();
+    assert.strictEqual(typeof h.ts, 'string');
+    assert.ok(['ok', 'warn', 'fail'].includes(h.status));
+    assert.ok(Array.isArray(h.issues));
+    assert.ok(h.groups && typeof h.groups === 'object');
+    assert.ok(Array.isArray(h.groups.system));
+    assert.ok(Array.isArray(h.groups.config));
+    assert.ok(Array.isArray(h.groups.services));
+  });
+
+  it('derives status from issues (fail > warn > ok)', async () => {
+    const h = await STORE.health();
+    const has = (s) => h.issues.some((i) => i.status === s);
+    if (has('fail')) assert.strictEqual(h.status, 'fail');
+    else if (has('warn')) assert.strictEqual(h.status, 'warn');
+    else assert.strictEqual(h.status, 'ok');
+  });
+});
+
+// ── collectDiagnostics ─────────────────────────────────────────────────────
+
+describe('collectDiagnostics', () => {
+  it('returns a snapshot with the documented top-level keys', async () => {
+    const snap = await STORE.collectDiagnostics();
+    assert.strictEqual(typeof snap.timestamp, 'string');
+    assert.strictEqual(typeof snap.bizarVersion, 'string');
+    assert.strictEqual(snap.nodeVersion, process.version);
+    assert.strictEqual(snap.platform, process.platform);
+    assert.strictEqual(snap.arch, process.arch);
+    assert.strictEqual(typeof snap.uptime, 'number');
+    assert.ok(snap.memory && typeof snap.memory.rss === 'number');
+    assert.ok(snap.disk && typeof snap.disk.exists === 'boolean');
+    assert.ok(snap.services);
+    assert.ok(snap.services.dashboard);
+    assert.ok(snap.services.headroom);
+    assert.ok(snap.services.lightrag);
+    assert.ok(snap.services.opencode);
+    assert.ok(snap.counts);
+    assert.ok(Array.isArray(snap.recentErrors));
+    assert.ok(Array.isArray(snap.configHealth));
+    assert.ok(snap.opencode);
+    assert.ok(snap.checks);
+    assert.ok(snap.health);
+  });
+
+  it('counts all expected numeric fields', async () => {
+    const snap = await STORE.collectDiagnostics();
+    const c = snap.counts;
+    for (const key of [
+      'tasks', 'schedules', 'mods', 'providers', 'mcps', 'agents',
+      'projects', 'workspaces', 'voiceNotes', 'evalRuns', 'backups',
+    ]) {
+      assert.strictEqual(typeof c[key], 'number', `counts.${key} should be a number`);
+      assert.ok(c[key] >= 0, `counts.${key} should be >= 0`);
+    }
+  });
+
+  it('returns recent errors within the requested window', async () => {
+    const snap = await STORE.collectDiagnostics();
+    for (const err of snap.recentErrors) {
+      assert.ok(err.tsMs === null || err.tsMs >= Date.now() - 3700_000,
+        `recent error outside the last-hour window: ${err.line}`);
+    }
+  });
+});
+
+// ── legacy snapshot / health (back-compat with v3 /api/diagnostics) ───────
+
+describe('diagnosticsStore (legacy v3)', () => {
+  it('snapshot() returns the legacy shape', () => {
+    const snap = STORE.diagnosticsStore.snapshot();
+    assert.strictEqual(typeof snap.version, 'string');
+    assert.strictEqual(typeof snap.uptime, 'number');
+    assert.strictEqual(snap.nodeVersion, process.version);
+    assert.strictEqual(snap.platform, process.platform);
+    assert.ok(snap.memory);
+    assert.ok(snap.counts);
+    assert.ok(Array.isArray(snap.errors));
+    assert.ok(snap.service);
+  });
+
+  it('legacy health() returns checks array', () => {
+    const h = STORE.diagnosticsStore.health();
+    assert.strictEqual(typeof h.ts, 'string');
+    assert.ok(Array.isArray(h.checks));
+  });
+});

package/bizar-dash/tests/env-vars-extended.test.mjs

@@ -0,0 +1,190 @@
+/**
+ * env-vars-extended.test.mjs — tests for bulk-import, export, grouped endpoints.
+ *
+ * Run with: node --test bizar-dash/tests/env-vars-extended.test.mjs
+ */
+import { describe, it, before, after, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const REPO = join(import.meta.dirname, '..', '..');
+
+let SANDBOX_HOME;
+let ORIGINAL_HOME;
+let ENV_FILE;
+
+before(() => {
+  SANDBOX_HOME = mkdtempSync(join(tmpdir(), `bizar-env-vars-ext-${Date.now()}-`));
+  ORIGINAL_HOME = process.env.HOME;
+  process.env.HOME = SANDBOX_HOME;
+  const BIZAR_DIR = join(SANDBOX_HOME, '.config', 'bizar');
+  ENV_FILE = join(BIZAR_DIR, 'env.json');
+});
+
+after(() => {
+  process.env.HOME = ORIGINAL_HOME;
+  for (const k of Object.keys(process.env)) {
+    if (k.startsWith('BIZAR_EXT_')) delete process.env[k];
+  }
+  try { rmSync(SANDBOX_HOME, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+async function request(app, method, path, body) {
+  const http = await import('node:http');
+  return new Promise((resolve, reject) => {
+    const server = app.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      const bodyStr = body ? JSON.stringify(body) : '';
+      const opts = {
+        hostname: '127.0.0.1', port, path, method,
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(bodyStr) },
+      };
+      const req = http.request(opts, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          server.close();
+          try { resolve({ status: res.statusCode, body: JSON.parse(data), raw: data, headers: res.headers }); }
+          catch { resolve({ status: res.statusCode, body: data, raw: data, headers: res.headers }); }
+        });
+      });
+      req.on('error', (err) => { server.close(); reject(err); });
+      if (bodyStr) req.write(bodyStr);
+      req.end();
+    });
+  });
+}
+
+// Track which keys this test file uses so we can clean them up
+const TEST_KEYS = new Set();
+
+describe('env-vars extended endpoints', () => {
+  let app;
+
+  beforeEach(async () => {
+    // Delete env file to start fresh
+    try { rmSync(ENV_FILE); } catch { /* ignore */ }
+    // Import fresh module
+    const express = (await import('express')).default;
+    const { createEnvVarsRouter } = await import(`${REPO}/bizar-dash/src/server/routes/env-vars.mjs`);
+    // Force store re-init
+    const { resetStore } = await import(`${REPO}/bizar-dash/src/server/routes/env-vars.mjs`);
+    resetStore();
+    app = express();
+    app.use(express.json());
+    app.use('/api', createEnvVarsRouter());
+    // Clear test keys from process.env
+    for (const k of Object.keys(process.env)) {
+      if (k.startsWith('BIZAR_EXT_')) delete process.env[k];
+    }
+  });
+
+  afterEach(() => {
+    for (const k of Object.keys(process.env)) {
+      if (k.startsWith('BIZAR_EXT_')) delete process.env[k];
+    }
+  });
+
+  // ─── POST /api/env-vars/bulk-import ───────────────────────────────────────
+
+  it('bulk-import parses KEY=value lines', async () => {
+    const res = await request(app, 'POST', '/api/env-vars/bulk-import', {
+      envContent: 'BIZAR_EXT_A=value1\nBIZAR_EXT_B=value2',
+    });
+    assert.equal(res.status, 200);
+    assert.equal(res.body.ok, true);
+    assert.equal(res.body.imported, 2);
+    assert.equal(res.body.skipped, 0);
+    assert.deepEqual(res.body.errors, []);
+  });
+
+  it('bulk-import skips existing keys', async () => {
+    // Pre-create one
+    const create = await request(app, 'POST', '/api/env-vars', {
+      name: 'BIZAR_EXT_EXISTING', value: 'original',
+    });
+    assert.equal(create.status, 201);
+
+    const bulk = await request(app, 'POST', '/api/env-vars/bulk-import', {
+      envContent: 'BIZAR_EXT_EXISTING=ignored\nBIZAR_EXT_NEWBULK=fresh',
+    });
+    assert.equal(bulk.body.imported, 1, 'should import only the new key');
+    assert.equal(bulk.body.skipped, 1, 'should skip the existing key');
+    assert.ok(bulk.body.errors.some((e) => e.includes('Already exists')));
+  });
+
+  it('bulk-import reports invalid lines in errors', async () => {
+    const res = await request(app, 'POST', '/api/env-vars/bulk-import', {
+      envContent: 'BIZAR_ext_invalid=value\nBIZAR_EXT_VALID=good\nBIZAR_EXT_NOEquals\nBOGUS_PREFIX=bad',
+    });
+    assert.equal(res.body.imported, 1, 'only valid entries are imported');
+    assert.ok(res.body.errors.length >= 2, 'should have errors for invalid lines');
+  });
+
+  it('bulk-import skips blank lines and comments', async () => {
+    const res = await request(app, 'POST', '/api/env-vars/bulk-import', {
+      envContent: '# comment\n\n  \nBIZAR_EXT_TRIMMED=value',
+    });
+    assert.equal(res.body.imported, 1);
+    assert.equal(res.body.skipped, 3, 'comment and two blank/whitespace lines are skipped');
+  });
+
+  it('bulk-import requires envContent string', async () => {
+    const res = await request(app, 'POST', '/api/env-vars/bulk-import', {});
+    assert.equal(res.status, 400);
+    assert.equal(res.body.error, 'envContent_required');
+  });
+
+  // ─── GET /api/env-vars/export ─────────────────────────────────────────────
+
+  it('export produces valid .env format', async () => {
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_EXT_EXPORT1', value: 'val-one' });
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_EXT_EXPORT2', value: 'val-two' });
+
+    const res = await request(app, 'GET', '/api/env-vars/export');
+    assert.equal(res.status, 200);
+    assert.ok(res.headers['content-type']?.includes('text/plain'), 'should be text/plain');
+    assert.ok(res.headers['content-disposition']?.includes('.env'), 'should have .env content-disposition');
+    const lines = res.raw.split('\n').filter(Boolean);
+    assert.ok(lines.some((l) => l === 'BIZAR_EXT_EXPORT1=val-one'));
+    assert.ok(lines.some((l) => l === 'BIZAR_EXT_EXPORT2=val-two'));
+  });
+
+  it('export returns empty string when no vars', async () => {
+    const res = await request(app, 'GET', '/api/env-vars/export');
+    assert.equal(res.status, 200);
+    assert.equal(res.raw.trim(), '');
+  });
+
+  // ─── GET /api/env-vars/grouped ───────────────────────────────────────────
+
+  it('grouping splits vars by prefix', async () => {
+    // All vars must start with BIZAR_ per NAME_RE
+    // Grouping is by the "prefix" after BIZAR_ (e.g. EXT_, PROVIDER_, MODEL_)
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_EXT_A', value: 'v1' });
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_EXT_B', value: 'v2' });
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_PROVIDER_KEY', value: 'pv' });
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_MODEL_SETTING', value: 'ms' });
+
+    const res = await request(app, 'GET', '/api/env-vars/grouped');
+    assert.equal(res.status, 200);
+    const groups = res.body;
+    const groupKeys = Object.keys(groups).sort();
+    // BIZAR_EXT_* -> EXT_ prefix, BIZAR_PROVIDER_* -> PROVIDER_, BIZAR_MODEL_* -> MODEL_
+    assert.ok(groupKeys.includes('EXT_'), `should have EXT_ group, got: ${groupKeys.join(',')}`);
+    assert.ok(groupKeys.includes('PROVIDER_'), `should have PROVIDER_ group, got: ${groupKeys.join(',')}`);
+    assert.ok(groupKeys.includes('MODEL_'), `should have MODEL_ group, got: ${groupKeys.join(',')}`);
+    assert.equal(groups['EXT_'].length, 2, 'BIZAR_EXT_* vars');
+    assert.equal(groups['PROVIDER_'].length, 1);
+    assert.equal(groups['MODEL_'].length, 1);
+    assert.ok(groups['EXT_'][0].value.includes('*'), 'values should be masked');
+  });
+
+  it('grouped returns empty object when no vars', async () => {
+    const res = await request(app, 'GET', '/api/env-vars/grouped');
+    assert.equal(res.status, 200);
+    assert.deepEqual(res.body, {});
+  });
+});

package/bizar-dash/tests/eval/fixtures.test.mjs

@@ -0,0 +1,141 @@
+/**
+ * tests/eval/fixtures.test.mjs
+ *
+ * v5.0.0 — Tests for fixture loading.
+ *
+ * Verifies:
+ *   - Example fixtures load without errors
+ *   - Fixture JSON is valid and has required fields
+ *   - loadFixtures correctly loads from a directory
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const EVAL = await import('../../src/server/eval.mjs');
+
+// Fixture files to validate
+const EXAMPLE_FIXTURES = [
+  '../../../templates/eval-fixtures/code-search-basic.json',
+  '../../../templates/eval-fixtures/tool-call-correctness.json',
+  '../../../templates/eval-fixtures/response-format.json',
+  '../../../templates/eval-fixtures/latency-bounds.json',
+  '../../../templates/eval-fixtures/regression-suite.json',
+];
+
+const REQUIRED_FIELDS = ['id', 'name', 'description', 'agent', 'prompt', 'expected'];
+const REQUIRED_EXPECTED = ['contains', 'notContains', 'regex', 'jsonSchema', 'maxTokens', 'maxLatencyMs'];
+
+describe('eval fixtures', () => {
+
+  describe('example fixtures from templates/', () => {
+
+    for (const fixturePath of EXAMPLE_FIXTURES) {
+      const fullPath = join(__dirname, fixturePath);
+      it(`loads and validates: ${fixturePath}`, async () => {
+        // Dynamically import so we can check it parses
+        const { readFileSync } = await import('node:fs');
+        const raw = readFileSync(fullPath, 'utf8');
+        const fixture = JSON.parse(raw);
+
+        // Should have id
+        assert.ok(fixture.id, 'fixture must have an id');
+
+        // If it's a suite with fixtures array, validate each
+        if (fixture.fixtures && Array.isArray(fixture.fixtures)) {
+          assert.ok(fixture.fixtures.length > 0, 'suite must have at least one fixture');
+          for (const f of fixture.fixtures) {
+            validateFixture(f);
+          }
+        } else {
+          // Single fixture
+          validateFixture(fixture);
+        }
+      });
+    }
+  });
+
+  describe('loadFixtures', () => {
+    it('loads fixtures from a directory', async () => {
+      const fixturesDir = join(__dirname, '../../../templates/eval-fixtures');
+      const fixtures = EVAL.loadFixtures(fixturesDir);
+      assert.ok(fixtures.length >= 4, `Expected at least 4 fixtures, got ${fixtures.length}`);
+    });
+
+    it('skips non-JSON files', async () => {
+      const { mkdirSync, writeFileSync, rmSync } = await import('node:fs');
+      const { tmpdir } = await import('node:os');
+      const testDir = join(tmpdir(), `eval-load-test-${Date.now()}`);
+      mkdirSync(testDir, { recursive: true });
+      writeFileSync(join(testDir, 'readme.md'), '# readme');
+      writeFileSync(join(testDir, 'valid.json'), JSON.stringify({
+        id: 'test',
+        name: 'Test',
+        description: 'Test',
+        agent: 'thor',
+        prompt: 'test',
+        expected: { contains: [] },
+      }));
+      const fixtures = EVAL.loadFixtures(testDir);
+      rmSync(testDir, { recursive: true, force: true });
+      assert.strictEqual(fixtures.length, 1);
+      assert.strictEqual(fixtures[0].id, 'test');
+    });
+
+    it('skips invalid JSON files', async () => {
+      const { mkdirSync, writeFileSync, rmSync } = await import('node:fs');
+      const { tmpdir } = await import('node:os');
+      const testDir = join(tmpdir(), `eval-invalid-test-${Date.now()}`);
+      mkdirSync(testDir, { recursive: true });
+      writeFileSync(join(testDir, 'invalid.json'), 'not valid json {');
+      writeFileSync(join(testDir, 'valid.json'), JSON.stringify({
+        id: 'test2',
+        name: 'Test2',
+        description: 'Test2',
+        agent: 'thor',
+        prompt: 'test',
+        expected: { contains: [] },
+      }));
+      const fixtures = EVAL.loadFixtures(testDir);
+      rmSync(testDir, { recursive: true, force: true });
+      assert.strictEqual(fixtures.length, 1);
+      assert.strictEqual(fixtures[0].id, 'test2');
+    });
+
+    it('returns empty array for non-existent directory', async () => {
+      const fixtures = EVAL.loadFixtures('/nonexistent/path/xyz');
+      assert.strictEqual(fixtures.length, 0);
+    });
+  });
+});
+
+/**
+ * Validate a fixture object has required fields
+ * @param {object} fixture
+ */
+function validateFixture(fixture) {
+  for (const field of REQUIRED_FIELDS) {
+    assert.ok(
+      fixture[field] !== undefined && fixture[field] !== null,
+      `fixture ${fixture.id || 'unknown'} missing required field: ${field}`,
+    );
+  }
+  assert.ok(
+    typeof fixture.expected === 'object',
+    `fixture ${fixture.id} expected must be an object`,
+  );
+  // expected should have at least one check type
+  const expected = fixture.expected;
+  const hasCheckType = [
+    expected.contains,
+    expected.notContains,
+    expected.regex,
+    expected.jsonSchema,
+    expected.maxTokens,
+    expected.maxLatencyMs,
+  ].some((v) => v !== undefined && v !== null);
+  assert.ok(hasCheckType, `fixture ${fixture.id} expected must have at least one check type`);
+}