@polderlabs/bizar 4.9.0 → 5.0.1

package/bizar-dash/tests/minimax-bar.test.tsx

@@ -0,0 +1,113 @@
+/**
+ * bizar-dash/tests/minimax-bar.test.ts
+ *
+ * Tests for MiniMax quota bar in the dashboard.
+ * Verifies bar width = consumedPct (not remainingPct).
+ */
+
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import React from 'react';
+
+// ── Minimal QuotaBar clone for testing ──────────────────────────────────────
+// This mirrors the logic in MiniMaxUsage.tsx QuotaBar component.
+
+function clamp(n: number, lo: number, hi: number): number {
+  return Math.max(lo, Math.min(hi, n));
+}
+
+function QuotaBarTest({ remainingPct, consumedPct }: { remainingPct: number; consumedPct: number }) {
+  return (
+    <div data-testid="quota-row">
+      <div data-testid="remaining-label">{remainingPct}% remaining</div>
+      <div data-testid="consumed-label">· {consumedPct}% used</div>
+      <div
+        data-testid="bar-fill"
+        style={{ width: `${consumedPct}%` }}
+        aria-label={`${consumedPct}% consumed`}
+      />
+    </div>
+  );
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+
+describe('QuotaBar width logic', () => {
+
+  it('bar width equals consumedPct, not remainingPct', () => {
+    const remainingPct = 91;
+    const consumedPct = clamp(100 - remainingPct, 0, 100);
+
+    render(<QuotaBarTest remainingPct={remainingPct} consumedPct={consumedPct} />);
+
+    const barFill = screen.getByTestId('bar-fill');
+    const styleWidth = barFill.getAttribute('style');
+
+    // Bar width should be 9% (consumed), not 91% (remaining)
+    expect(styleWidth).toMatch(/width: 9%/);
+    expect(barFill.getAttribute('aria-label')).toBe('9% consumed');
+  });
+
+  it('100% remaining → 0% consumed → 0% bar width', () => {
+    const remainingPct = 100;
+    const consumedPct = clamp(100 - remainingPct, 0, 100);
+
+    render(<QuotaBarTest remainingPct={remainingPct} consumedPct={consumedPct} />);
+
+    const barFill = screen.getByTestId('bar-fill');
+    expect(barFill.getAttribute('style')).toMatch(/width: 0%/);
+  });
+
+  it('0% remaining → 100% consumed → 100% bar width', () => {
+    const remainingPct = 0;
+    const consumedPct = clamp(100 - remainingPct, 0, 100);
+
+    render(<QuotaBarTest remainingPct={remainingPct} consumedPct={consumedPct} />);
+
+    const barFill = screen.getByTestId('bar-fill');
+    expect(barFill.getAttribute('style')).toMatch(/width: 100%/);
+  });
+
+  it('75% remaining → 25% consumed → 25% bar width', () => {
+    const remainingPct = 75;
+    const consumedPct = clamp(100 - remainingPct, 0, 100);
+
+    render(<QuotaBarTest remainingPct={remainingPct} consumedPct={consumedPct} />);
+
+    const barFill = screen.getByTestId('bar-fill');
+    expect(barFill.getAttribute('style')).toMatch(/width: 25%/);
+  });
+
+  it('consumedPct = 100 - remainingPct', () => {
+    const testCases = [
+      { remaining: 100, expectedConsumed: 0 },
+      { remaining: 91, expectedConsumed: 9 },
+      { remaining: 75, expectedConsumed: 25 },
+      { remaining: 50, expectedConsumed: 50 },
+      { remaining: 25, expectedConsumed: 75 },
+      { remaining: 9, expectedConsumed: 91 },
+      { remaining: 0, expectedConsumed: 100 },
+    ];
+
+    for (const { remaining, expectedConsumed } of testCases) {
+      const consumed = clamp(100 - remaining, 0, 100);
+      expect(consumed).toBe(expectedConsumed);
+    }
+  });
+
+  it('clamp keeps values within 0-100 range', () => {
+    expect(clamp(-10, 0, 100)).toBe(0);
+    expect(clamp(110, 0, 100)).toBe(100);
+    expect(clamp(50, 0, 100)).toBe(50);
+  });
+
+  it('labels show both remaining and consumed', () => {
+    const remainingPct = 91;
+    const consumedPct = clamp(100 - remainingPct, 0, 100);
+
+    render(<QuotaBarTest remainingPct={remainingPct} consumedPct={consumedPct} />);
+
+    expect(screen.getByTestId('remaining-label').textContent).toBe('91% remaining');
+    expect(screen.getByTestId('consumed-label').textContent).toBe('· 9% used');
+  });
+});

package/bizar-dash/tests/minimax-models.test.mjs

@@ -0,0 +1,123 @@
+/**
+ * minimax-models.test.mjs — verify MiniMax is the default/primary provider
+ * and that the catalog, constants, and agent configs all agree.
+ *
+ * Run with: node --test tests/minimax-models.test.mjs
+ */
+import { describe, it, before } from 'node:test';
+import assert from 'node:assert/strict';
+import { resolve, join } from 'node:path';
+import { readFileSync, readdirSync } from 'node:fs';
+import { existsSync } from 'node:fs';
+
+const REPO = resolve(import.meta.dirname, '..', '..');
+
+let mod;
+let AGENTS_DIR;
+
+before(async () => {
+  const cacheBust = '?cb=' + Date.now() + '-' + Math.random().toString(36).slice(2);
+  mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + cacheBust);
+  AGENTS_DIR = join(REPO, 'config', 'agents');
+});
+
+describe('MiniMax model constants', () => {
+  it('MINIMAX_DEFAULT is MiniMax-M2.7', () => {
+    assert.equal(mod.MINIMAX_DEFAULT, 'MiniMax-M2.7');
+  });
+});
+
+describe('PROVIDER_CATALOG MiniMax entry', () => {
+  it('minimax is present in the catalog', () => {
+    const minimax = mod.PROVIDER_CATALOG.find((p) => p.id === 'minimax');
+    assert.ok(minimax, 'minimax provider not found in PROVIDER_CATALOG');
+  });
+
+  it('has at least 4 models', () => {
+    const minimax = mod.PROVIDER_CATALOG.find((p) => p.id === 'minimax');
+    assert.ok(minimax.models.length >= 4,
+      `expected at least 4 MiniMax models, got ${minimax.models.length}`);
+  });
+
+  it('includes MiniMax-M2.7-Flash as recommended cheap model', () => {
+    const minimax = mod.PROVIDER_CATALOG.find((p) => p.id === 'minimax');
+    const flash = minimax.models.find((m) => {
+      const id = typeof m === 'string' ? m : m.id;
+      return id === 'MiniMax-M2.7-Flash';
+    });
+    assert.ok(flash, 'MiniMax-M2.7-Flash not found in catalog');
+    if (typeof flash === 'object') {
+      assert.equal(flash.tier, 'cheap');
+      assert.equal(flash.recommended, true);
+    }
+  });
+
+  it('includes MiniMax-M2.7 (default cheap)', () => {
+    const minimax = mod.PROVIDER_CATALOG.find((p) => p.id === 'minimax');
+    const m27 = minimax.models.find((m) => {
+      const id = typeof m === 'string' ? m : m.id;
+      return id === 'MiniMax-M2.7';
+    });
+    assert.ok(m27, 'MiniMax-M2.7 not found in catalog');
+  });
+
+  it('includes MiniMax-M3 (mid tier)', () => {
+    const minimax = mod.PROVIDER_CATALOG.find((p) => p.id === 'minimax');
+    const m3 = minimax.models.find((m) => {
+      const id = typeof m === 'string' ? m : m.id;
+      return id === 'MiniMax-M3';
+    });
+    assert.ok(m3, 'MiniMax-M3 not found in catalog');
+  });
+
+  it('includes MiniMax-M3-Reasoning (premium)', () => {
+    const minimax = mod.PROVIDER_CATALOG.find((p) => p.id === 'minimax');
+    const m3r = minimax.models.find((m) => {
+      const id = typeof m === 'string' ? m : m.id;
+      return id === 'MiniMax-M3-Reasoning';
+    });
+    assert.ok(m3r, 'MiniMax-M3-Reasoning not found in catalog');
+  });
+});
+
+describe('Agent .md files use MiniMax models', () => {
+  // Agents that should be on minimax/MiniMax-M2.7
+  const m27Agents = ['frigg', 'heimdall', 'mimir', 'vor', 'semble-search', 'hermod', 'thor', 'baldr'];
+  // Agents that should be on minimax/MiniMax-M3
+  const m3Agents = ['tyr', 'vidarr', 'forseti', 'odin'];
+  // Agents that should be on minimax/MiniMax-M2.7-Flash
+  const flashAgents = ['quick'];
+
+  for (const agent of m27Agents) {
+    it(`${agent} uses minimax/MiniMax-M2.7`, () => {
+      const file = join(AGENTS_DIR, `${agent}.md`);
+      if (!existsSync(file)) { assert.fail(`agent file not found: ${file}`); }
+      const raw = readFileSync(file, 'utf8');
+      const match = raw.match(/^model:\s*([^\s#]+)/m);
+      assert.ok(match, `${agent}.md has no model: line`);
+      assert.equal(match[1], 'minimax/MiniMax-M2.7', `${agent} should use MiniMax-M2.7, got ${match[1]}`);
+    });
+  }
+
+  for (const agent of m3Agents) {
+    it(`${agent} uses minimax/MiniMax-M3`, () => {
+      const file = join(AGENTS_DIR, `${agent}.md`);
+      if (!existsSync(file)) { assert.fail(`agent file not found: ${file}`); }
+      const raw = readFileSync(file, 'utf8');
+      const match = raw.match(/^model:\s*([^\s#]+)/m);
+      assert.ok(match, `${agent}.md has no model: line`);
+      assert.equal(match[1], 'minimax/MiniMax-M3', `${agent} should use MiniMax-M3, got ${match[1]}`);
+    });
+  }
+
+  for (const agent of flashAgents) {
+    it(`${agent} uses minimax/MiniMax-M2.7-Flash`, () => {
+      const file = join(AGENTS_DIR, `${agent}.md`);
+      if (!existsSync(file)) { assert.fail(`agent file not found: ${file}`); }
+      const raw = readFileSync(file, 'utf8');
+      const match = raw.match(/^model:\s*([^\s#]+)/m);
+      assert.ok(match, `${agent}.md has no model: line`);
+      assert.equal(match[1], 'minimax/MiniMax-M2.7-Flash', `${agent} should use MiniMax-M2.7-Flash, got ${match[1]}`);
+    });
+  }
+});

package/bizar-dash/tests/ocr.test.mjs

@@ -0,0 +1,87 @@
+/**
+ * tests/ocr.test.mjs
+ *
+ * v5.0.0 — Tests for the OCR helper module and routes.
+ *
+ * The extractText tests require tesseract.js to be installed.
+ */
+
+import { describe, it, beforeEach, afterEach, before } from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync } from 'node:fs';
+
+// ── Test OCR helper ────────────────────────────────────────────────────────────
+
+describe('ocr.extractText', () => {
+  let ocrModule;
+
+  before(async () => {
+    try {
+      ocrModule = await import('../src/server/ocr.mjs');
+    } catch {
+      // tesseract.js or its deps not available
+    }
+  });
+
+  it('extractText returns a string for a valid PNG buffer', { skip: !ocrModule }, async () => {
+    const pngBuffer = Buffer.from(
+      'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+      'base64',
+    );
+    const text = await ocrModule.extractText(pngBuffer);
+    assert.strictEqual(typeof text, 'string');
+  });
+
+  it('checkOcrHealth returns ok or error message', { skip: !ocrModule }, async () => {
+    const health = await ocrModule.checkOcrHealth();
+    assert.ok(typeof health.ok === 'boolean');
+    assert.ok(typeof health.message === 'string');
+  });
+});
+
+// ── Test OCR routes ────────────────────────────────────────────────────────────
+
+describe('ocr routes', () => {
+  let projectRoot;
+  let server;
+  let baseUrl;
+  let ocrRouterModule;
+
+  before(async () => {
+    ocrRouterModule = await import('../src/server/routes/ocr.mjs');
+  });
+
+  beforeEach(async () => {
+    projectRoot = join(tmpdir(), `bizar-ocr-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+
+    const express = (await import('express')).default;
+    const router = await ocrRouterModule.createOcrRouter({ projectRoot });
+    const app = express();
+    app.use(express.json({ limit: '25mb' }));
+    app.use('/api', router);
+
+    await new Promise((resolve) => {
+      server = app.listen(0, () => {
+        const addr = server.address();
+        baseUrl = `http://127.0.0.1:${addr.port}`;
+        resolve();
+      });
+    });
+  });
+
+  afterEach(() => {
+    try { server?.close?.(); } catch { /* ignore */ }
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('GET /api/ocr/list returns entries array', async () => {
+    const r = await fetch(`${baseUrl}/api/ocr/list`);
+    assert.strictEqual(r.status, 200);
+    const data = await r.json();
+    assert.ok(Array.isArray(data.entries));
+  });
+});

package/bizar-dash/tests/opencode-sessions-detail.test.mjs

@@ -64,8 +64,32 @@ function startUpstream() {
         res.end(JSON.stringify({ data: [{ id: 'sess-1', title: 'Test', time: { created: 1, updated: 2, archived: null }, location: { directory: '/tmp/session-worktree' } }] }));
         return;
       }
+      // v5.0.0 — bug #4: per-session probe used by `worktreeHasSession`
+      // (resolveSessionDirectory fast-path). Matches `/api/session/{id}`
+      // (no `/message` or `/prompt` suffix). 200 when the session
+      // belongs to the directory in the query string; 404 otherwise.
+      const probeM = url.pathname.match(/^\/api\/session\/([^/]+)$/);
+      if (probeM && req.method === 'GET') {
+        const dir = url.searchParams.get('directory') || '';
+        // The session "lives" in /tmp/session-worktree (matches the
+        // recorded worktree in writeServeJson). All other directories
+        // 404 so we can test the fallback path.
+        if (dir === '/tmp/session-worktree') {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ id: probeM[1] }));
+          return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'session not found in directory' }));
+        return;
+      }
       const msgM = url.pathname.match(/^\/api\/session\/([^/]+)\/message$/);
       if (msgM && req.method === 'GET') {
+        if (msgM[1] === 'sess-upstream-500') {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'internal server error for testing' }));
+          return;
+        }
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ data: [
           { info: { id: 'm1', role: 'user', time: { created: 1000 } }, parts: [{ type: 'text', text: 'hello' }] },
@@ -128,6 +152,10 @@ function writeServeJson(worktree) {
   writeFileSync(SERVE_JSON_PATH, JSON.stringify({ port: upstreamPort, password: 'test-pw', worktree, pid: 99999, startedAt: Date.now() }), 'utf8');
 }
 
+function writeServeJsonWithoutWorktree() {
+  writeFileSync(SERVE_JSON_PATH, JSON.stringify({ port: upstreamPort, password: 'test-pw', pid: 99999, startedAt: Date.now() }), 'utf8');
+}
+
 /** Move serve.json aside so readServeInfo() returns null.
  *  Uses copy + unlink because rename across filesystems (e.g.
  *  /home/* → /tmp/*) throws EXDEV on Linux. */
@@ -273,4 +301,134 @@ test('SSE stream unwraps sync envelopes and strips version suffix', async () =>
   const d = JSON.parse(events[0].data);
   assert.equal(d.sessionID, 'our-id');
   assert.equal(d.messageID, 'm3');
+});
+
+// ── Error handling tests ─────────────────────────────────────────────────
+
+test('GET messages returns 503 directory_unknown when worktree missing and session not found', async () => {
+  writeServeJsonWithoutWorktree();
+  try {
+    // Request a non-existent session ID so listOpencodeSessions doesn't find it,
+    // and with no worktree in serve.json, resolveSessionDirectory returns null.
+    const res = await fetch(`${dashboardBaseUrl}/api/opencode-sessions/no-such-session/messages`);
+    assert.equal(res.status, 503);
+    const body = await res.json();
+    assert.equal(body.error, 'directory_unknown');
+    assert.ok(body.message.length > 0);
+    assert.ok(typeof body.suggestion === 'string');
+  } finally {
+    // Restore worktree for subsequent tests.
+    writeServeJson('/tmp/session-worktree');
+  }
+});
+
+test('GET messages returns 502 opencode_error when upstream returns 500', async () => {
+  writeServeJson('/tmp/session-worktree');
+  const res = await fetch(`${dashboardBaseUrl}/api/opencode-sessions/sess-upstream-500/messages`);
+  assert.equal(res.status, 502);
+  const body = await res.json();
+  assert.equal(body.error, 'opencode_error');
+  assert.ok(body.message.length > 0);
+  assert.ok(body.cause === 'unknown' || typeof body.cause === 'string');
+  assert.ok(typeof body.suggestion === 'string');
+});
+
+test('GET messages uses suggestion field in error responses', async () => {
+  // Test that the plugin_offline response includes suggestion.
+  moveServeJsonAside();
+  try {
+    const res = await fetch(`${dashboardBaseUrl}/api/opencode-sessions/sess-1/messages`);
+    assert.equal(res.status, 503);
+    const body = await res.json();
+    assert.equal(body.error, 'plugin_offline');
+    assert.ok(typeof body.suggestion === 'string');
+    assert.ok(body.suggestion.length > 0);
+  } finally {
+    // Restore so the after() cleanup finds the file.
+    writeServeJson('/tmp/session-worktree');
+  }
+});
+
+// ── v5.0.0 — bug #4 — structured error envelopes + worktree fast-path ──
+
+test('GET messages 502 envelope includes cause/status/suggestion on upstream failure', async () => {
+  // Issue: bug #4 — the user previously saw the raw error string
+  // ("listMessages network error: fetch failed") with no structured
+  // fields. The fix is to surface `cause`, `status`, and `suggestion`
+  // so the front-end ChatInfoPanel can render actionable UI.
+  writeServeJson('/tmp/session-worktree');
+  const res = await fetch(
+    `${dashboardBaseUrl}/api/opencode-sessions/sess-upstream-500/messages`,
+  );
+  assert.equal(res.status, 502);
+  const body = await res.json();
+  assert.equal(body.error, 'opencode_error');
+  assert.equal(typeof body.message, 'string');
+  assert.ok(body.message.length > 0);
+  // Upstream 500 → cause stays 'unknown' (no network code), and the
+  // route forwards the upstream's HTTP status so the operator can
+  // tell whether it's opencode that's broken vs. the dashboard.
+  assert.ok(typeof body.cause === 'string');
+  assert.equal(body.status, 500);
+  assert.ok(typeof body.suggestion === 'string');
+  assert.ok(body.suggestion.length > 0);
+});
+
+test('GET messages 503 plugin_offline envelope includes suggestion (operator guidance)', async () => {
+  // Defensive: confirm the 503 path also carries a suggestion (some
+  // consumers — including the structured-error path in useChat.ts —
+  // branch on `body.code === 'plugin_offline'`).
+  moveServeJsonAside();
+  try {
+    const res = await fetch(
+      `${dashboardBaseUrl}/api/opencode-sessions/sess-1/messages`,
+    );
+    assert.equal(res.status, 503);
+    const body = await res.json();
+    assert.equal(body.error, 'plugin_offline');
+    assert.ok(typeof body.suggestion === 'string');
+    assert.ok(body.suggestion.length > 0);
+    assert.match(body.suggestion, /bizar doctor|opencode serve/i);
+  } finally {
+    writeServeJson('/tmp/session-worktree');
+  }
+});
+
+test('GET messages 503 directory_unknown envelope includes suggestion', async () => {
+  writeServeJsonWithoutWorktree();
+  try {
+    const res = await fetch(
+      `${dashboardBaseUrl}/api/opencode-sessions/no-such-session/messages`,
+    );
+    assert.equal(res.status, 503);
+    const body = await res.json();
+    assert.equal(body.error, 'directory_unknown');
+    assert.ok(typeof body.message === 'string');
+    assert.ok(typeof body.suggestion === 'string');
+    assert.ok(body.suggestion.length > 0);
+  } finally {
+    writeServeJson('/tmp/session-worktree');
+  }
+});
+
+test('GET messages uses worktree fast-path when session exists in recorded worktree', async () => {
+  // The new resolveSessionDirectory fast-path probes the recorded
+  // worktree first (cheap GET /api/session/{id}?directory=... probe).
+  // When the upstream says yes, the resolver returns the worktree
+  // WITHOUT calling GET /api/session. We assert the latter is NOT
+  // called by checking the upstream.promptHits / request log isn't
+  // touched (only the messages endpoint should fire here).
+  //
+  // Indirect check: request a session whose id is NOT in the
+  // /api/session listing but IS in /tmp/session-worktree per the
+  // probe. The probe handler returns 200 for that directory, so the
+  // route should succeed even though the session isn't in the list.
+  writeServeJson('/tmp/session-worktree');
+  const res = await fetch(
+    `${dashboardBaseUrl}/api/opencode-sessions/sess-1/messages`,
+  );
+  assert.equal(res.status, 200);
+  const body = await res.json();
+  assert.ok(Array.isArray(body.messages));
+  assert.ok(body.messages.length >= 1);
 });