@polderlabs/bizar 8.0.0 → 9.0.0

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/routes/clipboard.mjs

@@ -0,0 +1,173 @@
+/**
+ * src/server/routes/clipboard.mjs
+ *
+ * v5.0.0 — Web Clipper endpoints.
+ *
+ * Accepts content pasted from the browser extension or bookmarklet,
+ * saves it as a markdown note in the vault with YAML frontmatter.
+ */
+
+import { Router } from 'express';
+import { join } from 'node:path';
+import { mkdirSync, writeFileSync, readFileSync, readdirSync, existsSync, rmSync } from 'node:fs';
+
+let _wrap = null;
+async function getShared() {
+  if (!_wrap) {
+    const mod = await import('./_shared.mjs');
+    _wrap = mod.wrap;
+  }
+  return { wrap: _wrap };
+}
+
+/**
+ * In-memory logs for recent clips. Persisted to a JSON file for reboot survival.
+ */
+function getLogPath(projectRoot) {
+  return join(projectRoot, '.bizar', 'clipboard-log.json');
+}
+
+function loadLog(projectRoot) {
+  try {
+    const p = getLogPath(projectRoot);
+    if (!existsSync(p)) return [];
+    return JSON.parse(readFileSync(p, 'utf8'));
+  } catch {
+    return [];
+  }
+}
+
+function saveLog(projectRoot, log) {
+  const p = getLogPath(projectRoot);
+  mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+  writeFileSync(p, JSON.stringify(log, null, 2) + '\n', 'utf8');
+}
+
+function appendLog(projectRoot, entry) {
+  const log = loadLog(projectRoot);
+  log.unshift(entry);
+  if (log.length > 100) log.length = 100; // keep last 100
+  saveLog(projectRoot, log);
+}
+
+function deleteLogEntry(projectRoot, id) {
+  const log = loadLog(projectRoot);
+  const idx = log.findIndex((e) => e.id === id);
+  if (idx === -1) return false;
+  log.splice(idx, 1);
+  saveLog(projectRoot, log);
+  return true;
+}
+
+export async function createClipboardRouter({ projectRoot }) {
+  const router = Router();
+  const { wrap } = await getShared();
+
+  /**
+   * POST /api/clipboard/save
+   *
+   * Accepts { url, title, content, selection?, savedAt? }
+   * Saves a markdown note to the vault at clips/<slug>.md
+   */
+  router.post('/clipboard/save', wrap(async (req, res) => {
+    const { url, title, content, selection, savedAt } = req.body || {};
+    if (!url && !content) {
+      res.status(400).json({ error: 'bad_request', message: 'url or content is required' });
+      return;
+    }
+
+    // Build a safe slug from the title or URL
+    const slugBase = (title || url || 'clip')
+      .replace(/^https?:\/\//, '')
+      .replace(/[^a-zA-Z0-9_\- ]/g, '')
+      .trim()
+      .substring(0, 60)
+      .replace(/\s+/g, '_')
+      .toLowerCase() || 'clip';
+
+    const timestamp = Date.now();
+    const slug = `${slugBase}_${timestamp}`;
+    const relPath = `clips/${slug}.md`;
+
+    // Build frontmatter
+    const noteTitle = title || 'Web Clip';
+    const fm = {
+      title: noteTitle,
+      url: url || '',
+      savedAt: savedAt || new Date().toISOString(),
+      type: 'webclip',
+      tags: ['webclip'],
+    };
+
+    // Build body
+    const body = [
+      selection ? `> ${selection.replace(/\n/g, '\n> ')}` : '',
+      '',
+      '## Source',
+      '',
+      `- **URL**: ${url || '(no URL)'}`,
+      `- **Date**: ${fm.savedAt}`,
+      '',
+      '## Content',
+      '',
+      '```html',
+      (content || '').substring(0, 50000),
+      '```',
+      '',
+    ].join('\n');
+
+    // Write to vault
+    const vaultDir = join(projectRoot, '.obsidian');
+    mkdirSync(join(vaultDir, 'clips'), { recursive: true });
+    const notePath = join(vaultDir, relPath);
+
+    const noteContent = [
+      '---',
+      ...Object.entries(fm).map(([k, v]) => `${k}: ${JSON.stringify(v)}`),
+      '---',
+      '',
+      body,
+    ].join('\n');
+
+    writeFileSync(notePath, noteContent, 'utf8');
+
+    // Log for recent-clips listing
+    const entry = {
+      id: slug,
+      title: noteTitle,
+      url,
+      notePath: relPath,
+      savedAt: fm.savedAt,
+    };
+    appendLog(projectRoot, entry);
+
+    res.status(201).json({ ok: true, notePath: relPath, id: slug });
+  }));
+
+  /**
+   * GET /api/clipboard/list
+   *
+   * Returns recent clips from the log.
+   */
+  router.get('/clipboard/list', wrap(async (_req, res) => {
+    const clips = loadLog(projectRoot);
+    res.json({ clips });
+  }));
+
+  /**
+   * DELETE /api/clipboard/:id
+   *
+   * Remove a clip from the log (does not delete the note file).
+   */
+  router.delete('/clipboard/:id', wrap(async (req, res) => {
+    const { id } = req.params;
+    const ok = deleteLogEntry(projectRoot, id);
+    if (!ok) {
+      res.status(404).json({ error: 'not_found', message: `clip ${id} not found` });
+      return;
+    }
+    res.json({ ok: true });
+  }));
+
+  return router;
+}

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/routes/config.mjs

@@ -0,0 +1,180 @@
+/**
+ * src/server/routes/config.mjs
+ *
+ * /api/config                           — read ~/.config/cline/cline.json
+ * /api/config (PUT)                     — write cline.json
+ * /api/config/reload (POST)             — re-read
+ * /api/config/providers                 — list providers
+ * /api/config/providers (POST)          — add
+ * /api/config/providers/:id (PUT)       — update
+ * /api/config/providers/:id (DELETE)    — remove
+ * /api/config/providers/auto (POST)     — add with key, auto-discover models
+ *                                          + apply systemLlm config
+ * /api/config/mcps                      — list MCP servers
+ * /api/config/mcps (POST)               — add
+ * /api/config/mcps/:id (PUT)            — update
+ * /api/config/mcps/:id (DELETE)         — remove
+ *
+ * Two stores are involved: the on-disk cline.json (read+write)
+ * and the providersStore/mcpsStore in-memory registries. /api/config
+ * is the former; /api/config/providers and /api/config/mcps are
+ * the latter. /api/providers (without the config/ prefix) is the
+ * dashboard's aggregated provider list and lives in providers.mjs.
+ */
+import { Router } from 'express';
+import { existsSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import {
+  providersStore,
+  mcpsStore,
+  loadConfig,
+  saveConfig,
+} from '../providers-store.mjs';
+import { CLINE_JSON, atomicWriteJson, safeReadJSON, wrap } from './_shared.mjs';
+
+/**
+ * @param {object} deps
+ * @param {object} deps.state
+ * @param {object} deps.watcher
+ * @returns {import('express').Router}
+ */
+export function createConfigRouter({ state, watcher }) {
+  const router = Router();
+
+  router.get('/config', wrap(async (_req, res) => {
+    const data = safeReadJSON(CLINE_JSON, null);
+    res.json({
+      path: CLINE_JSON,
+      data,
+      raw: data === null ? '' : JSON.stringify(data, null, 2),
+      exists: existsSync(CLINE_JSON),
+    });
+  }));
+
+  router.put('/config', wrap(async (req, res) => {
+    const body = req.body;
+    let parsed;
+    if (typeof body === 'string') {
+      try {
+        parsed = JSON.parse(body);
+      } catch (err) {
+        res.status(400).json({ error: 'invalid_json', message: err.message });
+        return;
+      }
+    } else if (body && typeof body === 'object') {
+      parsed = body;
+    } else {
+      res.status(400).json({ error: 'bad_request', message: 'body must be JSON' });
+      return;
+    }
+    mkdirSync(dirname(CLINE_JSON), { recursive: true });
+    atomicWriteJson(CLINE_JSON, parsed);
+    state.appendActivity({ kind: 'config.update' });
+    watcher.poke('change', CLINE_JSON);
+    res.json({ path: CLINE_JSON, data: parsed, exists: true, raw: JSON.stringify(parsed, null, 2) });
+  }));
+
+  router.post('/config/reload', wrap(async (_req, res) => {
+    const data = safeReadJSON(CLINE_JSON, null);
+    res.json({
+      path: CLINE_JSON,
+      data,
+      raw: data === null ? '' : JSON.stringify(data, null, 2),
+      exists: existsSync(CLINE_JSON),
+    });
+  }));
+
+  // ── /api/config/providers ─────────────────────────────────────────────
+  router.get('/config/providers', wrap(async (_req, res) => {
+    res.json({ providers: providersStore.list() });
+  }));
+
+  router.post('/config/providers', wrap(async (req, res) => {
+    const provider = providersStore.add(req.body || {});
+    res.status(201).json(provider);
+  }));
+
+  router.put('/config/providers/:id', wrap(async (req, res) => {
+    const provider = providersStore.update(req.params.id, req.body || {});
+    res.json(provider);
+  }));
+
+  router.delete('/config/providers/:id', wrap(async (req, res) => {
+    const ok = providersStore.remove(req.params.id);
+    if (!ok) {
+      res.status(404).json({ error: 'not_found' });
+      return;
+    }
+    res.status(204).end();
+  }));
+
+  // v4.4.14 — "Add with key" — the user pastes a key, we figure out the
+  // rest. Auto-discovers the live model list (probes /v1/models), writes
+  // the full provider block, and (if requested) applies the system LLM
+  // config so the rest of the dashboard's /api/llm/* calls hit this
+  // provider+model.
+  router.post('/config/providers/auto', wrap(async (req, res) => {
+    const body = req.body || {};
+    const result = await providersStore.addWithAuto({
+      id: typeof body.id === 'string' ? body.id.trim() : undefined,
+      name: typeof body.name === 'string' ? body.name.trim() : undefined,
+      apiKey: typeof body.apiKey === 'string' ? body.apiKey : '',
+      groupId: typeof body.groupId === 'string' ? body.groupId : 'default',
+      setAsSystemLlm: body.setAsSystemLlm !== false,
+      preferredModel: typeof body.preferredModel === 'string' ? body.preferredModel : undefined,
+      systemLlmModel: typeof body.systemLlmModel === 'string' ? body.systemLlmModel : undefined,
+    });
+    if (!result.ok) {
+      res.status(result.error === 'unknown_provider' ? 400 : 400).json(result);
+      return;
+    }
+    res.status(201).json(result);
+  }));
+
+  // ── /api/config/mcps ───────────────────────────────────────────────────
+  router.get('/config/mcps', wrap(async (_req, res) => {
+    res.json({ mcps: mcpsStore.list() });
+  }));
+
+  // v4.4.14 — System LLM settings. The dashboard reads / writes the
+  // cline.json#systemLlm block via this thin surface. The block
+  // controls which provider+model is used for the dashboard's own
+  // /api/llm/* calls (auto-title, enhance-prompt, summarization).
+  router.get('/llm/system-llm', wrap(async (_req, res) => {
+    const cfg = loadConfig();
+    res.json(cfg.systemLlm || { enabled: false, provider: null, model: null });
+  }));
+
+  router.put('/llm/system-llm', wrap(async (req, res) => {
+    const cfg = loadConfig();
+    const body = req.body || {};
+    cfg.systemLlm = {
+      enabled: body.enabled !== false,
+      provider: typeof body.provider === 'string' ? body.provider : (cfg.systemLlm?.provider || null),
+      model: typeof body.model === 'string' ? body.model : (cfg.systemLlm?.model || null),
+    };
+    saveConfig(cfg);
+    res.json(cfg.systemLlm);
+  }));
+
+  router.post('/config/mcps', wrap(async (req, res) => {
+    const mcp = mcpsStore.add(req.body || {});
+    res.status(201).json(mcp);
+  }));
+
+  router.put('/config/mcps/:id', wrap(async (req, res) => {
+    const mcp = mcpsStore.update(req.params.id, req.body || {});
+    res.json(mcp);
+  }));
+
+  router.delete('/config/mcps/:id', wrap(async (req, res) => {
+    const ok = mcpsStore.remove(req.params.id);
+    if (!ok) {
+      res.status(404).json({ error: 'not_found' });
+      return;
+    }
+    res.status(204).end();
+  }));
+
+  return router;
+}

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/routes/diagnostics.mjs

@@ -0,0 +1,50 @@
+/**
+ * src/server/routes/diagnostics.mjs
+ *
+ * /api/diagnostics                       — full snapshot
+ * /api/diagnostics/health                — health check
+ * /api/diagnostics/logs                  — tail of the active log file
+ */
+import { Router } from 'express';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { diagnosticsStore } from '../diagnostics-store.mjs';
+import { BIZAR_HOME, wrap } from './_shared.mjs';
+
+/**
+ * @returns {import('express').Router}
+ */
+export function createDiagnosticsRouter() {
+  const router = Router();
+
+  router.get('/diagnostics', wrap(async (_req, res) => {
+    res.json(diagnosticsStore.snapshot());
+  }));
+
+  router.get('/diagnostics/health', wrap(async (_req, res) => {
+    res.json(diagnosticsStore.health());
+  }));
+
+  router.get('/diagnostics/logs', wrap(async (req, res) => {
+    const requestedTail = parseInt(String(req.query.tail || '100'), 10);
+    const tail = Math.min(5000, Math.max(1, Number.isFinite(requestedTail) ? requestedTail : 100));
+    const serviceLog = join(BIZAR_HOME, 'service.log');
+    const dashboardLog = join(BIZAR_HOME, 'dashboard.log');
+    // Prefer service.log, fall back to dashboard.log
+    const logFile = existsSync(serviceLog) ? serviceLog : existsSync(dashboardLog) ? dashboardLog : null;
+    if (!logFile) {
+      res.json({ lines: [], file: null, total: 0 });
+      return;
+    }
+    try {
+      const text = readFileSync(logFile, 'utf8');
+      const allLines = text.split(/\r?\n/).filter(Boolean);
+      const lines = allLines.slice(-tail);
+      res.json({ lines, file: logFile, total: allLines.length });
+    } catch (err) {
+      res.status(500).json({ error: 'read_failed', message: err.message });
+    }
+  }));
+
+  return router;
+}

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/routes/dialogs.mjs

@@ -0,0 +1,86 @@
+/**
+ * src/server/routes/dialogs.mjs
+ *
+ * v3.9.0 — Dialog-request HTTP routes.
+ *
+ *   GET    /api/dialogs            — list recent dialog history (debug)
+ *   GET    /api/dialogs/queue      — list currently-queued (undelivered) dialogs
+ *   POST   /api/dialogs            — enqueue a dialog (used by the slash-command plugin)
+ *   DELETE /api/dialogs/:id        — remove a dialog from the queue
+ *
+ * WIRING (REQUIRED — read carefully):
+ *
+ *   This router is OWNED BY THE DIALOG SCOPE (Tyr). The route is
+ *   MOUNTED BY THE SLASH-COMMAND SIBLING SCOPE (Thor). Thor owns
+ *   `server.mjs`; I do NOT modify that file.
+ *
+ *   When Thor lands, they need to add the following to `server.mjs`:
+ *
+ *     import { createDialogsRouter } from './routes/dialogs.mjs';
+ *     import { startDialogPoller } from './dialog-poller.mjs';
+ *
+ *     // …inside createServer or whatever the bootstrap is…
+ *     app.use(createDialogsRouter({ broadcast }));
+ *     startDialogPoller();
+ *
+ *   Until that's done, the router is wired but unreachable and the
+ *   poller never starts. This is intentional — sibling separation
+ *   prevents both of us from racing on the same file.
+ *
+ *   Service-mode gap: `cli/service.mjs` also does NOT start the dialog
+ *   poller. If you want slash-command dialogs to flow in a service-only
+ *   deployment (no dashboard), add `startDialogPoller()` to
+ *   `cli/service.mjs`. Out of scope for this PR.
+ */
+import { Router } from 'express';
+import { dialogStore } from '../dialog-store.mjs';
+import { wrap } from './_shared.mjs';
+
+/**
+ * @param {object} deps
+ * @param {Function} deps.broadcast
+ * @returns {import('express').Router}
+ */
+export function createDialogsRouter({ broadcast }) {
+  const router = Router();
+
+  // Debug / introspection — what dialogs are currently queued?
+  router.get('/dialogs/queue', wrap(async (_req, res) => {
+    const queue = dialogStore.list();
+    res.json({ count: queue.length, queue });
+  }));
+
+  // Debug / history — what's been delivered recently? Since dialogs
+  // are one-shot and removed after broadcast, this endpoint returns
+  // the *currently queued* set as well; a true history view would
+  // need a separate append-only log (out of scope here).
+  router.get('/dialogs', wrap(async (_req, res) => {
+    const queue = dialogStore.list();
+    res.json({ dialogs: queue, dir: dialogStore.DIALOG_DIR });
+  }));
+
+  // Used by the slash-command plugin (Thor owns that, I just provide
+  // the route). The plugin POSTs the dialog descriptor and the route
+  // persists it; the poller picks it up on the next tick.
+  router.post('/dialogs', wrap(async (req, res) => {
+    const dialog = dialogStore.add(req.body || {});
+    // Best-effort immediate broadcast — the poller will re-broadcast on
+    // the next tick if this fails, but a successful immediate broadcast
+    // cuts latency to ~ms for already-connected dashboards.
+    try {
+      broadcast({ type: 'dialog:show', dialog });
+    } catch { /* best-effort */ }
+    res.status(201).json(dialog);
+  }));
+
+  router.delete('/dialogs/:id', wrap(async (req, res) => {
+    const ok = dialogStore.remove(req.params.id);
+    if (!ok) {
+      res.status(404).json({ error: 'not_found' });
+      return;
+    }
+    res.status(204).end();
+  }));
+
+  return router;
+}

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/routes/digests.mjs

@@ -0,0 +1,82 @@
+/**
+ * src/server/routes/digests.mjs
+ *
+ * /api/digests                          — list digests
+ * /api/digests/generate (POST)          — generate a digest
+ * /api/digests/:path (GET)              — get a specific digest
+ * /api/digests/:path (DELETE)           — delete a digest
+ *
+ * The `:path` parameter is URL-encoded so it survives Express routing.
+ */
+import { Router } from 'express';
+import {
+  generateAndSave,
+  listDigests,
+  getDigest,
+  deleteDigest,
+} from '../digest-store.mjs';
+import { readActiveProjectId, wrap } from './_shared.mjs';
+
+/**
+ * @param {object} deps
+ * @param {object} [deps.projectRoot]
+ * @returns {import('express').Router}
+ */
+export function createDigestsRouter({ projectRoot } = {}) {
+  const router = Router();
+
+  // GET /api/digests — list all digests
+  router.get('/digests', wrap(async (req, res) => {
+    const limit = parseInt(req.query.limit, 10) || 20;
+    const digests = await listDigests({ limit });
+    res.json({ digests });
+  }));
+
+  // GET /api/digests/:path — get a single digest by path
+  // The path is double-encoded: first by the client, then by Express.
+  router.get('/digests/*', wrap(async (req, res) => {
+    // Reconstruct the path from the wildcard
+    const rawPath = req.params[0];
+    if (!rawPath) {
+      // This catches /api/digests with no trailing path (should be handled
+      // by the /digests route above, but Express may match this first if the
+      // wildcard is greedy — we handle the list case explicitly).
+      const digests = await listDigests({ limit: 20 });
+      res.json({ digests });
+      return;
+    }
+    const filePath = decodeURIComponent(rawPath);
+    const digest = await getDigest(filePath);
+    if (!digest) {
+      res.status(404).json({ error: 'not_found', message: 'Digest not found' });
+      return;
+    }
+    res.json(digest);
+  }));
+
+  // POST /api/digests/generate — generate a new digest
+  router.post('/digests/generate', wrap(async (req, res) => {
+    const { weekStart, weekEnd, dryRun } = req.body || {};
+    const root = req.body?.projectRoot || projectRoot || process.cwd();
+    const result = await generateAndSave({ weekStart, weekEnd, projectRoot: root, dryRun });
+    res.status(dryRun ? 200 : 201).json(result);
+  }));
+
+  // DELETE /api/digests/* — delete a digest by path
+  router.delete('/digests/*', wrap(async (req, res) => {
+    const rawPath = req.params[0];
+    if (!rawPath) {
+      res.status(400).json({ error: 'bad_request', message: 'Digest path required' });
+      return;
+    }
+    const filePath = decodeURIComponent(rawPath);
+    const result = await deleteDigest(filePath);
+    if (!result.ok) {
+      res.status(404).json({ error: 'not_found', message: result.error || 'Digest not found' });
+      return;
+    }
+    res.status(204).end();
+  }));
+
+  return router;
+}