@polderlabs/bizar 5.2.0 → 5.3.1

package/bizar-dash/tests/a11y/forms.test.tsx

@@ -0,0 +1,191 @@
+// tests/a11y/forms.test.tsx — WCAG 2.1.1 / 3.3.1 form accessibility for Doctor and Schedules.
+//
+// Tests that all form inputs have accessible names (label, aria-label,
+// or aria-labelledby), and that form errors and live regions are announced.
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { Doctor } from '../../src/web/views/Doctor';
+import { Schedules } from '../../src/web/views/Schedules';
+import { ToastProvider } from '../../src/web/components/Toast';
+import { ModalProvider } from '../../src/web/components/Modal';
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/** Assert every input/select/textarea in the container has an accessible name. */
+function expectAllInputsAccessible(container: HTMLElement) {
+  const inputs = container.querySelectorAll('input, select, textarea');
+  const offenders: string[] = [];
+  inputs.forEach((el) => {
+    if ((el as HTMLInputElement).type === 'hidden') return;
+    const accessibleName =
+      el.getAttribute('aria-label') ||
+      el.getAttribute('aria-labelledby') ||
+      el.getAttribute('placeholder') ||
+      el.getAttribute('title');
+    let labelledByLabel = false;
+    if (el.id) {
+      labelledByLabel = !!container.querySelector(`label[for="${el.id}"]`);
+    }
+    if (!accessibleName && !labelledByLabel) {
+      offenders.push(
+        `<${el.tagName.toLowerCase()}${el.id ? ` id="${el.id}"` : ''}${el.getAttribute('type') ? ` type="${el.getAttribute('type')}"` : ''}> has no accessible name`,
+      );
+    }
+  });
+  expect(offenders, offenders.join('\n')).toEqual([]);
+}
+
+/** Assert every button in the container has an accessible name. */
+function expectAllButtonsAccessible(container: HTMLElement) {
+  const buttons = container.querySelectorAll('button');
+  const offenders: string[] = [];
+  buttons.forEach((el) => {
+    const ariaLabel = el.getAttribute('aria-label');
+    const labelledBy = el.getAttribute('aria-labelledby');
+    const text = (el.textContent || '').trim();
+    const title = el.getAttribute('title');
+    if (!ariaLabel && !labelledBy && !text && !title) {
+      offenders.push(`<button> has no accessible name`);
+    }
+  });
+  expect(offenders, offenders.join('\n')).toEqual([]);
+}
+
+function renderWithProviders(ui: React.ReactNode) {
+  return render(
+    <ToastProvider>
+      <ModalProvider>{ui}</ModalProvider>
+    </ToastProvider>,
+  );
+}
+
+// ─── Doctor ─────────────────────────────────────────────────────────────────
+
+const FAKE_SNAPSHOT = {
+  bizarreVersion: '99.0.0',
+  platform: 'linux',
+  arch: 'x64',
+  uptime: 3600,
+  tasks: 0,
+  schedules: 0,
+  mods: 0,
+  providers: 0,
+  mcps: 0,
+  agents: 0,
+  projects: 0,
+  workspaces: 0,
+  voiceNotes: 0,
+  evalRuns: 0,
+  backups: 0,
+  activeProject: null,
+};
+
+const FAKE_SETTINGS = {};
+
+describe('Doctor — WCAG 3.3.1: form inputs have accessible names + aria-live', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    // Mock the API to avoid real network calls
+    vi.spyOn(require('../../src/web/lib/api'), 'api').mockImplementation(() => ({
+      get: vi.fn().mockResolvedValue({
+        health: { status: 'ok', issues: [] },
+        checks: { system: [], services: [], config: [], counts: [] },
+        bizarreVersion: '99.0.0',
+        platform: 'linux',
+        arch: 'x64',
+        uptime: 3600,
+        counts: {},
+        recentErrors: [],
+      }),
+      post: vi.fn().mockResolvedValue({ name: 'test', message: 'ok' }),
+    }));
+  });
+
+  it('the "Run Health Check Now" button has aria-label="Refresh diagnostics"', async () => {
+    renderWithProviders(
+      <Doctor
+        snapshot={FAKE_SNAPSHOT}
+        settings={FAKE_SETTINGS}
+        activeTab="doctor"
+        setActiveTab={() => {}}
+        refreshSnapshot={() => Promise.resolve()}
+      />,
+    );
+    const btn = screen.getByRole('button', { name: /refresh diagnostics/i });
+    expect(btn).toBeInTheDocument();
+  });
+
+  it('the auto-refresh toggle button has an accessible name', async () => {
+    renderWithProviders(
+      <Doctor
+        snapshot={FAKE_SNAPSHOT}
+        settings={FAKE_SETTINGS}
+        activeTab="doctor"
+        setActiveTab={() => {}}
+        refreshSnapshot={() => Promise.resolve()}
+      />,
+    );
+    // The button shows "Pause auto-refresh" or "Resume auto-refresh"
+    const btn = screen.getByRole('button', { name: /(pause|resume) auto-refresh/i });
+    expect(btn).toBeInTheDocument();
+  });
+
+  it('header meta region has aria-live="polite"', async () => {
+    renderWithProviders(
+      <Doctor
+        snapshot={FAKE_SNAPSHOT}
+        settings={FAKE_SETTINGS}
+        activeTab="doctor"
+        setActiveTab={() => {}}
+        refreshSnapshot={() => Promise.resolve()}
+      />,
+    );
+    const liveRegion = document.querySelector('[aria-live="polite"]');
+    expect(liveRegion).toBeInTheDocument();
+  });
+});
+
+// ─── Schedules ───────────────────────────────────────────────────────────────
+
+describe('Schedules — WCAG 3.3.1: all form inputs have accessible names', () => {
+  it('the Refresh button has aria-label="Refresh schedules"', () => {
+    renderWithProviders(
+      <Schedules
+        snapshot={FAKE_SNAPSHOT}
+        settings={FAKE_SETTINGS}
+        activeTab="schedules"
+        setActiveTab={() => {}}
+        refreshSnapshot={() => Promise.resolve()}
+      />,
+    );
+    const btn = screen.getByRole('button', { name: /refresh schedules/i });
+    expect(btn).toBeInTheDocument();
+  });
+
+  it('all visible inputs in the Schedules view have accessible names', () => {
+    const { container } = renderWithProviders(
+      <Schedules
+        snapshot={FAKE_SNAPSHOT}
+        settings={FAKE_SETTINGS}
+        activeTab="schedules"
+        setActiveTab={() => {}}
+        refreshSnapshot={() => Promise.resolve()}
+      />,
+    );
+    expectAllInputsAccessible(container);
+  });
+
+  it('all visible buttons in the Schedules view have accessible names', () => {
+    const { container } = renderWithProviders(
+      <Schedules
+        snapshot={FAKE_SNAPSHOT}
+        settings={FAKE_SETTINGS}
+        activeTab="schedules"
+        setActiveTab={() => {}}
+        refreshSnapshot={() => Promise.resolve()}
+      />,
+    );
+    expectAllButtonsAccessible(container);
+  });
+});

package/bizar-dash/tests/a11y/navigation.test.tsx

@@ -0,0 +1,112 @@
+// tests/a11y/navigation.test.tsx — WCAG 2.1.1 / 2.4.1 navigation accessibility.
+//
+// Tests that sidebar, tabs, and the Memory source rail all meet
+// keyboard navigation, role, and aria attributes requirements.
+
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { Memory } from '../../src/web/views/Memory';
+import { Plugins } from '../../src/web/views/Plugins';
+import { ToastProvider } from '../../src/web/components/Toast';
+import { ModalProvider } from '../../src/web/components/Modal';
+
+function renderWithProviders(ui: React.ReactNode) {
+  return render(
+    <ToastProvider>
+      <ModalProvider>{ui}</ModalProvider>
+    </ToastProvider>,
+  );
+}
+
+// ─── Memory tab ──────────────────────────────────────────────────────────────
+
+describe('Memory — WCAG 2.4.1: nav has aria-label, tabs have role=tab + aria-selected', () => {
+  it('source rail has aria-label="Memory sources"', () => {
+    renderWithProviders(
+      <Memory
+        snapshot={{} as any}
+        settings={{} as any}
+        activeTab="memory"
+        setActiveTab={() => {}}
+        refreshSnapshot={() => Promise.resolve()}
+      />,
+    );
+    const nav = document.querySelector('[aria-label="Memory sources"]');
+    expect(nav).toBeInTheDocument();
+  });
+
+  it('each source button has role="tab"', () => {
+    renderWithProviders(
+      <Memory
+        snapshot={{} as any}
+        settings={{} as any}
+        activeTab="memory"
+        setActiveTab={() => {}}
+        refreshSnapshot={() => Promise.resolve()}
+      />,
+    );
+    const tabs = screen.getAllByRole('tab');
+    expect(tabs.length).toBeGreaterThan(0);
+  });
+
+  it('active tab has aria-selected="true"', () => {
+    renderWithProviders(
+      <Memory
+        snapshot={{} as any}
+        settings={{} as any}
+        activeTab="memory"
+        setActiveTab={() => {}}
+        refreshSnapshot={() => Promise.resolve()}
+      />,
+    );
+    const activeTab = screen.getByRole('tab', { selected: true });
+    expect(activeTab).toBeInTheDocument();
+  });
+
+  it('inactive tabs have aria-selected="false"', () => {
+    renderWithProviders(
+      <Memory
+        snapshot={{} as any}
+        settings={{} as any}
+        activeTab="memory"
+        setActiveTab={() => {}}
+        refreshSnapshot={() => Promise.resolve()}
+      />,
+    );
+    const tabs = screen.getAllByRole('tab');
+    const unselected = tabs.filter((t) => !t.getAttribute('aria-selected') || t.getAttribute('aria-selected') === 'false');
+    expect(unselected.length).toBeGreaterThan(0);
+  });
+
+  it('refresh button has aria-label="Refresh memory"', () => {
+    renderWithProviders(
+      <Memory
+        snapshot={{} as any}
+        settings={{} as any}
+        activeTab="memory"
+        setActiveTab={() => {}}
+        refreshSnapshot={() => Promise.resolve()}
+      />,
+    );
+    const btn = screen.getByRole('button', { name: /refresh memory/i });
+    expect(btn).toBeInTheDocument();
+  });
+});
+
+// ─── Plugins ─────────────────────────────────────────────────────────────────
+
+describe('Plugins — WCAG 2.1.1: filter input has accessible name', () => {
+  it('the filter input has aria-label="Filter plugins"', () => {
+    renderWithProviders(
+      <Plugins
+        snapshot={{} as any}
+        settings={{} as any}
+        activeTab="plugins"
+        setActiveTab={() => {}}
+        refreshSnapshot={() => Promise.resolve()}
+      />,
+    );
+    const input = document.querySelector('input[type="search"]');
+    expect(input).toHaveAttribute('aria-label', 'Filter plugins');
+  });
+});

package/bizar-dash/tests/components/marketplace-plugin-card.test.tsx

@@ -0,0 +1,144 @@
+// tests/components/marketplace-plugin-card.test.tsx — MarketplacePluginCard and InstallConfirmDialog unit tests.
+
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi } from 'vitest';
+import { ModalProvider } from '../../src/web/components/Modal';
+import { MarketplacePluginCard } from '../../src/web/components/MarketplacePluginCard';
+import { InstallConfirmDialog } from '../../src/web/components/InstallConfirmDialog';
+import { PluginPermissions } from '../../src/web/components/PluginPermissions';
+
+const defaultPlugin = {
+  id: 'test-marketplace-plugin',
+  name: 'Test Marketplace Plugin',
+  version: '2.1.0',
+  author: 'TestAuthor',
+  description: 'A test plugin for the marketplace',
+  category: 'Utilities',
+  tags: ['testing', 'utility'],
+  permissions: ['net', 'fs'],
+};
+
+describe('MarketplacePluginCard', () => {
+  it('renders name, version, description', () => {
+    render(
+      <MarketplacePluginCard
+        plugin={defaultPlugin}
+        onInstall={vi.fn()}
+        onView={vi.fn()}
+      />,
+    );
+    expect(screen.getByText('Test Marketplace Plugin')).toBeInTheDocument();
+    expect(screen.getByText('v2.1.0 · Utilities')).toBeInTheDocument();
+    expect(screen.getByText('A test plugin for the marketplace')).toBeInTheDocument();
+  });
+
+  it('shows tags as chips', () => {
+    render(
+      <MarketplacePluginCard
+        plugin={defaultPlugin}
+        onInstall={vi.fn()}
+        onView={vi.fn()}
+      />,
+    );
+    expect(screen.getByText('testing')).toBeInTheDocument();
+    expect(screen.getByText('utility')).toBeInTheDocument();
+  });
+
+  it('shows permissions', () => {
+    render(
+      <MarketplacePluginCard
+        plugin={defaultPlugin}
+        onInstall={vi.fn()}
+        onView={vi.fn()}
+      />,
+    );
+    // PluginPermissions renders "Network access" for 'net' and "Filesystem" for 'fs'
+    expect(screen.getByText('Network access')).toBeInTheDocument();
+    expect(screen.getByText('Filesystem')).toBeInTheDocument();
+  });
+
+  it('calls onInstall when Install clicked', async () => {
+    const onInstall = vi.fn();
+    const user = userEvent.setup();
+    render(
+      <MarketplacePluginCard
+        plugin={defaultPlugin}
+        onInstall={onInstall}
+        onView={vi.fn()}
+      />,
+    );
+    await user.click(screen.getByRole('button', { name: 'Install' }));
+    expect(onInstall).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls onView when Details clicked', async () => {
+    const onView = vi.fn();
+    const user = userEvent.setup();
+    render(
+      <MarketplacePluginCard
+        plugin={defaultPlugin}
+        onInstall={vi.fn()}
+        onView={onView}
+      />,
+    );
+    await user.click(screen.getByRole('button', { name: 'Details' }));
+    expect(onView).toHaveBeenCalledTimes(1);
+  });
+});
+
+function InstallConfirmDialogTestHarness({ plugin, installing = false }: {
+  plugin: typeof defaultPlugin;
+  installing?: boolean;
+}) {
+  return (
+    <ModalProvider>
+      <InstallConfirmDialog
+        plugin={plugin}
+        onConfirm={vi.fn()}
+        onCancel={vi.fn()}
+        installing={installing}
+      />
+    </ModalProvider>
+  );
+}
+
+describe('InstallConfirmDialog', () => {
+  it('renders plugin name and description', async () => {
+    render(<InstallConfirmDialogTestHarness plugin={defaultPlugin} />);
+    // The dialog content is rendered in a modal, check for the title
+    expect(await screen.findByText('Install Test Marketplace Plugin?')).toBeInTheDocument();
+    expect(screen.getByText('A test plugin for the marketplace')).toBeInTheDocument();
+  });
+
+  it('shows permissions prominently', async () => {
+    render(<InstallConfirmDialogTestHarness plugin={defaultPlugin} />);
+    expect(await screen.findByText('Network access')).toBeInTheDocument();
+    expect(screen.getByText('Filesystem')).toBeInTheDocument();
+  });
+
+  it('disables buttons during install', async () => {
+    render(<InstallConfirmDialogTestHarness plugin={defaultPlugin} installing={true} />);
+    expect(await screen.findByRole('button', { name: 'Installing...' })).toBeDisabled();
+    expect(screen.getByRole('button', { name: 'Cancel' })).toBeDisabled();
+  });
+});
+
+describe('PluginPermissions', () => {
+  it('renders each permission as a chip', () => {
+    render(<PluginPermissions permissions={['net', 'fs']} />);
+    expect(screen.getByText('Network access')).toBeInTheDocument();
+    expect(screen.getByText('Filesystem')).toBeInTheDocument();
+  });
+
+  it('shows unknown permission with default label', () => {
+    render(<PluginPermissions permissions={['unknown_perm']} />);
+    expect(screen.getByText('unknown_perm')).toBeInTheDocument();
+  });
+
+  it('handles empty permissions array', () => {
+    const { container } = render(<PluginPermissions permissions={[]} />);
+    expect(container.querySelector('.plugin-permissions')).toBeInTheDocument();
+    expect(container.querySelectorAll('.permission-chip')).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,67 @@
+// tests/eval-csv.test.mjs — v5.3.0
+// Tests for CSV export functionality in eval.mjs
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { toCSV } from '../src/server/eval.mjs';
+
+describe('CSV export', () => {
+  it('produces valid CSV with headers', () => {
+    const csv = toCSV([
+      { fixtureId: 'test-1', name: 'Test', ok: true, latencyMs: 100, checks: [] },
+    ]);
+    assert.ok(csv.split('\n')[0].includes('fixture_id'));
+    assert.ok(csv.split('\n')[0].includes('name'));
+    assert.ok(csv.split('\n')[0].includes('ok'));
+    assert.ok(csv.split('\n')[0].includes('pass_count'));
+    assert.ok(csv.split('\n')[0].includes('fail_count'));
+    assert.ok(csv.split('\n')[0].includes('latency_ms'));
+    assert.ok(csv.split('\n')[0].includes('tokens'));
+    assert.ok(csv.split('\n')[0].includes('timestamp'));
+  });
+
+  it('escapes commas in values', () => {
+    const csv = toCSV([{ fixtureId: 'a,b', ok: true, checks: [] }]);
+    assert.ok(csv.includes('"a,b"'));
+  });
+
+  it('escapes quotes in values', () => {
+    const csv = toCSV([{ fixtureId: 'a"b', ok: true, checks: [] }]);
+    assert.ok(csv.includes('"a""b"'));
+  });
+
+  it('handles newlines in values', () => {
+    const csv = toCSV([{ fixtureId: 'a\nb', ok: true, checks: [] }]);
+    assert.ok(csv.includes('"a\nb"'));
+  });
+
+  it('outputs ok as 1 or 0', () => {
+    const csvPass = toCSV([{ fixtureId: 'p', ok: true, checks: [] }]);
+    const csvFail = toCSV([{ fixtureId: 'f', ok: false, checks: [] }]);
+    assert.ok(csvPass.match(/,1,/));
+    assert.ok(csvFail.match(/,0,/));
+  });
+
+  it('counts pass/fail checks correctly', () => {
+    const csv = toCSV([
+      {
+        fixtureId: 'c1',
+        ok: false,
+        checks: [
+          { pass: true },
+          { pass: false, message: 'failed check' },
+          { pass: true },
+        ],
+      },
+    ]);
+    // pass_count=2, fail_count=1
+    const row = csv.split('\n')[1];
+    assert.ok(row.match(/c1.*,2,1/));
+  });
+
+  it('returns empty string for missing optional fields', () => {
+    const csv = toCSV([{ fixtureId: 'minimal' }]);
+    // Should not throw and should have all 9 columns
+    assert.strictEqual(csv.split('\n')[0].split(',').length, 9);
+  });
+});

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

@@ -0,0 +1,84 @@
+// tests/eval-scheduled.test.mjs — v5.3.0
+// Tests for eval schedule CRUD
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { rmSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+describe('Eval schedule CRUD', () => {
+  const originalConfigDir = process.env.BIZAR_EVAL_CONFIG_DIR;
+
+  beforeEach(() => {
+    // Use a unique config dir per test to avoid cross-test pollution
+    const testId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    process.env.BIZAR_EVAL_CONFIG_DIR = `/tmp/bizar-eval-config-${testId}`;
+    mkdirSync(process.env.BIZAR_EVAL_CONFIG_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    process.env.BIZAR_EVAL_CONFIG_DIR = originalConfigDir;
+  });
+
+  it('registerEvalSchedule returns a schedule with id', async () => {
+    // Dynamic import ensures env var is set before module initializes
+    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}`);
+    const { registerEvalSchedule } = mod;
+    const schedule = registerEvalSchedule({
+      name: 'Daily check',
+      suitePath: './fixtures',
+      cron: '0 8 * * *',
+      agent: 'thor',
+    });
+    assert.ok(schedule.id);
+    assert.strictEqual(schedule.name, 'Daily check');
+    assert.strictEqual(schedule.suitePath, './fixtures');
+    assert.strictEqual(schedule.cron, '0 8 * * *');
+    assert.strictEqual(schedule.agent, 'thor');
+  });
+
+  it('listEvalSchedules returns all registered schedules', async () => {
+    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}-${Math.random()}`);
+    const { registerEvalSchedule, listEvalSchedules } = mod;
+    registerEvalSchedule({ name: 's1', suitePath: './a', cron: '0 9 * * *' });
+    registerEvalSchedule({ name: 's2', suitePath: './b', cron: '0 10 * * *' });
+    const schedules = listEvalSchedules();
+    assert.strictEqual(schedules.length, 2);
+    assert.ok(schedules.find((s) => s.name === 's1'));
+    assert.ok(schedules.find((s) => s.name === 's2'));
+  });
+
+  it('deleteEvalSchedule removes a schedule by id', async () => {
+    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}`);
+    const { registerEvalSchedule, listEvalSchedules, deleteEvalSchedule } = mod;
+    const sched = registerEvalSchedule({ name: 'to-delete', suitePath: './x', cron: '0 9 * * *' });
+    const result = deleteEvalSchedule(sched.id);
+    assert.strictEqual(result.ok, true);
+    const remaining = listEvalSchedules();
+    assert.strictEqual(remaining.find((s) => s.id === sched.id), undefined);
+  });
+
+  it('deleteEvalSchedule returns ok:false for unknown id', async () => {
+    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}`);
+    const { deleteEvalSchedule } = mod;
+    const result = deleteEvalSchedule('does-not-exist');
+    assert.strictEqual(result.ok, false);
+  });
+
+  it('schedule ids are unique across multiple registrations', async () => {
+    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}`);
+    const { registerEvalSchedule, listEvalSchedules } = mod;
+    const ids = new Set();
+    for (let i = 0; i < 10; i++) {
+      ids.add(registerEvalSchedule({ name: `s${i}`, suitePath: '.', cron: '* * * * *' }).id);
+    }
+    assert.strictEqual(ids.size, 10);
+  });
+});
+
+describe('schedules runner eval-run action', () => {
+  it('schedulesRunner module loads and exposes tick', async () => {
+    const { schedulesRunner } = await import('../src/server/schedules-runner.mjs');
+    assert.strictEqual(typeof schedulesRunner.tick, 'function');
+  });
+});