@polderlabs/bizar 4.9.0 → 5.0.1

package/bizar-dash/tests/chat-composer.test.tsx

@@ -0,0 +1,140 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi } from 'vitest';
+import { ChatComposer } from '../src/web/components/chat/ChatComposer';
+
+// Mock the enhancePrompt API
+vi.mock('../src/web/lib/api', () => ({
+  enhancePrompt: vi.fn().mockResolvedValue('enhanced prompt'),
+}));
+
+// Mock lucide-react — use importOriginal to preserve all real icons,
+// then override only the ones we need to stub
+vi.mock('lucide-react', async (importOriginal) => {
+  const actual = await importOriginal() as Record<string, unknown>;
+  return {
+    ...actual,
+    Send: () => <svg data-testid="send-icon" />,
+    Paperclip: () => <svg data-testid="paperclip-icon" />,
+    X: () => <svg data-testid="x-icon" />,
+    Sparkles: () => <svg data-testid="sparkles-icon" />,
+    Bot: () => <svg data-testid="bot-icon" />,
+    ChevronDown: () => <svg data-testid="chevron-down-icon" />,
+  };
+});
+
+function makeProps() {
+  return {
+    agent: 'test-agent',
+    setAgent: vi.fn(),
+    model: 'test-model',
+    setModel: vi.fn(),
+    text: '',
+    setText: vi.fn(),
+    sending: false,
+    onSend: vi.fn(),
+    attachments: [] as string[],
+    setAttachments: vi.fn(),
+    suggestions: [] as Array<{ cmd: string; desc: string }>,
+    onPickSuggestion: vi.fn(),
+    agents: [{ name: 'test-agent' }],
+    onAttach: vi.fn(),
+  };
+}
+
+describe('ChatComposer sizing', () => {
+  it('renders a textarea inside the composer', () => {
+    render(<ChatComposer {...makeProps()} />);
+    const textarea = screen.getByRole('textbox');
+    expect(textarea).toBeInTheDocument();
+  });
+
+  it('composer pill exists with the correct class', () => {
+    const { container } = render(<ChatComposer {...makeProps()} />);
+    const pill = container.querySelector('.chat-composer-pill');
+    expect(pill).not.toBeNull();
+  });
+
+  it('send button exists with correct class', () => {
+    const { container } = render(<ChatComposer {...makeProps()} />);
+    const sendBtn = container.querySelector('.chat-send-btn');
+    expect(sendBtn).not.toBeNull();
+  });
+
+  it('textarea starts with rows=1 for compact single-line appearance', () => {
+    render(<ChatComposer {...makeProps()} />);
+    const textarea = screen.getByRole('textbox');
+    expect(textarea.getAttribute('rows')).toBe('1');
+  });
+});
+
+describe('ChatComposer auto-grow', () => {
+  it('setText is called on each keystroke (controlled component)', async () => {
+    const user = userEvent.setup();
+    const props = makeProps();
+    render(<ChatComposer {...props} />);
+    const textarea = screen.getByRole('textbox');
+    await user.click(textarea);
+    // user.type fires input events which trigger onChange → setText
+    await user.type(textarea, 'hello');
+    // setText is called for each character in a controlled component
+    expect(props.setText.mock.calls.length).toBeGreaterThanOrEqual(5);
+  });
+
+  it('empty state shows send message placeholder', () => {
+    render(<ChatComposer {...makeProps()} />);
+    const textarea = screen.getByRole('textbox');
+    expect(textarea).toHaveAttribute('placeholder', 'Send a message…');
+  });
+
+  it('sending state shows sending placeholder', () => {
+    const props = makeProps();
+    props.sending = true;
+    render(<ChatComposer {...props} />);
+    const textarea = screen.getByRole('textbox');
+    expect(textarea).toHaveAttribute('placeholder', 'Sending…');
+  });
+});
+
+describe('ChatComposer interactions', () => {
+  it('calls onSend when send button is clicked', async () => {
+    const user = userEvent.setup();
+    const props = makeProps();
+    const { rerender } = render(<ChatComposer {...props} />);
+    // Simulate typing: update the text prop as a real state would
+    props.text = 'hello world';
+    rerender(<ChatComposer {...props} />);
+    const sendBtn = document.querySelector('.chat-send-btn') as HTMLButtonElement;
+    await user.click(sendBtn);
+    expect(props.onSend).toHaveBeenCalled();
+  });
+
+  it('does not call onSend when textarea is empty', async () => {
+    const user = userEvent.setup();
+    const props = makeProps();
+    render(<ChatComposer {...props} />);
+    const sendBtn = document.querySelector('.chat-send-btn') as HTMLButtonElement;
+    await user.click(sendBtn);
+    expect(props.onSend).not.toHaveBeenCalled();
+  });
+
+  it('setText is called on input change', async () => {
+    const user = userEvent.setup();
+    const props = makeProps();
+    render(<ChatComposer {...props} />);
+    const textarea = screen.getByRole('textbox');
+    await user.click(textarea);
+    await user.keyboard('typed text');
+    // For controlled components, setText is called per-keystroke.
+    // Verify it was called multiple times (once per character)
+    expect(props.setText.mock.calls.length).toBeGreaterThanOrEqual(10);
+  });
+
+  it('textarea is disabled while sending', () => {
+    const props = makeProps();
+    props.sending = true;
+    render(<ChatComposer {...props} />);
+    const textarea = screen.getByRole('textbox');
+    expect(textarea).toBeDisabled();
+  });
+});

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

@@ -0,0 +1,147 @@
+/**
+ * tests/clipboard.test.mjs
+ *
+ * v5.0.0 — Tests for the clipboard route save-format logic.
+ *
+ * These tests verify the note file format (frontmatter, body) produced
+ * by the clipboard/save endpoint. We test via a lightweight HTTP server
+ * using a temp project root.
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import express from 'express';
+
+const CLIPBOARD_ROUTES = await import('../src/server/routes/clipboard.mjs');
+
+describe('clipboard note format', () => {
+  let projectRoot;
+  let server;
+  let baseUrl;
+
+  beforeEach(async () => {
+    projectRoot = join(tmpdir(), `bizar-clip-test2-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+
+    const router = await CLIPBOARD_ROUTES.createClipboardRouter({ projectRoot });
+    const app = express();
+    app.use(express.json({ limit: '5mb' }));
+    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('saves a note with correct YAML frontmatter', async () => {
+    const r = await fetch(`${baseUrl}/api/clipboard/save`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        url: 'https://example.com/test',
+        title: 'Test Page Title',
+        content: '<html>test content</html>',
+        selection: 'selected text',
+        savedAt: '2026-07-05T12:00:00.000Z',
+      }),
+    });
+    assert.strictEqual(r.status, 201);
+    const data = await r.json();
+    assert.ok(data.ok);
+    assert.ok(data.notePath);
+    assert.ok(data.notePath.startsWith('clips/'));
+    assert.ok(data.notePath.endsWith('.md'));
+
+    // Read the file
+    const noteFile = join(projectRoot, '.obsidian', data.notePath);
+    assert.ok(existsSync(noteFile));
+    const content = readFileSync(noteFile, 'utf8');
+
+    // Check frontmatter
+    assert.ok(content.startsWith('---'));
+    assert.ok(content.includes('title: "Test Page Title"'));
+    assert.ok(content.includes('url: "https://example.com/test"'));
+    assert.ok(content.includes('type: "webclip"'));
+    assert.ok(content.includes('savedAt: "2026-07-05T12:00:00.000Z"'));
+
+    // Check body contains selection and content
+    assert.ok(content.includes('selected text'));
+    assert.ok(content.includes('<html>test content</html>'));
+
+    // Check tags
+    assert.ok(content.includes('"webclip"'));
+  });
+
+  it('returns 400 when url and content are both missing', async () => {
+    const r = await fetch(`${baseUrl}/api/clipboard/save`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({}),
+    });
+    assert.strictEqual(r.status, 400);
+    const data = await r.json();
+    assert.strictEqual(data.error, 'bad_request');
+  });
+
+  it('GET /api/clipboard/list returns clips array', async () => {
+    // Save a clip first
+    await fetch(`${baseUrl}/api/clipboard/save`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        url: 'https://example.com/list-test',
+        title: 'List Test',
+        content: 'list content',
+      }),
+    });
+
+    const r = await fetch(`${baseUrl}/api/clipboard/list`);
+    assert.strictEqual(r.status, 200);
+    const data = await r.json();
+    assert.ok(Array.isArray(data.clips));
+    assert.strictEqual(data.clips.length, 1);
+    assert.ok(data.clips[0].id);
+    assert.strictEqual(data.clips[0].title, 'List Test');
+  });
+
+  it('DELETE /api/clipboard/:id removes clip from log', async () => {
+    // Save
+    const saveRes = await fetch(`${baseUrl}/api/clipboard/save`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        url: 'https://example.com/delete-test',
+        title: 'Delete Test',
+        content: 'delete content',
+      }),
+    });
+    const { id } = await saveRes.json();
+
+    // Delete
+    const delRes = await fetch(`${baseUrl}/api/clipboard/${id}`, { method: 'DELETE' });
+    assert.strictEqual(delRes.status, 200);
+
+    // List should be empty
+    const listRes = await fetch(`${baseUrl}/api/clipboard/list`);
+    const { clips } = await listRes.json();
+    assert.strictEqual(clips.length, 0);
+  });
+
+  it('DELETE /api/clipboard/:id returns 404 for unknown id', async () => {
+    const r = await fetch(`${baseUrl}/api/clipboard/nonexistent`, { method: 'DELETE' });
+    assert.strictEqual(r.status, 404);
+  });
+});

package/bizar-dash/tests/components/doctor-panel.test.tsx

@@ -0,0 +1,105 @@
+// tests/components/doctor-panel.test.tsx — v6.0.0
+//
+// Tests for the reusable DoctorPanel component. Verifies:
+//   - Renders the category title and check rows with status pills
+//   - Empty state when no checks / info / children
+//   - info list renders below checks
+//   - children bypasses the default check-list render
+
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect } from 'vitest';
+import { DoctorPanel } from '../../src/web/components/DoctorPanel';
+import type { DoctorCheck } from '../../src/web/lib/types';
+
+const checks: DoctorCheck[] = [
+  { name: 'node', status: 'ok', message: 'v22.16.0 on linux/x64' },
+  { name: 'memory', status: 'warn', message: 'rss 612.4 MB' },
+  { name: 'opencode', status: 'fail', message: 'serve-info missing' },
+];
+
+describe('DoctorPanel', () => {
+  it('renders the category title from defaults', () => {
+    render(<DoctorPanel category="system" checks={checks} />);
+    expect(screen.getByText('System health')).toBeInTheDocument();
+  });
+
+  it('renders one row per check, with name + message', () => {
+    render(<DoctorPanel category="services" checks={checks} />);
+    expect(screen.getByText('node')).toBeInTheDocument();
+    expect(screen.getByText('memory')).toBeInTheDocument();
+    expect(screen.getByText('opencode')).toBeInTheDocument();
+    expect(screen.getByText('v22.16.0 on linux/x64')).toBeInTheDocument();
+    expect(screen.getByText('rss 612.4 MB')).toBeInTheDocument();
+    expect(screen.getByText('serve-info missing')).toBeInTheDocument();
+  });
+
+  it('renders the status pill text per row', () => {
+    render(<DoctorPanel category="services" checks={checks} />);
+    expect(screen.getAllByText('ok').length).toBeGreaterThanOrEqual(1);
+    expect(screen.getAllByText('warn').length).toBeGreaterThanOrEqual(1);
+    expect(screen.getAllByText('fail').length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('shows the empty state when no checks / info / children are passed', () => {
+    render(<DoctorPanel category="errors" checks={[]} />);
+    expect(screen.getByText('No recent errors')).toBeInTheDocument();
+  });
+
+  it('renders the info list when info rows are supplied', () => {
+    render(
+      <DoctorPanel
+        category="counts"
+        checks={[]}
+        info={[
+          { label: 'Tasks', value: 42 },
+          { label: 'Mods', value: 5 },
+        ]}
+      />,
+    );
+    expect(screen.getByText('Tasks')).toBeInTheDocument();
+    expect(screen.getByText('Mods')).toBeInTheDocument();
+    expect(screen.getByText('42')).toBeInTheDocument();
+    expect(screen.getByText('5')).toBeInTheDocument();
+  });
+
+  it('renders children when provided, bypassing the default check-list', () => {
+    render(
+      <DoctorPanel category="actions" checks={[]}>
+        <div data-testid="custom-child">Run Check</div>
+      </DoctorPanel>,
+    );
+    expect(screen.getByTestId('custom-child')).toBeInTheDocument();
+    expect(screen.getByText('Actions')).toBeInTheDocument();
+  });
+
+  it('honors an explicit title override', () => {
+    render(
+      <DoctorPanel
+        category="system"
+        title="My custom title"
+        checks={[]}
+      />,
+    );
+    expect(screen.getByText('My custom title')).toBeInTheDocument();
+    expect(screen.queryByText('System health')).not.toBeInTheDocument();
+  });
+
+  it('renders the meta string when supplied', () => {
+    render(
+      <DoctorPanel
+        category="system"
+        checks={[]}
+        meta="linux/x64"
+      />,
+    );
+    expect(screen.getByText('linux/x64')).toBeInTheDocument();
+  });
+
+  it('applies the category-specific class to the card', () => {
+    const { container } = render(
+      <DoctorPanel category="services" checks={checks} />,
+    );
+    const card = container.querySelector('.doctor-panel-services');
+    expect(card).toBeInTheDocument();
+  });
+});

package/bizar-dash/tests/components/screenshot-ocr.test.tsx

@@ -0,0 +1,75 @@
+/**
+ * tests/components/screenshot-ocr.test.tsx
+ *
+ * v5.0.0 — Component tests for ScreenshotCapture and ScreenshotOCR.
+ *
+ * These tests verify that the components render correctly and handle
+ * their states (capturing, processing, results).
+ */
+
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { ScreenshotCapture } from '../../src/web/components/ScreenshotCapture';
+import { ScreenshotOCR } from '../../src/web/components/ScreenshotOCR';
+
+// Mock the Toast component
+vi.mock('../../src/web/components/Toast', () => ({
+  useToast: () => ({
+    info: vi.fn(),
+    success: vi.fn(),
+    error: vi.fn(),
+    warning: vi.fn(),
+  }),
+  ToastProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+}));
+
+// Mock the api module
+vi.mock('../../src/web/lib/api', () => ({
+  api: {
+    post: vi.fn().mockResolvedValue({ ok: true, text: 'test text', notePath: 'ocr/test.md' }),
+  },
+}));
+
+// Mock getDisplayMedia
+beforeEach(() => {
+  Object.defineProperty(navigator, 'mediaDevices', {
+    value: {
+      getDisplayMedia: vi.fn().mockRejectedValue(new DOMException('', 'NotAllowedError')),
+    },
+    writable: true,
+    configurable: true,
+  });
+});
+
+describe('ScreenshotCapture', () => {
+  it('renders the capture button', () => {
+    render(<ScreenshotCapture onTextExtracted={vi.fn()} />);
+    expect(screen.getByText('Capture Screen')).toBeDefined();
+  });
+
+  it('renders without crashing when no onTextExtracted provided', () => {
+    render(<ScreenshotCapture />);
+    expect(screen.getByText('Capture Screen')).toBeDefined();
+  });
+
+  it('shows loading state when capturing', async () => {
+    // getDisplayMedia won't resolve, so it will show "Selecting…"
+    render(<ScreenshotCapture onTextExtracted={vi.fn()} />);
+    const btn = screen.getByText('Capture Screen');
+    // Not clicking — just verify initial state renders
+    expect(btn).toBeDefined();
+  });
+});
+
+describe('ScreenshotOCR', () => {
+  it('renders the combined panel', () => {
+    render(<ScreenshotOCR />);
+    expect(screen.getByText('Capture Screen')).toBeDefined();
+    expect(screen.getByText(/capture your screen/i)).toBeDefined();
+  });
+
+  it('renders without crashing', () => {
+    const { container } = render(<ScreenshotOCR />);
+    expect(container).toBeDefined();
+  });
+});

package/bizar-dash/tests/components/workspace-selector.test.tsx

@@ -0,0 +1,73 @@
+import { render, screen, waitFor, act } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import React from 'react';
+import { WorkspaceSelector } from '../../src/web/components/WorkspaceSelector';
+
+// Mock the api module
+vi.mock('../../src/web/lib/api', () => ({
+  api: {
+    get: vi.fn().mockResolvedValue({ workspaces: [] }),
+  },
+}));
+
+describe('WorkspaceSelector', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders with default text when no workspace is selected', () => {
+    render(
+      <WorkspaceSelector
+        currentWorkspaceId={null}
+        onWorkspaceChange={vi.fn()}
+      />,
+    );
+    expect(screen.getByText('Workspace')).toBeInTheDocument();
+  });
+
+  it('opens dropdown on click', async () => {
+    const user = userEvent.setup();
+    render(
+      <WorkspaceSelector
+        currentWorkspaceId={null}
+        onWorkspaceChange={vi.fn()}
+      />,
+    );
+    await user.click(screen.getByRole('button'));
+    expect(screen.getByRole('menu')).toBeInTheDocument();
+  });
+
+  it('shows empty state in dropdown when no workspaces', async () => {
+    const user = userEvent.setup();
+    render(
+      <WorkspaceSelector
+        currentWorkspaceId={null}
+        onWorkspaceChange={vi.fn()}
+      />,
+    );
+    await user.click(screen.getByRole('button'));
+    expect(screen.getByText('No workspaces')).toBeInTheDocument();
+  });
+
+  it('renders workspace name when provided and API returns data', async () => {
+    const { api } = await import('../../src/web/lib/api');
+    (api.get as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      workspaces: [
+        { workspace: { id: 'ws_abc', name: 'Engineering' }, role: 'admin' },
+      ],
+    });
+
+    render(
+      <WorkspaceSelector
+        currentWorkspaceId="ws_abc"
+        onWorkspaceChange={vi.fn()}
+      />,
+    );
+
+    // Wait for the effect to run and state to update
+    await waitFor(() => {
+      expect(screen.getByText('Engineering')).toBeInTheDocument();
+    });
+  });
+});

package/bizar-dash/tests/deploy-templates.test.mjs

@@ -0,0 +1,100 @@
+/**
+ * bizar-dash/tests/deploy-templates.test.mjs
+ *
+ * Verify that deploy templates exist and are valid.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const PROJECT_ROOT = join(__dirname, '..', '..');
+const TEMPLATES_DIR = join(PROJECT_ROOT, 'templates', 'deploy');
+
+// Lazy-import toml/yaml only if needed (they're devDependencies)
+let toml;
+let yaml;
+
+function getToml() {
+  if (!toml) {
+    toml = import('smol-toml').then((m) => m.parse || m.default?.parse || m.default);
+  }
+  // synchronous wrapper
+  return { parse: (s) => { throw new Error('use async version'); } };
+}
+
+async function parseToml(content) {
+  const mod = await import('smol-toml');
+  return (mod.parse || mod.default?.parse || mod.default)(content);
+}
+
+async function parseYaml(content) {
+  const mod = await import('js-yaml');
+  return (mod.load || mod.default?.load || mod.default)(content);
+}
+
+describe('Deploy templates', () => {
+  const platforms = ['vercel', 'cloudflare', 'fly', 'docker'];
+  const requiredFiles = {
+    vercel: ['vercel.json.template', 'api-index.template.js', 'README.md'],
+    cloudflare: ['wrangler.toml.template', 'functions-index.template.js', 'README.md'],
+    fly: ['fly.toml.template', 'README.md'],
+    docker: ['docker-compose.template.yml', '.env.template', 'README.md'],
+  };
+
+  for (const platform of platforms) {
+    it(platform + ' template directory exists', () => {
+      const dir = join(TEMPLATES_DIR, platform);
+      assert.ok(existsSync(dir), 'Directory missing: templates/deploy/' + platform);
+    });
+
+    it(platform + ' has at least 2 files', () => {
+      const dir = join(TEMPLATES_DIR, platform);
+      const entries = readdirSync(dir).filter((f) => {
+        return statSync(join(dir, f)).isFile();
+      });
+      assert.ok(entries.length >= 2, platform + ' has ' + entries.length + ' files (need >=2): ' + entries.join(', '));
+    });
+
+    for (const file of (requiredFiles[platform] || [])) {
+      it(platform + '/' + file + ' exists', () => {
+        const fpath = join(TEMPLATES_DIR, platform, file);
+        assert.ok(existsSync(fpath), 'Missing file: templates/deploy/' + platform + '/' + file);
+      });
+    }
+  }
+
+  it('vercel.json.template is valid JSON', () => {
+    const content = readFileSync(join(TEMPLATES_DIR, 'vercel', 'vercel.json.template'), 'utf8');
+    const parsed = JSON.parse(content);
+    assert.ok(parsed.name);
+    assert.strictEqual(parsed.version, 2);
+    assert.ok(Array.isArray(parsed.routes));
+  });
+
+  it('wrangler.toml.template is valid TOML', { timeout: 10000 }, async () => {
+    const content = readFileSync(join(TEMPLATES_DIR, 'cloudflare', 'wrangler.toml.template'), 'utf8');
+    const parsed = await parseToml(content);
+    assert.ok(parsed);
+    assert.ok(parsed.name);
+    assert.ok(parsed.site);
+  });
+
+  it('fly.toml.template is valid TOML', { timeout: 10000 }, async () => {
+    const content = readFileSync(join(TEMPLATES_DIR, 'fly', 'fly.toml.template'), 'utf8');
+    const parsed = await parseToml(content);
+    assert.ok(parsed);
+    assert.ok(parsed.app);
+    assert.ok(parsed.http_service);
+  });
+
+  it('docker-compose.template.yml is valid YAML', { timeout: 10000 }, async () => {
+    const content = readFileSync(join(TEMPLATES_DIR, 'docker', 'docker-compose.template.yml'), 'utf8');
+    const parsed = await parseYaml(content);
+    assert.ok(parsed);
+    assert.ok(parsed.services);
+    assert.ok(parsed.services['bizar-dash']);
+  });
+});