@polderlabs/bizar 3.23.1 → 4.2.0

package/bizar-dash/src/server/diagnostics-store.mjs

@@ -0,0 +1,148 @@
+/**
+ * src/server/diagnostics-store.mjs
+ *
+ * v3.0.0 — Health check, version info, and last-N errors.
+ *
+ * Returns a single snapshot for the diagnostics card in the dashboard.
+ */
+import { existsSync, readFileSync, statSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { projectsStore } from './projects-store.mjs';
+import { modsLoader } from './mods-loader.mjs';
+import { agentsStore } from './agents-store.mjs';
+import { providersStore, mcpsStore } from './providers-store.mjs';
+import { tasksStore } from './tasks-store.mjs';
+import { schedulesStore } from './schedules-store.mjs';
+
+const HOME = homedir();
+const SERVICE_LOG = join(HOME, '.config', 'bizar', 'service.log');
+const SERVICE_PID = join(HOME, '.config', 'bizar', 'service.pid');
+const DASH_PACKAGE_JSON = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json');
+
+const startedAt = Date.now();
+
+function dashboardVersion() {
+  try {
+    return JSON.parse(readFileSync(DASH_PACKAGE_JSON, 'utf8'))?.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+function readRecentErrors() {
+  if (!existsSync(SERVICE_LOG)) return [];
+  try {
+    const text = readFileSync(SERVICE_LOG, 'utf8');
+    const lines = text.split(/\r?\n/);
+    const errors = [];
+    for (let i = lines.length - 1; i >= 0 && errors.length < 10; i--) {
+      const line = lines[i];
+      if (!line.trim()) continue;
+      if (/\b(failed|error|err)\b/i.test(line)) {
+        errors.push({ line, ts: parseLogTs(line) });
+      }
+    }
+    return errors;
+  } catch {
+    return [];
+  }
+}
+
+function parseLogTs(line) {
+  const m = /^\[([^\]]+)\]/.exec(line);
+  return m ? m[1] : null;
+}
+
+function checkPidAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function serviceStatus() {
+  if (!existsSync(SERVICE_PID)) return { running: false };
+  try {
+    const pid = parseInt(readFileSync(SERVICE_PID, 'utf8').trim(), 10);
+    if (!Number.isFinite(pid)) return { running: false, error: 'bad PID file' };
+    const alive = checkPidAlive(pid);
+    return { running: alive, pid, pidFile: SERVICE_PID };
+  } catch (err) {
+    return { running: false, error: err.message };
+  }
+}
+
+export const diagnosticsStore = {
+  /** Build the full diagnostics snapshot. */
+  snapshot(extra = {}) {
+    const projects = projectsStore.list();
+    const active = projectsStore.active();
+    const tasks = active ? tasksStore.loadTasks(active.id) : [];
+    const schedules = active ? schedulesStore.list(active.id) : [];
+    return {
+      version: dashboardVersion(),
+      uptimeMs: Date.now() - startedAt,
+      uptime: Math.floor((Date.now() - startedAt) / 1000),
+      nodeVersion: process.version,
+      platform: process.platform,
+      memory: {
+        rss: process.memoryUsage().rss,
+        heapUsed: process.memoryUsage().heapUsed,
+        heapTotal: process.memoryUsage().heapTotal,
+      },
+      counts: {
+        agents: agentsStore.list().length,
+        plans: 0, // plans are not in our scope yet; leave at 0
+        tasks: tasks.length,
+        projects: projects.projects.length,
+        activeProject: active?.id || null,
+        mods: modsLoader.list().length,
+        schedules: schedules.length,
+        providers: providersStore.list().length,
+        mcps: mcpsStore.list().length,
+      },
+      errors: readRecentErrors(),
+      service: serviceStatus(),
+      ...extra,
+    };
+  },
+
+  /** Run a set of health checks and return per-subsystem status. */
+  health() {
+    const checks = [];
+    const projectsFile = projectsStore.PROJECTS_FILE;
+    checks.push({
+      name: 'projects-registry',
+      ok: existsSync(dirname(projectsFile)),
+      detail: dirname(projectsFile),
+    });
+    checks.push({
+      name: 'opencode-agents',
+      ok: existsSync(agentsStore.AGENTS_DIR),
+      detail: agentsStore.AGENTS_DIR,
+    });
+    checks.push({
+      name: 'opencode-config',
+      ok: existsSync(providersStore.OPENCODE_JSON),
+      detail: providersStore.OPENCODE_JSON,
+    });
+    const modsDir = modsLoader.MOD_DIR || modsLoader.MOD_DIR;
+    checks.push({
+      name: 'mods-dir',
+      ok: true, // the dir is auto-created; this is informational
+      detail: modsLoader.MOD_DIR || modsLoader.MOD_DIR,
+    });
+    return {
+      ts: new Date().toISOString(),
+      checks,
+    };
+  },
+};
+
+// Add MOD_DIR alias for older access
+modsLoader.MOD_DIR = modsLoader.MOD_DIR || modsLoader.MODS_DIR;

package/bizar-dash/src/server/dialog-poller.mjs

@@ -0,0 +1,105 @@
+/**
+ * src/server/dialog-poller.mjs
+ *
+ * v3.9.0 — Dialog-request poller.
+ *
+ * Mirrors the bg-poller pattern: the plugin writes dialog requests to
+ * `~/.cache/bizar/dialogs/*.json`; this poller scans every second,
+ * broadcasts each one as a `dialog:show` WS message, and removes the
+ * file once the broadcast is dispatched.
+ *
+ * The dashboard's Chat view (sibling scope — Thor) listens for
+ * `dialog:show` messages and mounts the dialog component keyed by
+ * `dialog.component`.
+ *
+ * Idempotency: a dialog is a one-shot event. As soon as the broadcast
+ * succeeds the file is deleted. If the WS layer is down (no clients
+ * connected), the dialog stays on disk and will be delivered on the
+ * next tick — at-least-once delivery is acceptable because the
+ * dashboard de-duplicates by `dialog.id`.
+ *
+ * WIRING: this module is loaded by the dashboard's `server.mjs` (sibling
+ * scope — Thor). It expects `server.mjs` to call
+ * `startDialogPoller()` once at startup. The `broadcast()` function
+ * is exported from `server.mjs`; we lazy-import it the same way
+ * `bg-poller.mjs` does to avoid a circular dep.
+ *
+ * v3.x service-mode gap: `cli/service.mjs` does NOT currently start
+ * the dialog poller. Service-only deployments will need to add
+ * `startDialogPoller()` to `cli/service.mjs` if they want slash-
+ * command dialogs to flow without a running dashboard.
+ */
+import { dialogStore } from './dialog-store.mjs';
+
+const POLL_INTERVAL_MS = 1_000;
+
+let _interval = null;
+
+async function broadcastDialog(dialog) {
+  try {
+    const { broadcast } = await import('./server.mjs');
+    broadcast({
+      type: 'dialog:show',
+      dialog: {
+        id: dialog.id,
+        title: dialog.title,
+        command: dialog.command,
+        component: dialog.component,
+        data: dialog.data,
+      },
+    });
+  } catch (err) {
+    console.error('[dialog-poller] broadcast failed:', err.message);
+    return false;
+  }
+  return true;
+}
+
+async function tick() {
+  let queue;
+  try {
+    queue = dialogStore.list();
+  } catch (err) {
+    console.error('[dialog-poller] list() failed:', err.message);
+    return;
+  }
+  if (!queue || queue.length === 0) return;
+  for (const dialog of queue) {
+    const ok = await broadcastDialog(dialog);
+    if (!ok) continue;
+    // We remove AFTER broadcast — never before. That way a crash in
+    // the WS layer doesn't permanently lose a dialog.
+    try {
+      dialogStore.remove(dialog.id);
+    } catch (err) {
+      console.error('[dialog-poller] remove failed:', err.message);
+    }
+  }
+}
+
+export function startDialogPoller() {
+  if (_interval) return; // idempotent
+  // Tick once immediately so any dialog queued before startup is
+  // delivered to the first WS client without waiting a full interval.
+  tick().catch((err) => console.error('[dialog-poller] initial tick:', err.message));
+  _interval = setInterval(() => {
+    tick().catch((err) => console.error('[dialog-poller] tick:', err.message));
+  }, POLL_INTERVAL_MS);
+  if (_interval && typeof _interval.unref === 'function') {
+    _interval.unref();
+  }
+  console.log(`[dialog-poller] started (interval=${POLL_INTERVAL_MS}ms)`);
+}
+
+export function stopDialogPoller() {
+  if (_interval) {
+    clearInterval(_interval);
+    _interval = null;
+  }
+}
+
+// Exposed for tests / introspection.
+export const _pollerInternals = {
+  tick,
+  POLL_INTERVAL_MS,
+};

package/bizar-dash/src/server/dialog-store.mjs

@@ -0,0 +1,177 @@
+/**
+ * src/server/dialog-store.mjs
+ *
+ * v3.9.0 — Persisted dialog-request store for the slash-command plugin
+ * bridge. Thor's sibling plugin writes dialog requests to disk here; the
+ * dialog poller picks them up and broadcasts each as a
+ * `{ type: 'dialog:show', dialog }` WS message.
+ *
+ * Storage:
+ *   ~/.cache/bizar/dialogs/<iso-ts>-<rand>.json
+ *
+ * Each entry:
+ *   { id, ts, title, command, component, data? }
+ *
+ * Each entry is a single one-shot event: the poller removes the file
+ * after the broadcast succeeds. There is no ack/retry — if the WS is
+ * offline, the dialog is still on disk and will be delivered on the
+ * next tick. Operators who care about delivery can poll
+ * GET /api/dialogs for recent history.
+ *
+ * WIRING: this module is intentionally READ-ONLY from the perspective
+ * of `server.mjs` — the file that mounts routes and starts the poller
+ * is owned by the slash-command sibling. See the header comment at the
+ * top of `routes/dialogs.mjs` for the exact wiring contract.
+ *
+ * v3.x service-mode gap: `cli/service.mjs` runs the schedule tick but
+ * does NOT currently start the dialog poller. The dialog poller lives
+ * in the dashboard server. Service-only deployments (no dashboard
+ * running) will silently drop dialog requests until a future PR wires
+ * the poller into `cli/service.mjs`.
+ */
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  mkdirSync,
+  readdirSync,
+  unlinkSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+
+const HOME = homedir();
+const DIALOG_DIR = join(HOME, '.cache', 'bizar', 'dialogs');
+
+function ensureDir() {
+  try {
+    mkdirSync(DIALOG_DIR, { recursive: true });
+  } catch {
+    /* ignore — best-effort */
+  }
+}
+
+function safeReadJSON(file) {
+  try {
+    if (!existsSync(file)) return null;
+    const text = readFileSync(file, 'utf8');
+    if (!text.trim()) return null;
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function genId() {
+  return `dlg_${Date.now().toString(36)}${randomBytes(3).toString('hex')}`;
+}
+
+/** Allow-list of dialog `component` keys. The dashboard mounts each key
+ *  in the Chat view; unknown keys are accepted but logged. */
+// NOTE: if you add a new DialogComponent to lib/types.ts or
+// plugins/bizar/src/commands.ts, mirror it here so dialog-store
+// doesn't warn on every dialog of that type.
+const KNOWN_COMPONENTS = new Set([
+  'visual-plan',
+  'plan-create',
+  'plan-list',
+  'help',
+  'audit',
+  'generic',
+]);
+
+export const dialogStore = {
+  DIALOG_DIR,
+
+  /**
+   * Append a dialog request. Returns the persisted descriptor.
+   * Caller is expected to provide at minimum `{ id, title, command,
+   * component }`. `id` is auto-generated when missing.
+   *
+   * @param {{ id?: string, title: string, command: string, component: string, data?: Record<string, unknown> }} input
+   */
+  add(input) {
+    ensureDir();
+    if (!input || typeof input !== 'object') {
+      throw new Error('dialog payload required');
+    }
+    const id = input.id || genId();
+    const component = String(input.component || '');
+    if (!KNOWN_COMPONENTS.has(component)) {
+      // Don't reject — the desktop UI may grow new dialog components
+      // before this list does. Log instead so the operator can spot it.
+      console.warn(`[dialog-store] unknown dialog component: ${component}`);
+    }
+    const dialog = {
+      id,
+      ts: new Date().toISOString(),
+      title: String(input.title || ''),
+      command: String(input.command || ''),
+      component,
+      data: input.data && typeof input.data === 'object' ? input.data : undefined,
+    };
+    const safeTs = dialog.ts.replace(/[:.]/g, '-');
+    const file = join(DIALOG_DIR, `${safeTs}-${randomBytes(3).toString('hex')}.json`);
+    const tmp = `${file}.tmp.${process.pid}`;
+    writeFileSync(tmp, JSON.stringify(dialog, null, 2) + '\n', 'utf8');
+    renameSync(tmp, file);
+    return dialog;
+  },
+
+  /** Read every queued dialog. Cheap on a phone — expected N is 0–5. */
+  list() {
+    ensureDir();
+    let files;
+    try {
+      files = readdirSync(DIALOG_DIR).filter((f) => f.endsWith('.json'));
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const f of files) {
+      const full = join(DIALOG_DIR, f);
+      const data = safeReadJSON(full);
+      if (data) {
+        out.push({ ...data, _file: full });
+      }
+    }
+    // Oldest first — the poller processes in order so the user sees
+    // dialogs in the same sequence the plugin emitted them.
+    out.sort((a, b) => (a.ts || '').localeCompare(b.ts || ''));
+    return out;
+  },
+
+  /**
+   * Remove a dialog by id. Returns true when a file was actually
+   * deleted (used by the poller after a successful broadcast).
+   *
+   * @param {string} id
+   */
+  remove(id) {
+    if (!id) return false;
+    ensureDir();
+    let files;
+    try {
+      files = readdirSync(DIALOG_DIR).filter((f) => f.endsWith('.json'));
+    } catch {
+      return false;
+    }
+    let removed = false;
+    for (const f of files) {
+      const full = join(DIALOG_DIR, f);
+      const data = safeReadJSON(full);
+      if (data && data.id === id) {
+        try {
+          unlinkSync(full);
+          removed = true;
+        } catch {
+          /* best-effort */
+        }
+        break;
+      }
+    }
+    return removed;
+  },
+};