@polderlabs/bizar 7.0.4 → 8.1.0

package/bizar-dash/src/server/progress-parser.test.mjs

@@ -0,0 +1,105 @@
+/**
+ * src/server/progress-parser.test.mjs
+ *
+ * Sprint S10 — Unit tests for progress-parser.mjs.
+ * Uses node:test (matches the existing `cli/__tests__/*.test.mjs` pattern
+ * shipped across the harness — no vitest/jsdom dependency).
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { parseProgress, serializeProgress } from './progress-parser.mjs';
+
+test('empty input → empty goals + empty preamble', () => {
+  const r = parseProgress('');
+  assert.equal(r.goals.length, 0);
+  assert.equal(r.preamble, '');
+  assert.equal(r.postamble, '');
+});
+
+test('parses single F-NNN header with status + progress + owner', () => {
+  const text = `# Title\n\nIntro line.\n\n## F-052 — Ship dashboard\nOwner: sam\nDue: Q3 2026\n\nGoal is **at-risk**. About 42% done.\n\nKey results:\n- [x] First KR\n- [ ] Second KR (@alex)\n`;
+  const r = parseProgress(text);
+  assert.equal(r.goals.length, 1);
+  const g = r.goals[0];
+  assert.equal(g.id, 'F-052');
+  assert.equal(g.title, 'Ship dashboard');
+  assert.equal(g.status, 'at-risk');
+  assert.equal(g.owner, 'sam');
+  assert.equal(g.due, 'Q3 2026');
+  assert.equal(g.keyResults.length, 2);
+  assert.equal(g.keyResults[0].done, true);
+  assert.equal(g.keyResults[1].done, false);
+  assert.equal(g.keyResults[1].assignee, 'alex');
+  assert.equal(g.progress, 0.5);
+});
+
+test('parses bare title (no F-NNN id)', () => {
+  const r = parseProgress('## Cut S9 polish in half\nGoal is **on-track**.\n');
+  assert.equal(r.goals.length, 1);
+  assert.equal(r.goals[0].id, 'cut-s9-polish-in-half');
+  assert.equal(r.goals[0].title, 'Cut S9 polish in half');
+});
+
+test('multi-goal preserves preamble and orders', () => {
+  const text = `# Header\nPreamble line.\n\n## F-001 — One\nGoal is **done**.\n\n## F-002 — Two\nGoal is **active**. 25%.\n\n## F-003 — Three\nGoal is **blocked**.\n`;
+  const r = parseProgress(text);
+  assert.equal(r.goals.length, 3);
+  assert.equal(r.goals[0].id, 'F-001');
+  assert.equal(r.goals[0].status, 'done');
+  assert.equal(r.goals[1].status, 'active');
+  assert.equal(r.goals[2].status, 'blocked');
+  assert.ok(r.preamble.includes('Preamble line.'));
+});
+
+test('progress derives from KRs when no % present', () => {
+  const text = '## F-A — Title\n- [x] a\n- [x] b\n- [ ] c\n- [ ] d\n';
+  const r = parseProgress(text);
+  assert.equal(r.goals[0].progress, 0.5);
+});
+
+test('unknown status defaults to on-track', () => {
+  const r = parseProgress('## F-X — Title\nNo status marker here.\n');
+  assert.equal(r.goals[0].status, 'on-track');
+});
+
+test('serialise round-trips goal + KR structure', () => {
+  const parsed = {
+    preamble: '# Header\n',
+    postamble: '',
+    goals: [
+      {
+        id: 'F-052',
+        title: 'Ship dashboard',
+        status: 'at-risk',
+        description: 'Description body.',
+        progress: 0.5,
+        keyResults: [
+          { id: 'kr-1', title: 'First KR', done: true },
+          { id: 'kr-2', title: 'Second KR', done: false, assignee: 'alex' },
+        ],
+        owner: 'sam',
+        due: 'Q3 2026',
+        section: 'in-progress',
+      },
+    ],
+  };
+  const out = serializeProgress(parsed);
+  assert.ok(out.includes('## F-052 — Ship dashboard'));
+  assert.ok(out.includes('Owner: sam'));
+  assert.ok(out.includes('Goal is **at-risk**.'));
+  assert.ok(out.includes('- [x] First KR'));
+  assert.ok(out.includes('- [ ] Second KR (@alex)'));
+});
+
+test('serialise preserves preamble verbatim', () => {
+  const parsed = {
+    preamble: '# Title\n\nIntro stays here.\n\n',
+    postamble: '\n## Footnotes\nThis stays too.\n',
+    goals: [],
+  };
+  const out = serializeProgress(parsed);
+  assert.ok(out.startsWith('# Title'));
+  assert.ok(out.includes('Intro stays here.'));
+  assert.ok(out.includes('## Footnotes'));
+});

package/bizar-dash/src/server/routes/agents-cc.mjs

@@ -0,0 +1,381 @@
+/**
+ * src/server/routes/agents-cc.mjs
+ *
+ * Sprint S10/S11 — Claude Code-native background agents.
+ *
+ * Reads the live agent roster via `claude agents --json`. Caches the
+ * result for 5s so the dashboard can poll every render without forking
+ * a subprocess per view. Provides unified `GET /api/cc-agents` that
+ * merges with session metadata so the dashboard shows a full picture
+ * (agent name, cwd, session id, status, started-at, etc).
+ *
+ * S11 — adds `POST /api/cc-agents/:id/kill` and
+ * `POST /api/cc-agents/:id/send` for the AgentDetail control plane.
+ */
+
+import { Router } from 'express';
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, statSync, watch } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { wrap } from './_shared.mjs';
+
+const HOME = homedir();
+const CACHE_TTL_MS = 5_000;
+let _cache = null; // { ts, agents, error }
+
+function runClaudeAgents() {
+  return new Promise((resolve) => {
+    let stdout = '';
+    let stderr = '';
+    let done = false;
+    try {
+      const proc = spawn('claude', ['agents', '--json', '--all'], {
+        env: process.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      const timer = setTimeout(() => {
+        if (!done) { done = true; try { proc.kill('SIGTERM'); } catch { /* */ } resolve({ ok: false, error: 'timeout', stderr: stderr.slice(0, 500) }); }
+      }, 4_000);
+      proc.stdout.on('data', (chunk) => { stdout += chunk.toString('utf8'); });
+      proc.stderr.on('data', (chunk) => { stderr += chunk.toString('utf8'); });
+      proc.on('error', (err) => {
+        if (done) return;
+        done = true;
+        clearTimeout(timer);
+        resolve({ ok: false, error: err.message, stderr });
+      });
+      proc.on('exit', (code) => {
+        if (done) return;
+        done = true;
+        clearTimeout(timer);
+        if (code !== 0) {
+          resolve({ ok: false, error: `exit ${code}`, stderr: stderr.slice(0, 500), stdout: stdout.slice(0, 500) });
+          return;
+        }
+        try {
+          const parsed = JSON.parse(stdout || '[]');
+          if (!Array.isArray(parsed)) {
+            resolve({ ok: false, error: 'unexpected shape', stdout: stdout.slice(0, 200) });
+            return;
+          }
+          resolve({ ok: true, agents: parsed });
+        } catch (err) {
+          resolve({ ok: false, error: `parse: ${err.message}`, stdout: stdout.slice(0, 200) });
+        }
+      });
+    } catch (err) {
+      resolve({ ok: false, error: err.message });
+    }
+  });
+}
+
+function enrichSession(agent) {
+  if (!agent || !agent.sessionId) return agent;
+  const file = join(HOME, '.claude', 'sessions', agent.sessionId, 'messages.jsonl');
+  if (!existsSync(file)) return agent;
+  try {
+    const st = statSync(file);
+    agent.lastMessageAt = st.mtimeMs;
+    const text = readFileSync(file, 'utf8');
+    agent.messageCount = text.split('\n').filter((l) => l.trim()).length;
+    // Read last assistant text snippet (best-effort).
+    const lines = text.split('\n').filter((l) => l.trim());
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      try {
+        const obj = JSON.parse(lines[i]);
+        if (obj?.type === 'assistant' && obj?.message?.content) {
+          const c = obj.message.content;
+          const txt = typeof c === 'string' ? c
+            : Array.isArray(c) ? c.filter((b) => b && (b.type === 'text' || typeof b.text === 'string')).map((b) => b.text || '').join('\n')
+            : '';
+          if (txt) { agent.lastMessageSnippet = txt.replace(/\s+/g, ' ').trim().slice(0, 120); }
+          break;
+        }
+      } catch { /* skip */ }
+    }
+  } catch { /* best effort */ }
+  return agent;
+}
+
+async function listAgents({ force = false } = {}) {
+  const now = Date.now();
+  if (!force && _cache && (now - _cache.ts) < CACHE_TTL_MS) {
+    return _cache;
+  }
+  const r = await runClaudeAgents();
+  if (r.ok) {
+    const agents = r.agents.map(enrichSession);
+    _cache = { ts: now, agents, error: null };
+  } else {
+    _cache = { ts: now, agents: [], error: r.error || 'unknown' };
+  }
+  return _cache;
+}
+
+/**
+ * @param {{ broadcast?: Function }} deps
+ */
+export function createCCAgentsRouter({ broadcast = () => {} } = {}) {
+  const router = Router();
+
+  router.get('/cc-agents', wrap(async (_req, res) => {
+    const r = await listAgents();
+    res.json({ agents: r.agents, count: r.agents.length, error: r.error });
+  }));
+
+  router.get('/cc-agents/:id', wrap(async (req, res) => {
+    const r = await listAgents();
+    const agent = r.agents.find((a) => a.id === req.params.id || a.sessionId === req.params.id);
+    if (!agent) { res.status(404).json({ error: 'not_found' }); return; }
+    res.json(agent);
+  }));
+
+  // S11 — kill a CC background agent.
+  router.post('/cc-agents/:id/kill', wrap(async (req, res) => {
+    const id = req.params.id;
+    if (!id || !/^[A-Za-z0-9_-]{1,64}$/.test(id)) {
+      res.status(400).json({ error: 'bad_request', message: 'invalid id' });
+      return;
+    }
+    try {
+      const proc = spawn('claude', ['agents', 'kill', id], {
+        env: process.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      let stderr = '';
+      proc.stderr.on('data', (c) => { stderr += c.toString('utf8'); });
+      const exitCode = await new Promise((resolve) => proc.on('exit', resolve));
+      _cache = null; // bust cache so the next list reflects the kill
+      broadcast({ type: 'agents:change' });
+      if (exitCode === 0) {
+        res.json({ ok: true, id });
+      } else {
+        res.status(502).json({ ok: false, error: `exit ${exitCode}`, stderr: stderr.slice(0, 500) });
+      }
+    } catch (err) {
+      res.status(500).json({ ok: false, error: err.message });
+    }
+  }));
+
+  // S11 — send a follow-up prompt to a CC background agent.
+  router.post('/cc-agents/:id/send', wrap(async (req, res) => {
+    const id = req.params.id;
+    const prompt = String((req.body && req.body.prompt) || '').trim();
+    if (!prompt) {
+      res.status(400).json({ error: 'bad_request', message: 'prompt is required' });
+      return;
+    }
+    if (!id || !/^[A-Za-z0-9_-]{1,64}$/.test(id)) {
+      res.status(400).json({ error: 'bad_request', message: 'invalid id' });
+      return;
+    }
+    const { spawnAgent } = await import('../claude-runner.mjs');
+    const result = await spawnAgent({
+      prompt,
+      agent: undefined,
+      worktree: HOME,
+      logPath: join(HOME, '.claude', 'sessions', '_new', `${Date.now()}.log`),
+      background: true,
+      sessionIdTimeoutMs: 5_000,
+    });
+    if (!result.ok) {
+      res.status(502).json({ ok: false, error: result.error || 'spawn failed' });
+      return;
+    }
+    _cache = null;
+    broadcast({ type: 'agents:change' });
+    res.json({ ok: true, sessionId: result.sessionId, processId: result.processId });
+  }));
+
+  return router;
+}
+
+/**
+ * resolveSessionLog — locate the JSONL file backing a Claude Code session.
+ *
+ * Claude Code writes per-session logs to:
+ *   ~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl
+ *
+ * The agent roster (from `claude agents --json`) gives us the session id
+ * and the working directory; we encode the cwd the same way Claude Code
+ * does (`-` prefix + every `/` replaced with `-`) and probe the path.
+ */
+export function resolveSessionLog(sessionId, cwd) {
+  if (!sessionId) return null;
+  const enc = String(cwd || '').replace(/[/]/g, '-').replace(/^-/, '-');
+  const candidate = join(HOME, '.claude', 'projects', enc, `${sessionId}.jsonl`);
+  return existsSync(candidate) ? candidate : null;
+}
+
+/**
+ * parseJsonlTail — read the last N lines of a session JSONL and shape each
+ * line into the dashboard's agent-stream event:
+ *
+ *   { ts, kind, content, role?, toolName?, toolInput? }
+ *
+ * Recognised line types: assistant message, user message, tool_use,
+ * tool_result, system.
+ */
+export function parseJsonlTail(text, limit = 100) {
+  const lines = text.split('\n').filter((l) => l.trim().length > 0);
+  const slice = lines.slice(-limit);
+  const out = [];
+  for (const line of slice) {
+    let rec;
+    try { rec = JSON.parse(line); } catch { continue; }
+    const ts = typeof rec.ts === 'string'
+      ? Date.parse(rec.ts)
+      : (typeof rec.timestamp === 'string' ? Date.parse(rec.timestamp) : Date.now());
+    const msg = rec.message || rec;
+    const role = msg.role || rec.role || (rec.type === 'user' ? 'user' : rec.type === 'assistant' ? 'assistant' : 'system');
+    if (msg.content && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === 'text') {
+          out.push({ ts, kind: 'text', role, content: String(block.text || '').slice(0, 4000) });
+        } else if (block.type === 'tool_use') {
+          out.push({
+            ts,
+            kind: 'tool',
+            role,
+            toolName: String(block.name || 'tool'),
+            toolInput: typeof block.input === 'string' ? block.input : JSON.stringify(block.input || {}).slice(0, 4000),
+          });
+        } else if (block.type === 'tool_result') {
+          out.push({
+            ts,
+            kind: 'tool-result',
+            role,
+            content: typeof block.content === 'string' ? block.content : JSON.stringify(block.content || '').slice(0, 4000),
+            isError: block.is_error === true,
+          });
+        }
+      }
+    } else if (typeof msg.content === 'string') {
+      out.push({ ts, kind: 'text', role, content: msg.content.slice(0, 4000) });
+    } else if (rec.type === 'system' || rec.type === 'summary') {
+      out.push({ ts, kind: 'system', role: 'system', content: typeof rec.summary === 'string' ? rec.summary : JSON.stringify(rec).slice(0, 2000) });
+    }
+  }
+  return out;
+}
+
+/**
+ * createAgentStreamRouter — separate Router mounted at `/api/agent-stream`.
+ * Exposes:
+ *   GET /api/agent-stream/recent?sessionId=<id>&limit=<n>
+ *     Buffered last-N events for a session (cheap, no file watch).
+ *   GET /api/agent-stream/live?sessionId=<id>
+ *     Server-Sent Events stream. Sends the buffer first, then tails the
+ *     JSONL via fs.watch and pushes new lines as `event: append` frames.
+ *     25s heartbeat keeps proxies from idling out the connection.
+ */
+export function createAgentStreamRouter() {
+  const router = Router();
+
+  router.get('/agent-stream/recent', wrap(async (req, res) => {
+    const sessionId = String(req.query?.sessionId || '');
+    const limit = Math.min(Math.max(parseInt(String(req.query?.limit || '50'), 10) || 50, 1), 500);
+    const r = await listAgents();
+    const agent = r.agents.find((a) => a.sessionId === sessionId || a.id === sessionId);
+    if (!agent) { res.status(404).json({ error: 'not_found' }); return; }
+    const logPath = resolveSessionLog(agent.sessionId, agent.cwd);
+    if (!logPath) { res.json({ events: [], agent, logPath: null }); return; }
+    const stat = statSync(logPath);
+    if (!stat.isFile()) { res.json({ events: [], agent }); return; }
+    const start = Math.max(0, stat.size - 256 * 1024); // last 256KB keeps it cheap
+    const fd = await import('node:fs').then((m) => m.openSync(logPath, 'r'));
+    const buf = Buffer.alloc(stat.size - start);
+    try {
+      readFileSync(fd, buf, 0, buf.length, start);
+    } finally {
+      (await import('node:fs')).closeSync(fd);
+    }
+    res.json({
+      agent,
+      logPath,
+      events: parseJsonlTail(buf.toString('utf8'), limit),
+    });
+  }));
+
+  router.get('/agent-stream/live', (req, res) => {
+    const sessionId = String(req.query?.sessionId || '');
+    if (!/^[A-Za-z0-9_-]{4,64}$/.test(sessionId)) {
+      res.status(400).json({ error: 'bad_request', message: 'sessionId required' });
+      return;
+    }
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.flushHeaders?.();
+
+    let closed = false;
+    const send = (event, data) => {
+      if (closed) return;
+      try { res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`); } catch { closed = true; }
+    };
+
+    // Initial snapshot — last 50 events so the UI renders immediately.
+    (async () => {
+      const r = await listAgents();
+      const agent = r.agents.find((a) => a.sessionId === sessionId || a.id === sessionId);
+      if (!agent) { send('error', { error: 'not_found' }); res.end(); return; }
+      const logPath = resolveSessionLog(agent.sessionId, agent.cwd);
+      send('agent', agent);
+      if (!logPath) { send('end', { reason: 'no_log' }); return; }
+      const stat = statSync(logPath);
+      let offset = stat.size;
+      // Seed with the last 50 events so the user sees context.
+      const start = Math.max(0, stat.size - 128 * 1024);
+      const buf = Buffer.alloc(stat.size - start);
+      const fd = await import('node:fs').then((m) => m.openSync(logPath, 'r'));
+      try { readFileSync(fd, buf, 0, buf.length, start); } finally { (await import('node:fs')).closeSync(fd); }
+      send('snapshot', { events: parseJsonlTail(buf.toString('utf8'), 50) });
+
+      // Tail the file via fs.watch + interval poll (fs.watch is flaky on Linux
+      // for files appended to by other processes; poll every 750ms as a safety net).
+      const interval = setInterval(async () => {
+        if (closed) return;
+        try {
+          const s = statSync(logPath);
+          if (s.size > offset) {
+            const fd2 = await import('node:fs').then((m) => m.openSync(logPath, 'r'));
+            const buf2 = Buffer.alloc(s.size - offset);
+            try { readFileSync(fd2, buf2, 0, buf2.length, offset); } finally { (await import('node:fs')).closeSync(fd2); }
+            offset = s.size;
+            send('append', { events: parseJsonlTail(buf2.toString('utf8'), 200) });
+          }
+        } catch {
+          // file may have been rotated — close gracefully.
+          send('end', { reason: 'file_gone' });
+          closed = true;
+          res.end();
+        }
+      }, 750);
+
+      // Heartbeat keeps the connection alive through corporate proxies.
+      const hb = setInterval(() => {
+        if (closed) return;
+        try { res.write(': ping\n\n'); } catch { closed = true; }
+      }, 25_000);
+
+      const cleanup = () => {
+        if (closed) return;
+        closed = true;
+        clearInterval(interval);
+        clearInterval(hb);
+        try { res.end(); } catch { /* */ }
+      };
+      req.on('close', cleanup);
+      req.on('aborted', cleanup);
+    })().catch((err) => {
+      send('error', { error: err?.message || String(err) });
+      try { res.end(); } catch { /* */ }
+    });
+  });
+
+  return router;
+}
+
+export const _internals = { listAgents, runClaudeAgents, enrichSession, CACHE_TTL_MS };

package/bizar-dash/src/server/routes/agents-cc.test.mjs

@@ -0,0 +1,35 @@
+/**
+ * src/server/routes/agents-cc.test.mjs
+ *
+ * Sprint S10 — Unit tests for the cc-agents helper internals.
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { _internals } from './agents-cc.mjs';
+const { enrichSession, listAgents } = _internals;
+
+test('enrichSession returns agent unchanged when no sessionId', () => {
+  const a = { id: 'x' };
+  assert.deepEqual(enrichSession(a), a);
+});
+
+test('enrichSession is a no-op when session directory is missing', () => {
+  const a = { id: 'nonexistent-12345', sessionId: 'nonexistent-12345' };
+  const out = enrichSession(a);
+  assert.equal(out, a);
+  assert.equal(out.lastMessageAt, undefined);
+});
+
+test('listAgents returns a result object with ts/agents/error fields', async () => {
+  const r = await listAgents({ force: true });
+  assert.equal(typeof r.ts, 'number');
+  assert.ok(Array.isArray(r.agents));
+  assert.ok(r.error === null || typeof r.error === 'string');
+});
+
+test('listAgents cache hits within TTL without re-running', async () => {
+  const first = await listAgents({ force: true });
+  const second = await listAgents();
+  assert.equal(second.ts, first.ts, 'second call should hit the cache (same ts)');
+});