@polderlabs/bizar-dash 3.0.0

package/src/server/projects-store.mjs

@@ -0,0 +1,198 @@
+/**
+ * src/server/projects-store.mjs
+ *
+ * v3.0.0 — Per-project state registry.
+ *
+ * Project identification: the project's path basename (e.g.,
+ * `/home/user/myapp` → `myapp`). If the basename collides, the full path
+ * becomes the id.
+ *
+ * Storage:
+ *   ~/.config/opencode/projects.json         — registry (list + active id)
+ *   ~/.config/opencode/projects/<id>/        — per-project data dir
+ *     tasks.json, plans.json, schedules.json, mods.json, state.json,
+ *     sessions/ (chat sessions)
+ *
+ * The bizar core runtime (bizar package) and the dashboard both call into
+ * this module. All file ops are defensive — missing files / parse errors
+ * are silent.
+ */
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  statSync,
+  mkdirSync,
+} from 'node:fs';
+import { join, basename, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+
+const HOME = homedir();
+const OPENCODE_DIR = join(HOME, '.config', 'opencode');
+const PROJECTS_FILE = join(OPENCODE_DIR, 'projects.json');
+const PROJECTS_DIR = join(OPENCODE_DIR, 'projects');
+
+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 ensureProjectsDir() {
+  mkdirSync(PROJECTS_DIR, { recursive: true });
+  mkdirSync(OPENCODE_DIR, { recursive: true });
+}
+
+function loadRegistry() {
+  const data = safeReadJSON(PROJECTS_FILE, null);
+  if (!data || typeof data !== 'object') {
+    return { projects: [], active: null };
+  }
+  if (!Array.isArray(data.projects)) data.projects = [];
+  return data;
+}
+
+function saveRegistry(reg) {
+  ensureProjectsDir();
+  writeFileSync(PROJECTS_FILE, JSON.stringify(reg, null, 2) + '\n', 'utf8');
+}
+
+function projectIdFromPath(path) {
+  const b = basename(path);
+  return b || 'project';
+}
+
+function projectDir(id) {
+  return join(PROJECTS_DIR, id);
+}
+
+function readProjectFile(id, name, fallback) {
+  const file = join(projectDir(id), name);
+  return safeReadJSON(file, fallback);
+}
+
+function writeProjectFile(id, name, data) {
+  ensureProjectsDir();
+  const dir = projectDir(id);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, name), JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Public API.
+ */
+export const projectsStore = {
+  HOME,
+  OPENCODE_DIR,
+  PROJECTS_DIR,
+  PROJECTS_FILE,
+
+  /** Return the full registry. */
+  list() {
+    const reg = loadRegistry();
+    // Augment with disk status (active/inactive/error)
+    const out = (reg.projects || []).map((p) => {
+      let status = 'inactive';
+      if (p.path && existsSync(p.path)) {
+        status = p.id === reg.active ? 'active' : 'inactive';
+      } else if (p.path) {
+        status = 'error';
+      }
+      return { ...p, status };
+    });
+    return { projects: out, active: reg.active };
+  },
+
+  /** Add a project by absolute path. Returns the new project entry. */
+  add(path, name) {
+    if (!path || typeof path !== 'string') {
+      throw new Error('path is required');
+    }
+    const id = projectIdFromPath(path);
+    const reg = loadRegistry();
+    const existing = reg.projects.find((p) => p.id === id);
+    const now = new Date().toISOString();
+    if (existing) {
+      existing.path = path;
+      existing.lastAccessed = now;
+      saveRegistry(reg);
+      return existing;
+    }
+    const entry = {
+      id,
+      name: name || id,
+      path,
+      lastAccessed: now,
+      status: 'inactive',
+      summary: '',
+    };
+    reg.projects.push(entry);
+    if (!reg.active) reg.active = id;
+    saveRegistry(reg);
+    // Make sure the per-project dir exists
+    ensureProjectsDir();
+    mkdirSync(projectDir(id), { recursive: true });
+    return entry;
+  },
+
+  /** Remove a project from the registry. Per-project data is NOT deleted. */
+  remove(id) {
+    const reg = loadRegistry();
+    reg.projects = reg.projects.filter((p) => p.id !== id);
+    if (reg.active === id) reg.active = reg.projects[0]?.id || null;
+    saveRegistry(reg);
+    return true;
+  },
+
+  /** Switch the active project. Returns the new active entry or null. */
+  activate(id) {
+    const reg = loadRegistry();
+    const found = reg.projects.find((p) => p.id === id);
+    if (!found) return null;
+    reg.active = id;
+    found.lastAccessed = new Date().toISOString();
+    saveRegistry(reg);
+    return found;
+  },
+
+  /** Get the active project entry, or null. */
+  active() {
+    const reg = loadRegistry();
+    return reg.projects.find((p) => p.id === reg.active) || null;
+  },
+
+  /** Touch the lastAccessed timestamp. */
+  touch(id) {
+    const reg = loadRegistry();
+    const found = reg.projects.find((p) => p.id === id);
+    if (found) {
+      found.lastAccessed = new Date().toISOString();
+      saveRegistry(reg);
+    }
+  },
+
+  /** Per-project file helpers. */
+  readProjectFile,
+  writeProjectFile,
+  projectDir,
+
+  /** Return path to the per-project data dir; ensure it exists. */
+  ensureProjectDir(id) {
+    ensureProjectsDir();
+    const dir = projectDir(id);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+  },
+
+  /** Generate a short random id with prefix. */
+  genId(prefix = 'id') {
+    return prefix + '_' + randomBytes(6).toString('hex').slice(0, 10);
+  },
+};

package/src/server/providers-store.mjs

@@ -0,0 +1,183 @@
+/**
+ * src/server/providers-store.mjs
+ *
+ * v3.0.0 — OpenCode providers and MCPs management.
+ *
+ * Reads / writes the opencode.json at ~/.config/opencode/opencode.json
+ * under the `provider` and `mcp` keys.
+ *
+ * API keys are never echoed back in full — the response masks them.
+ */
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+} from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+const HOME = homedir();
+const OPENCODE_JSON = join(HOME, '.config', 'opencode', 'opencode.json');
+
+function safeReadJSON(file, fallback = {}) {
+  try {
+    if (!existsSync(file)) return fallback;
+    const text = readFileSync(file, 'utf8');
+    if (!text.trim()) return fallback;
+    return JSON.parse(text);
+  } catch {
+    return fallback;
+  }
+}
+
+function loadConfig() {
+  return safeReadJSON(OPENCODE_JSON, {});
+}
+
+function saveConfig(data) {
+  mkdirSync(dirname(OPENCODE_JSON), { recursive: true });
+  writeFileSync(OPENCODE_JSON, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+function mask(value) {
+  if (typeof value !== 'string' || !value) return '';
+  if (value.length <= 8) return '***';
+  return value.slice(0, 4) + '***' + value.slice(-4);
+}
+
+function unmask(stored, incoming) {
+  // Incoming is the user-typed value. If it's the masked form, keep stored.
+  if (typeof incoming === 'string' && incoming.startsWith('***') && incoming.endsWith('***')) {
+    return stored;
+  }
+  return incoming;
+}
+
+export const providersStore = {
+  OPENCODE_JSON,
+
+  list() {
+    const cfg = loadConfig();
+    const providers = cfg.provider || {};
+    return Object.entries(providers).map(([id, p]) => ({
+      id,
+      name: p.name || id,
+      baseURL: p.baseURL || p.options?.baseURL || '',
+      apiKey: mask(p.apiKey || p.options?.apiKey || ''),
+      models: Array.isArray(p.models) ? p.models : [],
+      enabled: p.enabled !== false,
+    }));
+  },
+
+  get(id) {
+    return this.list().find((p) => p.id === id) || null;
+  },
+
+  add(input) {
+    if (!input || !input.id) throw new Error('id is required');
+    if (!/^[a-z0-9][a-z0-9_-]{0,63}$/i.test(input.id)) {
+      throw new Error('invalid id');
+    }
+    const cfg = loadConfig();
+    cfg.provider = cfg.provider || {};
+    if (cfg.provider[input.id]) throw new Error(`provider "${input.id}" exists`);
+    cfg.provider[input.id] = {
+      name: input.name || input.id,
+      baseURL: input.baseURL || '',
+      apiKey: input.apiKey || '',
+      models: Array.isArray(input.models) ? input.models : [],
+      enabled: input.enabled !== false,
+    };
+    saveConfig(cfg);
+    return this.get(input.id);
+  },
+
+  update(id, patch) {
+    if (!patch || typeof patch !== 'object') throw new Error('patch required');
+    const cfg = loadConfig();
+    cfg.provider = cfg.provider || {};
+    const cur = cfg.provider[id];
+    if (!cur) throw new Error(`provider "${id}" not found`);
+    cfg.provider[id] = {
+      ...cur,
+      name: patch.name ?? cur.name,
+      baseURL: patch.baseURL ?? cur.baseURL,
+      apiKey: unmask(cur.apiKey, patch.apiKey),
+      models: Array.isArray(patch.models) ? patch.models : cur.models,
+      enabled: patch.enabled ?? cur.enabled,
+    };
+    saveConfig(cfg);
+    return this.get(id);
+  },
+
+  remove(id) {
+    const cfg = loadConfig();
+    if (!cfg.provider || !cfg.provider[id]) return false;
+    delete cfg.provider[id];
+    saveConfig(cfg);
+    return true;
+  },
+};
+
+export const mcpsStore = {
+  OPENCODE_JSON,
+
+  list() {
+    const cfg = loadConfig();
+    const mcps = cfg.mcp || {};
+    return Object.entries(mcps).map(([id, m]) => ({
+      id,
+      command: m.command || '',
+      args: Array.isArray(m.args) ? m.args : [],
+      env: m.env || {},
+      enabled: m.enabled !== false,
+    }));
+  },
+
+  get(id) {
+    return this.list().find((m) => m.id === id) || null;
+  },
+
+  add(input) {
+    if (!input || !input.id) throw new Error('id is required');
+    if (!/^[a-z0-9][a-z0-9_-]{0,63}$/i.test(input.id)) {
+      throw new Error('invalid id');
+    }
+    const cfg = loadConfig();
+    cfg.mcp = cfg.mcp || {};
+    if (cfg.mcp[input.id]) throw new Error(`mcp "${input.id}" exists`);
+    cfg.mcp[input.id] = {
+      command: input.command || '',
+      args: Array.isArray(input.args) ? input.args : [],
+      env: input.env || {},
+      enabled: input.enabled !== false,
+    };
+    saveConfig(cfg);
+    return this.get(input.id);
+  },
+
+  update(id, patch) {
+    if (!patch || typeof patch !== 'object') throw new Error('patch required');
+    const cfg = loadConfig();
+    cfg.mcp = cfg.mcp || {};
+    const cur = cfg.mcp[id];
+    if (!cur) throw new Error(`mcp "${id}" not found`);
+    cfg.mcp[id] = {
+      command: patch.command ?? cur.command,
+      args: Array.isArray(patch.args) ? patch.args : cur.args,
+      env: patch.env || cur.env,
+      enabled: patch.enabled ?? cur.enabled,
+    };
+    saveConfig(cfg);
+    return this.get(id);
+  },
+
+  remove(id) {
+    const cfg = loadConfig();
+    if (!cfg.mcp || !cfg.mcp[id]) return false;
+    delete cfg.mcp[id];
+    saveConfig(cfg);
+    return true;
+  },
+};

package/src/server/schedules-runner.mjs

@@ -0,0 +1,150 @@
+/**
+ * src/server/schedules-runner.mjs
+ *
+ * v3.0.0 — Executes due schedules.
+ *
+ * Called by the service daemon (cli/service.mjs) on a tick. For each due
+ * schedule, this module runs the action and records the result via
+ * schedulesStore.recordRun().
+ *
+ * Action types:
+ *   - command  → spawn a child process
+ *   - agent    → log + append activity (we don't dispatch live agents from
+ *               the service yet — that's wired in v3.1)
+ *   - webhook  → POST JSON to the URL
+ *
+ * v3 keeps the runner minimal. Errors are caught and recorded; the loop
+ * never throws.
+ */
+import { spawn } from 'node:child_process';
+import { writeFileSync, appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { projectsStore } from './projects-store.mjs';
+import { schedulesStore } from './schedules-store.mjs';
+
+const HOME = homedir();
+const LOG_DIR = join(HOME, '.config', 'bizar');
+const LOG_FILE = join(LOG_DIR, 'service.log');
+
+function logLine(line) {
+  try {
+    mkdirSync(LOG_DIR, { recursive: true });
+    appendFileSync(LOG_FILE, line + '\n', 'utf8');
+  } catch {
+    /* ignore */
+  }
+}
+
+async function runAction(action) {
+  if (!action || typeof action !== 'object') {
+    throw new Error('invalid action');
+  }
+  if (action.type === 'command') {
+    return runCommand(action);
+  }
+  if (action.type === 'webhook') {
+    return runWebhook(action);
+  }
+  if (action.type === 'agent') {
+    // For v3 we just log; real agent dispatch lives in v3.1+
+    logLine(`[schedule] agent dispatch (deferred to v3.1): ${action.target || '?'}`);
+    return { ok: true, note: 'agent dispatch deferred to v3.1' };
+  }
+  throw new Error(`unknown action type: ${action.type}`);
+}
+
+function runCommand(action) {
+  return new Promise((resolve) => {
+    const target = action.target || '';
+    if (!target) {
+      resolve({ ok: false, error: 'empty command target' });
+      return;
+    }
+    try {
+      const child = spawn(target, {
+        shell: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: process.env,
+      });
+      let stdout = '';
+      let stderr = '';
+      child.stdout.on('data', (b) => (stdout += b.toString()));
+      child.stderr.on('data', (b) => (stderr += b.toString()));
+      child.on('error', (err) => {
+        resolve({ ok: false, error: err.message, stdout, stderr });
+      });
+      child.on('close', (code) => {
+        resolve({
+          ok: code === 0,
+          error: code === 0 ? null : `exit ${code}`,
+          stdout: stdout.slice(-2000),
+          stderr: stderr.slice(-2000),
+        });
+      });
+    } catch (err) {
+      resolve({ ok: false, error: err.message });
+    }
+  });
+}
+
+async function runWebhook(action) {
+  const url = action.target;
+  if (!url) return { ok: false, error: 'empty webhook URL' };
+  try {
+    const r = await fetch(url, {
+      method: action.method || 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: action.body ? JSON.stringify(action.body) : undefined,
+    });
+    return { ok: r.ok, status: r.status };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+export const schedulesRunner = {
+  LOG_FILE,
+
+  /** Run all currently-due schedules for every project. */
+  async tick() {
+    const reg = projectsStore.list();
+    const fired = [];
+    for (const project of reg.projects) {
+      const due = schedulesStore.due(project.id, Date.now());
+      for (const sched of due) {
+        const result = await this.runOne(project.id, sched);
+        fired.push({ projectId: project.id, scheduleId: sched.id, ...result });
+      }
+    }
+    return fired;
+  },
+
+  /** Run a single schedule immediately and record the result. */
+  async runOne(projectId, sched) {
+    const startedAt = new Date().toISOString();
+    logLine(
+      `[${startedAt}] run ${projectId}/${sched.id} (${sched.type}: ${sched.schedule})`,
+    );
+    try {
+      const res = await runAction(sched.action);
+      const updated = schedulesStore.recordRun(projectId, sched.id, {
+        result: res.ok ? 'success' : 'error',
+        error: res.error || null,
+      });
+      logLine(
+        `[${new Date().toISOString()}] done ${projectId}/${sched.id} → ${res.ok ? 'success' : 'error: ' + res.error}`,
+      );
+      return { ok: res.ok, schedule: updated, runResult: res };
+    } catch (err) {
+      const updated = schedulesStore.recordRun(projectId, sched.id, {
+        result: 'error',
+        error: err.message || String(err),
+      });
+      logLine(
+        `[${new Date().toISOString()}] failed ${projectId}/${sched.id}: ${err.message}`,
+      );
+      return { ok: false, schedule: updated, runResult: { error: err.message } };
+    }
+  },
+};