@polderlabs/bizar 4.0.0 → 4.2.1

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

@@ -11,7 +11,7 @@
  * initVault time (F7 invariant).
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, lstatSync, unlinkSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join, dirname, relative, resolve as pathResolve, sep } from 'node:path';
 import { homedir } from 'node:os';
@@ -19,6 +19,7 @@ import { parseFrontmatter, serializeFrontmatter } from './yaml.mjs';
 import { validateNote } from './memory-schema.mjs';
 import { scan as scanSecrets, hasHighFindings } from './memory-secrets.mjs';
 import { atomicWriteJson, safeReadJSON, safeReadText } from '../../../cli/atomic.mjs';
+import * as memoryGit from './memory-git.mjs';
 
 const HOME = homedir();
 const BIZAR_MEMORY_ROOT = join(HOME, '.local', 'share', 'bizar', 'memory');
@@ -26,15 +27,51 @@ const BIZAR_MEMORY_ROOT = join(HOME, '.local', 'share', 'bizar', 'memory');
 /**
  * Path safety: reject any relPath that would escape the vault root.
  *
+ * Defenses (in order):
+ *   1. Empty / null-byte injection → reject.
+ *   2. Explicit segment check for `..` and absolute path prefixes → reject
+ *      before path.resolve normalizes them away. The check is on SEGMENTS
+ *      (`..` separated by `/` or `\`), so filenames like `my..note.md` are
+ *      still allowed.
+ *   3. Post-resolve check: the resulting absolute path must be inside
+ *      vaultRoot (relative path must not start with `..`).
+ *   4. Symlink guard: if the resolved path is a pre-existing symlink, refuse.
+ *      This blocks an attacker who placed a symlink inside the vault pointing
+ *      outside from writing/reading through it.
+ *
+ * Known limitation: the symlink guard is not TOCTOU-safe. A swap between
+ * lstatSync and the subsequent read/write/delete is still possible. For a
+ * full TOCTOU fix the read/write/delete would need to use O_NOFOLLOW and
+ * operate on an open fd, not a path. This is acceptable for the current
+ * threat model (the vault is a per-user directory, not a multi-tenant FS).
+ *
  * @param {string} vaultRoot
  * @param {string} relPath
  * @returns {string | null} — resolved absolute path, or null if unsafe
  */
 function resolveSafe(vaultRoot, relPath) {
   if (!relPath || relPath.includes('\0')) return null;
+  // Segment-level check: reject any `..` segment or absolute-path prefix
+  // BEFORE path.resolve normalizes them away. This explicitly rejects
+  // paths like `notes/../escape.md`, while still allowing filenames like
+  // `my..note.md` (the substring `..` inside a single segment is fine).
+  const segments = relPath.split(/[\\/]+/);
+  if (segments.includes('..') || segments[0] === '') return null;
   const abs = pathResolve(vaultRoot, relPath);
   const rel = relative(vaultRoot, abs);
   if (rel.startsWith('..') || abs !== pathResolve(abs)) return null;
+  // Symlink guard (see note above re: TOCTOU). Note: existsSync follows
+  // symlinks, so we MUST use lstatSync directly — existsSync + isSymbolicLink
+  // misses dangling symlinks (target doesn't exist). lstatSync returns a
+  // Stats object even for dangling symlinks; catch only unexpected errors
+  // (e.g. EACCES on the parent directory).
+  try {
+    if (lstatSync(abs).isSymbolicLink()) return null;
+  } catch {
+    // Path doesn't exist or parent dir inaccessible — not a symlink,
+    // proceed. (A fresh write won't traverse a symlink because the
+    // symlink itself doesn't exist yet at write time.)
+  }
   return abs;
 }
 
@@ -119,6 +156,31 @@ export function resolveVault(projectRoot) {
   return { mode, projectId, vaultRoot, repoPath, configDir, gitRemote, branch, lightragDir, namespaces };
 }
 
+/**
+ * Resolve the absolute path of a namespace root.
+ *
+ * For `project`, returns vaultRoot (the existing default). For `global` and
+ * `user`, returns `<vaultRoot>/<namespaces.global|user>` in both modes —
+ * `writeNote('global/bizar/foo.md', …)` already places files there in both
+ * local-only and managed mode, so this matches the on-disk layout that
+ * existing callers rely on.
+ *
+ * (Note: an earlier draft distinguished local-only vs managed, putting
+ * global under `<repoPath>/global/bizar` in managed mode. That diverged from
+ * where writeNote actually creates the file, which is always under
+ * vaultRoot. This implementation matches the on-disk reality.)
+ *
+ * @param {{ mode: string, vaultRoot: string, namespaces: object }} vaultInfo
+ * @param {'project'|'global'|'user'} namespace
+ * @returns {string|null} absolute path, or null if the namespace is unknown
+ */
+export function resolveNamespaceRoot(vaultInfo, namespace) {
+  if (namespace === 'project') return vaultInfo.vaultRoot;
+  const ns = vaultInfo.namespaces?.[namespace];
+  if (!ns) return null;
+  return join(vaultInfo.vaultRoot, ns);
+}
+
 /**
  * Initialize the vault for a project. In local-only mode, creates .obsidian/
  * and standard subdirectories. In managed mode, the shared repo is assumed to
@@ -225,15 +287,20 @@ export function initVault(projectRoot) {
  * List all notes in the vault. Returns enriched note metadata.
  *
  * @param {string} projectRoot
- * @param {{ namespace?: string }} [opts]
+ * @param {{ namespace?: string, root?: string }} [opts]
+ *   `namespace`: subdirectory under `root` to walk (e.g. `projects/<id>`).
+ *   `root`:      override the root used as the walking base. Defaults to
+ *                `vaultRoot` from resolveVault. Used by namespace helpers
+ *                in cli/memory.mjs to list global / user notes.
  * @returns {Array<{ relPath: string, mtime: number, size: number, frontmatter: Record<string, unknown>, body: string, schemaValid: boolean }>}
  */
 export function listNotes(projectRoot, opts = {}) {
   const { vaultRoot } = resolveVault(projectRoot);
-  if (!existsSync(vaultRoot)) return [];
+  const root = opts.root || vaultRoot;
+  if (!existsSync(root)) return [];
 
   const namespace = opts.namespace || '';
-  const searchRoot = namespace ? join(vaultRoot, namespace) : vaultRoot;
+  const searchRoot = namespace ? join(root, namespace) : root;
   if (!existsSync(searchRoot)) return [];
 
   const out = [];
@@ -267,11 +334,14 @@ export function listNotes(projectRoot, opts = {}) {
  *
  * @param {string} projectRoot
  * @param {string} relPath
+ * @param {{ root?: string }} [opts]  optional override for the root used by
+ *                                    resolveSafe; defaults to vaultRoot
  * @returns {{ relPath: string, frontmatter: Record<string, unknown>, body: string, raw: string, mtime: number, size: number, schemaValid: boolean } | null}
  */
-export function readNote(projectRoot, relPath) {
-  const { vaultRoot } = resolveVault(projectRoot);
-  const filePath = resolveSafe(vaultRoot, relPath);
+export function readNote(projectRoot, relPath, opts = {}) {
+  const vaultInfo = resolveVault(projectRoot);
+  const root = opts.root || vaultInfo.vaultRoot;
+  const filePath = resolveSafe(root, relPath);
   if (!filePath || !existsSync(filePath)) return null;
   try {
     const raw = readFileSync(filePath, 'utf8');
@@ -333,6 +403,33 @@ export function writeNote(projectRoot, relPath, { frontmatter, body }) {
   const content = `---\n${yamlBlock}\n---\n\n${body}`;
   writeFileSync(filePath, content, 'utf8');
 
+  // Auto-commit the written file to git (if configured).
+  // The lock serializes commits, not writes — concurrent writes will each
+  // trigger their own commit, which is the intended behaviour.
+  (() => {
+    try {
+      if (!memoryGit.isGitInstalled()) return;
+      const { config } = loadConfig(projectRoot);
+      if (config.mode === 'local-only') return;
+      if (config.git?.autoCommitOnMemoryWrite !== true) return;
+      const lockResult = memoryGit.acquireLock(vaultRoot);
+      if (!lockResult || lockResult.error) return; // skip if locked or error
+      try {
+        memoryGit.addFile(vaultRoot, relPath);
+        const summary = frontmatter.title || relPath;
+        const message = (config.git.commitMessageTemplate || 'memory(BizarHarness): {summary}')
+          .replace('{summary}', summary);
+        memoryGit.commit(vaultRoot, message, { author: config.git.commitAuthor });
+      } finally {
+        lockResult.release();
+      }
+    } catch (err) {
+      // Log but never re-throw — the write already succeeded; a failed
+      // auto-commit is recoverable on next write or manual commit.
+      console.error('[memory-store] autoCommitOnMemoryWrite failed:', err?.message || err);
+    }
+  })();
+
   const st = statSync(filePath);
   return {
     relPath,
@@ -350,11 +447,14 @@ export function writeNote(projectRoot, relPath, { frontmatter, body }) {
  *
  * @param {string} projectRoot
  * @param {string} relPath
+ * @param {{ root?: string }} [opts]  optional override for the root used by
+ *                                    resolveSafe; defaults to vaultRoot
  * @returns {boolean}
  */
-export function deleteNote(projectRoot, relPath) {
-  const { vaultRoot } = resolveVault(projectRoot);
-  const filePath = resolveSafe(vaultRoot, relPath);
+export function deleteNote(projectRoot, relPath, opts = {}) {
+  const vaultInfo = resolveVault(projectRoot);
+  const root = opts.root || vaultInfo.vaultRoot;
+  const filePath = resolveSafe(root, relPath);
   if (!filePath || !existsSync(filePath)) return false;
   unlinkSync(filePath);
   return true;
@@ -422,3 +522,22 @@ export function validateAll(projectRoot) {
   }
   return results;
 }
+
+// ── LightRAG integration (v4.1.0) ──────────────────────────────────────────
+//
+// Re-export the LightRAG orchestrator from the memory-store module so the
+// dashboard, CLI, and tests have a single import surface. The actual
+// implementation lives in `memory-lightrag.mjs`.
+
+export {
+  resolveLightRAGConfig,
+  isInstalled as isLightRAGInstalled,
+  isRunning as isLightRAGRunning,
+  startServer as startLightRAG,
+  stopServer as stopLightRAG,
+  ensureRunning as ensureLightRAGRunning,
+  insertNote as insertLightRAGNote,
+  insertAllNotes as insertLightRAGAll,
+  reindexVault,
+  query as queryLightRAG,
+} from './memory-lightrag.mjs';

package/bizar-dash/src/server/mod-security.mjs

@@ -22,7 +22,7 @@
  *      Path-traversal attacks (e.g. `../`) are blocked.
  *   3. **Subprocess allowlist** — only whitelisted binaries
  *      (`bizar`, `opencode`, `python3`, `graphify`, `git`, `node`,
- *      `npm`, `pip`, `pipx`, `uv`, `rtk`) can be spawned. Custom
+ *      `npm`, `pip`, `pipx`, `uv`, `headroom`) can be spawned. Custom
  *      binaries require an explicit `process:spawn:<bin>` permission.
  *   4. **Audit log** — every privileged operation (fs read/write,
  *      process spawn, network fetch) is logged to
@@ -73,7 +73,7 @@ export const ALLOWED_BINARIES = new Set([
   'npm',
   'npx',
   'git',
-  'rtk',
+  'headroom',
   'jq',
 ]);
 

package/bizar-dash/src/server/routes/memory.mjs

@@ -23,6 +23,28 @@ const { atomicWriteJson } = await import(`${SERVER_ROOT}/../../../cli/atomic.mjs
 
 const { wrap } = await import('./_shared.mjs').then((m) => m);
 
+// Lazy import to avoid circular dependency with memory-lightrag.mjs
+async function getMemoryLightrag() {
+  return import(`${SERVER_ROOT}/memory-lightrag.mjs`).then((m) => m);
+}
+
+/**
+ * Redact apiKey in the lightrag block before sending to the UI.
+ * apiKey '***' means it was already redacted.
+ * Any non-empty string that is not '***' is replaced with '***'.
+ */
+function redactLightRAGConfig(config) {
+  if (!config || !config.lightrag) return config;
+  const { lightrag, ...rest } = config;
+  const redactedLightrag = {
+    ...lightrag,
+    apiKey: lightrag.apiKey && lightrag.apiKey !== '' && lightrag.apiKey !== '***'
+      ? '***'
+      : lightrag.apiKey || undefined,
+  };
+  return { ...rest, lightrag: redactedLightrag };
+}
+
 export function createMemoryRouter({ projectRoot }) {
   const router = Router();
 
@@ -82,12 +104,42 @@ export function createMemoryRouter({ projectRoot }) {
   router.get('/memory/config', wrap(async (_req, res) => {
     const { loadConfig } = memoryStore;
     const { config, exists } = loadConfig(projectRoot);
-    res.json({ exists, config });
+    res.json({ exists, config: redactLightRAGConfig(config) });
   }));
 
   // POST /memory/config
   router.post('/memory/config', wrap(async (req, res) => {
     const { loadConfig, saveConfig } = memoryStore;
+
+    // ── Patch mode: merge only the lightrag block ──────────────────────────
+    if (req.body && req.body.patch === true) {
+      const { writeLightRAGConfig } = await getMemoryLightrag();
+      const { lightrag, patch: _patch, ...restPatch } = req.body;
+
+      // Validate no unexpected top-level fields in patch
+      if (Object.keys(restPatch).length > 0) {
+        res.status(400).json({ error: 'bad_request', message: 'patch mode only accepts a "lightrag" field' });
+        return;
+      }
+      if (!lightrag || typeof lightrag !== 'object') {
+        res.status(400).json({ error: 'bad_request', message: 'patch mode requires a "lightrag" object' });
+        return;
+      }
+
+      const result = writeLightRAGConfig(projectRoot, lightrag);
+      if (!result.ok) {
+        res.status(400).json({ error: 'validation_error', message: result.error });
+        return;
+      }
+
+      // Return full config with redacted lightrag block
+      const { config: full } = loadConfig(projectRoot);
+      const redacted = redactLightRAGConfig(full);
+      res.json({ ok: true, config: redacted });
+      return;
+    }
+
+    // ── Full replace mode (existing behaviour) ───────────────────────────────
     const { config: newConfig, confirm } = req.body || {};
     if (!newConfig || typeof newConfig !== 'object') {
       res.status(400).json({ error: 'bad_request', message: 'body must include config object' });
@@ -111,7 +163,8 @@ export function createMemoryRouter({ projectRoot }) {
       res.status(500).json({ error: 'write_failed', message: result.error });
       return;
     }
-    res.json({ ok: true, config: merged });
+    const redacted = redactLightRAGConfig(merged);
+    res.json({ ok: true, config: redacted });
   }));
 
   // GET /memory/notes
@@ -437,20 +490,34 @@ export function createMemoryRouter({ projectRoot }) {
     res.json({ conflicts });
   }));
 
-  // POST /memory/reindex — STUB
+  // POST /memory/reindex — v4.1.0 real LightRAG population
   router.post('/memory/reindex', wrap(async (_req, res) => {
-    const cacheDir = join(projectRoot, '.bizar', 'memory-cache');
-    if (!existsSync(cacheDir)) {
-      mkdirSync(cacheDir, { recursive: true });
-    }
-    const marker = join(cacheDir, 'last-reindex-attempt.json');
-    const data = {
-      attemptedAt: new Date().toISOString(),
-      ok: false,
-      reason: 'lightrag-not-implemented',
-    };
-    atomicWriteJson(marker, data);
-    res.json({ ok: false, stub: true });
+    const { reindexVault } = memoryStore;
+    const result = await reindexVault(projectRoot, {});
+    if (!result.ok && result.inserted === 0) {
+      res.status(422).json(result);
+      return;
+    }
+    res.json(result);
+  }));
+
+  // GET /memory/query?q=...&topK=10 — merged lexical + semantic search
+  router.get('/memory/query', wrap(async (req, res) => {
+    const q = String(req.query.q || '').trim();
+    if (!q) {
+      res.status(400).json({ error: 'q required' });
+      return;
+    }
+    const topK = Math.min(parseInt(req.query.topK, 10) || 10, 50);
+    const { searchVault, queryLightRAG } = memoryStore;
+    const lexical = searchVault(projectRoot, q, { limit: topK });
+    let semantic = null;
+    try {
+      semantic = await queryLightRAG(projectRoot, q, { topK });
+    } catch (err) {
+      semantic = { ok: false, error: err.message };
+    }
+    res.json({ ok: true, q, lexical, semantic });
   }));
 
   // GET /memory/doctor
@@ -495,5 +562,97 @@ export function createMemoryRouter({ projectRoot }) {
     res.json({ ok: allPassed, checks });
   }));
 
+  // GET /memory/lightrag/status
+  router.get('/memory/lightrag/status', wrap(async (_req, res) => {
+    const { resolveLightRAGConfig, isRunning } = await getMemoryLightrag();
+    const cfg = resolveLightRAGConfig(projectRoot);
+    const pidFile = join(cfg.workingDir, 'lightrag.pid');
+
+    // Inline readPidAlive logic
+    let pid = null;
+    let alive = false;
+    if (existsSync(pidFile)) {
+      try {
+        pid = parseInt(readFileSync(pidFile, 'utf8').trim(), 10);
+        if (Number.isFinite(pid) && pid > 0) {
+          try {
+            process.kill(pid, 0);
+            alive = true;
+          } catch {
+            alive = false;
+          }
+        } else {
+          pid = null;
+        }
+      } catch {
+        pid = null;
+      }
+    }
+
+    const running = alive && (await isRunning(cfg));
+    const logFile = join(cfg.workingDir, 'lightrag.log');
+    const logTail = [];
+
+    if (existsSync(logFile)) {
+      try {
+        const content = readFileSync(logFile, 'utf8');
+        const lines = content.split('\n');
+        logTail.push(...lines.slice(-30));
+      } catch {}
+    }
+
+    let lastError = null;
+    if (!running && pid !== null) {
+      lastError = 'process not responding to health checks';
+    }
+
+    res.json({
+      running,
+      pid: running ? pid : null,
+      host: cfg.host,
+      port: cfg.port,
+      llmBinding: cfg.llmBinding,
+      embeddingBinding: cfg.embeddingBinding,
+      llmModel: cfg.llmModel,
+      embeddingModel: cfg.embeddingModel,
+      lastError,
+      logTail,
+    });
+  }));
+
+  // POST /memory/lightrag/start
+  router.post('/memory/lightrag/start', wrap(async (_req, res) => {
+    const { resolveLightRAGConfig, startServer } = await getMemoryLightrag();
+    const cfg = resolveLightRAGConfig(projectRoot);
+    const result = await startServer(cfg, {});
+    res.json(result);
+  }));
+
+  // POST /memory/lightrag/stop
+  router.post('/memory/lightrag/stop', wrap(async (_req, res) => {
+    const { resolveLightRAGConfig, stopServer } = await getMemoryLightrag();
+    const cfg = resolveLightRAGConfig(projectRoot);
+    const result = await stopServer(cfg, {});
+    res.json(result);
+  }));
+
+  // GET /memory/lightrag/log
+  router.get('/memory/lightrag/log', wrap(async (_req, res) => {
+    const { resolveLightRAGConfig } = await getMemoryLightrag();
+    const cfg = resolveLightRAGConfig(projectRoot);
+    const logFile = join(cfg.workingDir, 'lightrag.log');
+    if (!existsSync(logFile)) {
+      res.json({ lines: [] });
+      return;
+    }
+    try {
+      const content = readFileSync(logFile, 'utf8');
+      const lines = content.split('\n');
+      res.json({ lines: lines.slice(-200) });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  }));
+
   return router;
 }

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

@@ -302,7 +302,7 @@ export async function createServer({
   }
   currentBroadcast = localBroadcast;
 
-  const apiRouter = createApiRouter({
+  const apiRouter = await createApiRouter({
     state,
     watcher,
     projectRoot,

package/bizar-dash/src/server/state.mjs

@@ -13,7 +13,7 @@
  *   - getChat:      per-project sessions/<id>.jsonl (preferred) — falls
  *                   back to legacy .bizar/sessions if no project is active
  *   - getAgents:    ~/.config/opencode/agents/*.md (frontmatter parse)
- *   - getArtifacts:     scans artifacts/ (worktree) and ~/.config/opencode/artifacts/
+ *   - getArtifacts:     scans .bizar/artifacts/ (worktree) and ~/.config/opencode/artifacts/
  */
 import {
   existsSync,
@@ -47,7 +47,7 @@ export function createState({ projectRoot, opencodeConfigDir, bizarRoot }) {
     bizarDir: join(projectRoot, '.bizar'),
     sessionsDir: join(projectRoot, '.bizar', 'sessions'),
     activityLog: join(projectRoot, '.bizar', 'activity.log'),
-    plansDir: join(projectRoot, 'artifacts'),
+    plansDir: join(projectRoot, '.bizar', 'artifacts'),
     globalPlansDir: join(opencodeConfigDir, 'artifacts'),
     settingsFile: join(HOME, '.config', 'bizar', 'settings.json'),
   };