@polderlabs/bizar 3.23.1 → 4.2.0

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

@@ -0,0 +1,268 @@
+/**
+ * src/server/schedules-store.mjs
+ *
+ * v3.9.0 — Schedules registry.
+ *
+ * Each project has its own schedules.json at
+ *   ~/.config/opencode/projects/<id>/schedules.json
+ *
+ * A schedule is a recurring task: { name, type, schedule, action, enabled, ... }.
+ * Supported types:
+ *   - interval  ("30m", "2h", "1d")
+ *   - cron      ("0 0 * * *")  — full cron via the `croner` package, with
+ *                                optional IANA `timezone` (default "UTC")
+ *   - once      (ISO timestamp)
+ *
+ * The dashboard reads / writes schedules here. The bizar service daemon
+ * (cli/service.mjs) calls evaluateAndRun() on a tick to fire due actions.
+ *
+ * v3.9.0 changes vs v3.x:
+ *   - Cron parsing is now delegated to `croner` (proper 5-field + 6-field
+ *     + IANA TZ support). The old hand-rolled `nextCronMinute` walker is
+ *     gone.
+ *   - New Schedule fields: `timezone`, `budgetCheck`, `action.prompt`.
+ */
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  mkdirSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { Cron } from 'croner';
+import { projectsStore } from './projects-store.mjs';
+
+function safeReadJSON(file, fallback = null) {
+  try {
+    if (!existsSync(file)) return fallback;
+    const text = readFileSync(file, 'utf8');
+    if (!text.trim()) return fallback;
+    return JSON.parse(text);
+  } catch {
+    return fallback;
+  }
+}
+
+function genId() {
+  return 'sched_' + randomBytes(5).toString('hex').slice(0, 10);
+}
+
+/** Parse "30m" / "2h" / "1d" / "45s" → milliseconds. */
+export function parseInterval(s) {
+  if (typeof s !== 'string') return null;
+  const m = /^(\d+)\s*(s|sec|second|m|min|minute|h|hr|hour|d|day)$/i.exec(s.trim());
+  if (!m) return null;
+  const n = parseInt(m[1], 10);
+  const unit = m[2].toLowerCase();
+  if (unit.startsWith('s')) return n * 1000;
+  if (unit.startsWith('m')) return n * 60 * 1000;
+  if (unit.startsWith('h')) return n * 60 * 60 * 1000;
+  if (unit.startsWith('d')) return n * 24 * 60 * 60 * 1000;
+  return null;
+}
+
+/** Compute the next firing time for a schedule. Returns ISO string or null. */
+export function computeNextRun(schedule, fromMs = Date.now()) {
+  const type = schedule.type;
+  if (type === 'interval') {
+    const ms = parseInterval(schedule.schedule);
+    if (!ms) return null;
+    const last = schedule.lastRun ? new Date(schedule.lastRun).getTime() : fromMs;
+    return new Date(last + ms).toISOString();
+  }
+  if (type === 'once') {
+    if (schedule.lastRun) return null; // already fired
+    const when = new Date(schedule.schedule).getTime();
+    if (Number.isNaN(when)) return null;
+    return new Date(Math.max(when, fromMs)).toISOString();
+  }
+  if (type === 'cron') {
+    if (typeof schedule.schedule !== 'string' || !schedule.schedule.trim()) return null;
+    try {
+      const tz = schedule.timezone || 'UTC';
+      // croner takes IANA tz names ("America/New_York", "Europe/Berlin",
+      // "UTC", etc.) and falls back to the system zone on invalid input.
+      const job = new Cron(schedule.schedule, { timezone: tz });
+      const next = job.nextRun(new Date(fromMs));
+      return next ? next.toISOString() : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+function loadSchedules(projectId) {
+  const dir = projectsStore.ensureProjectDir(projectId);
+  const file = join(dir, 'schedules.json');
+  const data = safeReadJSON(file, null);
+  if (!data || !Array.isArray(data.schedules)) {
+    return { version: 1, schedules: [] };
+  }
+  return data;
+}
+
+function atomicWriteJson(filePath, data) {
+  const tmp = `${filePath}.tmp.${process.pid}`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', 'utf8');
+  renameSync(tmp, filePath);
+}
+
+function saveSchedules(projectId, data) {
+  const dir = projectsStore.ensureProjectDir(projectId);
+  atomicWriteJson(join(dir, 'schedules.json'), data);
+}
+
+export const schedulesStore = {
+  list(projectId) {
+    return loadSchedules(projectId).schedules;
+  },
+
+  get(projectId, id) {
+    return this.list(projectId).find((s) => s.id === id) || null;
+  },
+
+  add(projectId, input) {
+    if (!input || typeof input !== 'object') {
+      throw new Error('schedule payload required');
+    }
+    if (!input.name) throw new Error('name is required');
+    if (!['interval', 'cron', 'once'].includes(input.type)) {
+      throw new Error('type must be interval | cron | once');
+    }
+    if (!input.schedule) throw new Error('schedule is required');
+    if (!input.action || typeof input.action !== 'object') {
+      throw new Error('action is required');
+    }
+    const data = loadSchedules(projectId);
+    const now = new Date().toISOString();
+    const sched = {
+      id: genId(),
+      name: input.name,
+      type: input.type,
+      schedule: input.schedule,
+      timezone: typeof input.timezone === 'string' && input.timezone.trim()
+        ? input.timezone.trim()
+        : 'UTC',
+      action: input.action,
+      budgetCheck: input.budgetCheck && typeof input.budgetCheck === 'object'
+        ? {
+            maxConcurrent: Number.isFinite(input.budgetCheck.maxConcurrent)
+              ? input.budgetCheck.maxConcurrent
+              : 6,
+            skipIfBudgetLow: !!input.budgetCheck.skipIfBudgetLow,
+          }
+        : { maxConcurrent: 6, skipIfBudgetLow: false },
+      enabled: input.enabled !== false,
+      createdAt: now,
+      updatedAt: now,
+      lastRun: null,
+      lastResult: null,
+      lastError: null,
+      nextRun: computeNextRun({
+        type: input.type,
+        schedule: input.schedule,
+        timezone: input.timezone || 'UTC',
+      }),
+      history: [],
+    };
+    data.schedules.push(sched);
+    saveSchedules(projectId, data);
+    return sched;
+  },
+
+  update(projectId, id, patch) {
+    const data = loadSchedules(projectId);
+    const idx = data.schedules.findIndex((s) => s.id === id);
+    if (idx === -1) return null;
+    const cur = data.schedules[idx];
+    const next = {
+      ...cur,
+      ...patch,
+      id: cur.id,
+      updatedAt: new Date().toISOString(),
+    };
+    // Sanitize nested budgetCheck so callers can't smuggle in extra keys
+    // (matches the shape validation in `add`).
+    if (patch && Object.prototype.hasOwnProperty.call(patch, 'budgetCheck')) {
+      const bc = patch.budgetCheck && typeof patch.budgetCheck === 'object'
+        ? patch.budgetCheck
+        : {};
+      next.budgetCheck = {
+        maxConcurrent: Number.isFinite(bc.maxConcurrent) ? bc.maxConcurrent : 6,
+        skipIfBudgetLow: !!bc.skipIfBudgetLow,
+      };
+    }
+    if (patch && Object.prototype.hasOwnProperty.call(patch, 'timezone')) {
+      next.timezone = typeof patch.timezone === 'string' && patch.timezone.trim()
+        ? patch.timezone.trim()
+        : 'UTC';
+    }
+    if (patch && Object.prototype.hasOwnProperty.call(patch, 'action') && patch.action) {
+      // Preserve the existing action shape; only the listed keys are merged.
+      next.action = {
+        type: patch.action.type || cur.action.type,
+        target: patch.action.target ?? cur.action.target,
+        prompt: patch.action.prompt ?? cur.action.prompt,
+        method: patch.action.method ?? cur.action.method,
+        body: patch.action.body ?? cur.action.body,
+        title: patch.action.title ?? cur.action.title,
+        name: patch.action.name ?? cur.action.name,
+      };
+    }
+    if (patch.type || patch.schedule || patch.timezone) {
+      next.nextRun = computeNextRun({
+        type: next.type,
+        schedule: next.schedule,
+        timezone: next.timezone || 'UTC',
+      });
+    }
+    data.schedules[idx] = next;
+    saveSchedules(projectId, data);
+    return next;
+  },
+
+  remove(projectId, id) {
+    const data = loadSchedules(projectId);
+    const before = data.schedules.length;
+    data.schedules = data.schedules.filter((s) => s.id !== id);
+    if (data.schedules.length === before) return false;
+    saveSchedules(projectId, data);
+    return true;
+  },
+
+  /** Record the result of a run. */
+  recordRun(projectId, id, { result, error }) {
+    const data = loadSchedules(projectId);
+    const sched = data.schedules.find((s) => s.id === id);
+    if (!sched) return null;
+    const now = new Date().toISOString();
+    sched.lastRun = now;
+    // `result` is one of: 'success' | 'error' | 'skipped'. Pass through
+    // whatever the runner reports — null is also legal for backwards
+    // compat with old callers, but the new runner always passes a value.
+    sched.lastResult = result || null;
+    sched.lastError = error || null;
+    if (sched.type === 'once') {
+      sched.enabled = false;
+    } else {
+      sched.nextRun = computeNextRun(sched, Date.now());
+    }
+    sched.history = sched.history || [];
+    sched.history.push({ ts: now, result: result || 'unknown', error: error || null });
+    if (sched.history.length > 50) sched.history = sched.history.slice(-50);
+    saveSchedules(projectId, data);
+    return sched;
+  },
+
+  /** Return all schedules for the project that are currently due. */
+  due(projectId, now = Date.now()) {
+    return this.list(projectId).filter((s) => {
+      if (!s.enabled) return false;
+      if (!s.nextRun) return false;
+      return new Date(s.nextRun).getTime() <= now;
+    });
+  },
+};

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

@@ -0,0 +1,220 @@
+/**
+ * src/server/search-store.mjs
+ *
+ * v3.0.0 — Fuzzy search across projects, tasks, plans, agents, mods,
+ * commands.
+ *
+ * v3.0.4 — Added `settings` scope. Reads ~/.config/bizar/settings.json
+ * and surfaces each leaf as a searchable entry. Setting descriptions
+ * come from SETTINGS_DESCRIPTIONS so users can find them by typing
+ * "theme", "accent", "layout", etc.
+ *
+ * Uses a simple substring / token match for v3. fuse.js is wired in for
+ * fuzzy ranking but we keep a simple default that works without deps.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { agentsStore } from './agents-store.mjs';
+import { projectsStore } from './projects-store.mjs';
+import { tasksStore } from './tasks-store.mjs';
+import { modsLoader } from './mods-loader.mjs';
+import { schedulesStore } from './schedules-store.mjs';
+
+const HOME = homedir();
+const SETTINGS_FILE = join(HOME, '.config', 'bizar', 'settings.json');
+
+/**
+ * v3.0.4 — Human-friendly descriptions for each known setting key.
+ * The `path` in the result is what we attach to the search-result item
+ * so the frontend can scroll-and-flash the right row.
+ */
+const SETTINGS_DESCRIPTIONS = {
+  'theme.mode': 'Dark or light theme (dark, light, system)',
+  'theme.accent': 'Accent color for highlights',
+  'theme.success': 'Color used for success indicators',
+  'theme.warning': 'Color used for warning indicators',
+  'theme.error': 'Color used for error indicators',
+  'theme.info': 'Color used for info indicators',
+  'theme.fontFamily': 'Font family (Inter, system, mono)',
+  'theme.fontSize': 'Base font size in pixels',
+  'theme.compactMode': 'Denser UI with smaller spacing',
+  'theme.animations': 'Enable UI animations and transitions',
+  'ui.layout': 'Layout style (topnav, sidebar, both)',
+  'ui.showHeader': 'Show the top header bar',
+  'ui.showStatusBar': 'Show the status bar at the bottom',
+  'ui.defaultTab': 'Tab to open on launch',
+  'defaultAgent': 'Default agent used in chat and tasks',
+  'defaultModel': 'Default model override (empty = provider default)',
+  'notifications.onAgentComplete': 'Toast when an agent invocation completes',
+  'notifications.onPlanApproval': 'Toast when a plan needs approval',
+  'dashboard.autoLaunchWeb': 'Auto-launch web UI when starting TUI',
+  'service.enabled': 'Enable background service daemon',
+  'service.autostart': 'Start the service daemon at login',
+};
+
+function flattenSettings(obj, prefix = '', out = []) {
+  if (!obj || typeof obj !== 'object') return out;
+  for (const [k, v] of Object.entries(obj)) {
+    const path = prefix ? `${prefix}.${k}` : k;
+    if (v && typeof v === 'object' && !Array.isArray(v)) {
+      flattenSettings(v, path, out);
+    } else {
+      out.push({ id: path, value: v });
+    }
+  }
+  return out;
+}
+
+function readSettings() {
+  try {
+    if (!existsSync(SETTINGS_FILE)) return null;
+    const raw = readFileSync(SETTINGS_FILE, 'utf8');
+    if (!raw.trim()) return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function scoreItem(item, fields, query) {
+  if (!query) return 0;
+  const q = query.toLowerCase();
+  let best = 0;
+  for (const f of fields) {
+    const v = item[f];
+    if (typeof v !== 'string') continue;
+    const idx = v.toLowerCase().indexOf(q);
+    if (idx === -1) continue;
+    // earlier matches score higher
+    const s = 100 - Math.min(idx, 99);
+    if (s > best) best = s;
+  }
+  return best;
+}
+
+function findPlans(planDirs) {
+  // Quick local scan — the dashboard state already lists plans, but we
+  // re-discover from the active project's plans/ dir for a self-contained
+  // search.
+  const out = [];
+  // We don't have a project plan dir in v3 search — leave it empty.
+  return out;
+}
+
+export const searchStore = {
+  search(query, { activeProjectId, scope = 'all' } = {}) {
+    const q = (query || '').trim();
+    if (!q) return { query, results: [] };
+    const results = [];
+
+    if (scope === 'all' || scope === 'projects') {
+      const reg = projectsStore.list();
+      for (const p of reg.projects) {
+        const s = scoreItem(p, ['name', 'path', 'summary'], q);
+        if (s > 0) results.push({ type: 'project', score: s, item: p });
+      }
+    }
+
+    if (scope === 'all' || scope === 'agents') {
+      for (const a of agentsStore.list()) {
+        const s = scoreItem(a, ['name', 'description', 'model', 'mode'], q);
+        if (s > 0) results.push({ type: 'agent', score: s, item: a });
+      }
+    }
+
+    if (scope === 'all' || scope === 'tasks') {
+      const tasks = activeProjectId
+        ? tasksStore.loadTasks(activeProjectId)
+        : [];
+      for (const t of tasks) {
+        const tags = (t.tags || []).join(' ');
+        const s = scoreItem(
+          { title: t.title || '', description: t.description || '', tags },
+          ['title', 'description', 'tags'],
+          q,
+        );
+        if (s > 0) results.push({ type: 'task', score: s, item: t });
+      }
+    }
+
+    if (scope === 'all' || scope === 'mods') {
+      for (const m of modsLoader.list()) {
+        const s = scoreItem(
+          { name: m.name || '', description: m.description || '', author: m.author || '' },
+          ['name', 'description', 'author'],
+          q,
+        );
+        if (s > 0) results.push({ type: 'mod', score: s, item: m });
+      }
+    }
+
+    if (scope === 'all' || scope === 'schedules') {
+      const list = activeProjectId
+        ? schedulesStore.list(activeProjectId)
+        : [];
+      for (const sc of list) {
+        const s = scoreItem(sc, ['name', 'schedule'], q);
+        if (s > 0) results.push({ type: 'schedule', score: s, item: sc });
+      }
+    }
+
+    if (scope === 'all' || scope === 'commands') {
+      // Built-in slash commands + a placeholder for the user's
+      // commands-bizar folder.
+      const builtin = [
+        { name: 'plan', description: 'Manage visual plans' },
+        { name: 'audit', description: 'Run security audit' },
+        { name: 'init', description: 'Initialize .bizar/ in this project' },
+        { name: 'update', description: 'Update bizar + plugin' },
+        { name: 'export', description: 'Export to another harness' },
+        { name: 'service', description: 'Manage the service daemon' },
+        { name: 'explain', description: 'Read-only code Q&A' },
+        { name: 'pr-review', description: 'PR review with @mimir + @forseti' },
+      ];
+      for (const c of builtin) {
+        const s = scoreItem(c, ['name', 'description'], q);
+        if (s > 0) results.push({ type: 'command', score: s, item: c });
+      }
+    }
+
+    if (scope === 'all' || scope === 'settings') {
+      // v3.0.4 — Surface each setting as a result. Score against the
+      // full dot-path, the human description, and the current value
+      // (stringified) so users can find e.g. "dark" or "Inter" too.
+      const settings = readSettings();
+      if (settings) {
+        const flat = flattenSettings(settings);
+        for (const s of flat) {
+          const desc = SETTINGS_DESCRIPTIONS[s.id] || '';
+          const valStr = s.value === null || s.value === undefined
+            ? ''
+            : typeof s.value === 'string'
+              ? s.value
+              : JSON.stringify(s.value);
+          // Score against id (path) first, then description, then value.
+          let best = 0;
+          best = Math.max(best, scoreItem({ id: s.id }, ['id'], q));
+          if (desc) best = Math.max(best, scoreItem({ desc }, ['desc'], q));
+          if (valStr) best = Math.max(best, scoreItem({ val: valStr }, ['val'], q));
+          if (best > 0) {
+            results.push({
+              type: 'setting',
+              score: best,
+              item: {
+                id: s.id,
+                path: s.id,
+                label: s.id,
+                desc,
+                value: s.value,
+              },
+            });
+          }
+        }
+      }
+    }
+
+    results.sort((a, b) => b.score - a.score);
+    return { query, results: results.slice(0, 50) };
+  },
+};