synabun 2.0.10 → 2.2.0

package/neural-interface/lib/claude-history-cache.js

@@ -0,0 +1,210 @@
+// ── Claude Code transcripts, parsed once ──
+// GET /api/claude-code/sessions/:id/messages used to read and JSON.parse a
+// session's whole JSONL on every request, and one session open makes several:
+// the panel's snapshot probe (limit=1), the rebuild (limit=500), "load earlier",
+// "show all" of a clipped result (?tool=). A transcript runs to tens of MB, and
+// on Windows (slower file reads, every read scanned by the antivirus) each pass
+// costs seconds. This keeps the collector of the last few transcripts read and,
+// when the file grew, parses only what was appended.
+//
+// A kept collector is used only for the same file (device and inode) when
+// everything it read is still there unchanged. Same size and time: reused as it
+// is. Grown: the first HEAD_BYTES of the file and the last TAIL_BYTES before
+// where the last read stopped must still be what was read (a rewrite followed by
+// growth changes one of them). Any other change (shorter, same size with a new
+// time, an edit in place) reads the file again from the start. Only whole lines are taken: a last line
+// still being written (no newline yet, and not JSON yet) is read next time.
+// The file is always opened through openConfinedStream, from the canonical
+// paths findSessionTranscript checked.
+
+import { statSync } from 'node:fs';
+import { openConfinedStream } from './confined-fs.js';
+import { createHistoryCollector } from './claude-history.js';
+
+const NEWLINE = 0x0a;
+const TAIL_BYTES = 4096;
+const HEAD_BYTES = 4096;
+export const HISTORY_CACHE_LIMITS = Object.freeze({
+  maxEntries: 4,
+  maxIdleMs: 10 * 60_000,
+  // A bigger transcript is still answered, from a fresh read each time: it is not kept in memory.
+  maxCachedBytes: 256 * 1024 * 1024,
+  // All kept transcripts together (bytes parsed, a stand-in for the rows they hold): the least recently used go first.
+  maxTotalBytes: 384 * 1024 * 1024,
+});
+
+function parseLine(buf, collector) {
+  let text = buf.toString('utf-8');
+  if (text.endsWith('\r')) text = text.slice(0, -1);
+  if (!text.trim()) return true;
+  try { collector.add(JSON.parse(text)); return true; } catch { return false; }
+}
+
+/**
+ * Read `found.realPath` from `from` (an offset at a line start), feeding whole
+ * lines to `collector`. With `expectTail`, the first bytes read must equal it
+ * (the bytes before the old end); otherwise nothing is added and `null` is
+ * returned. Returns `{ offset, tail }`: where the next read starts, and the
+ * bytes before it.
+ */
+async function readFrom(found, collector, { from = 0, expectTail = null, open }) {
+  const skip = expectTail ? expectTail.length : 0;
+  const stream = open(found.realFolder, found.realPath, { start: Math.max(0, from - skip) });
+  let head = skip ? Buffer.alloc(0) : null; // collects the bytes to compare
+  let carry = Buffer.alloc(0);
+  let offset = from;
+  let tail = expectTail || Buffer.alloc(0);
+  let fileHead = from === 0 ? Buffer.alloc(0) : null; // the first bytes of the file, taken on a read from the start
+  const consumed = (bytes) => {
+    if (fileHead && fileHead.length < HEAD_BYTES) fileHead = Buffer.concat([fileHead, bytes.subarray(0, HEAD_BYTES - fileHead.length)]);
+    offset += bytes.length;
+    tail = Buffer.concat([tail, bytes.subarray(Math.max(0, bytes.length - TAIL_BYTES))]);
+    if (tail.length > TAIL_BYTES) tail = tail.subarray(tail.length - TAIL_BYTES);
+  };
+  try {
+    for await (const raw of stream) {
+      let chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(String(raw), 'utf-8');
+      if (head) {
+        const need = skip - head.length;
+        head = Buffer.concat([head, chunk.subarray(0, need)]);
+        chunk = chunk.subarray(need);
+        if (head.length < skip) continue;
+        if (!head.equals(expectTail)) return null; // the file changed under what was read
+        head = null;
+      }
+      let data = carry.length ? Buffer.concat([carry, chunk]) : chunk;
+      let start = 0;
+      let index;
+      while ((index = data.indexOf(NEWLINE, start)) !== -1) {
+        parseLine(data.subarray(start, index), collector);
+        consumed(data.subarray(start, index + 1));
+        start = index + 1;
+      }
+      carry = Buffer.from(data.subarray(start));
+    }
+  } finally {
+    stream.destroy?.();
+  }
+  if (head) return null; // the file ends before the bytes that were read last time
+  // A last line without its newline: taken when it is whole JSON already, else read next time.
+  if (carry.length && parseLine(carry, collector)) consumed(carry);
+  return { offset, tail, head: fileHead };
+}
+
+/** The first `length` bytes of the file, or less when it is shorter. */
+async function readHead(found, length, open) {
+  if (!length) return Buffer.alloc(0);
+  const stream = open(found.realFolder, found.realPath, { start: 0, end: length - 1 });
+  const parts = [];
+  let got = 0;
+  try {
+    for await (const raw of stream) {
+      const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(String(raw), 'utf-8');
+      parts.push(chunk); got += chunk.length;
+      if (got >= length) break;
+    }
+  } finally { stream.destroy?.(); }
+  return Buffer.concat(parts).subarray(0, length);
+}
+
+/**
+ * @param o.open     (folder, file, options) => readable stream (openConfinedStream)
+ * @param o.stat     (path) => fs.Stats
+ * @param o.newCollector () => a history collector (lib/claude-history.js)
+ */
+export function createHistoryCache({
+  open = openConfinedStream,
+  stat = statSync,
+  newCollector = createHistoryCollector,
+  now = Date.now,
+  limits = HISTORY_CACHE_LIMITS,
+} = {}) {
+  const entries = new Map(); // realPath → { dev, ino, size, mtimeMs, offset, tail, collector, usedAt }
+  const running = new Map(); // realPath → promise of the collector being brought up to date
+  const stats = { fresh: 0, appended: 0, reused: 0, reread: 0 };
+
+  const evict = (keep = null) => {
+    const at = now();
+    for (const [key, entry] of entries) if (key !== keep && at - entry.usedAt > limits.maxIdleMs) entries.delete(key);
+    while (entries.size > limits.maxEntries) entries.delete(entries.keys().next().value);
+    const maxTotal = limits.maxTotalBytes ?? Infinity;
+    let total = 0;
+    for (const entry of entries.values()) total += entry.offset;
+    for (const [key, entry] of entries) { // oldest first
+      if (total <= maxTotal) break;
+      entries.delete(key); total -= entry.offset;
+    }
+  };
+  const touch = (key, entry) => {
+    entry.usedAt = now();
+    entries.delete(key); entries.set(key, entry); // most recently used last
+    evict(key);
+  };
+  // Kept only while it fits: a transcript that grew past the limit is answered this once, then dropped.
+  const fits = (size) => size <= limits.maxCachedBytes;
+
+  async function update(found) {
+    const key = found.realPath;
+    evict(); // an idle entry goes before it could be reused
+    const st = stat(key);
+    let entry = entries.get(key) || null;
+    if (entry && (entry.dev !== st.dev || entry.ino !== st.ino || st.size < entry.offset)) entry = null;
+    if (entry && st.size === entry.size && st.mtimeMs === entry.mtimeMs) {
+      stats.reused++;
+      touch(key, entry);
+      return entry.collector;
+    }
+    // Changed without growing (same size with a new time, an edit in place): nothing tells what changed.
+    if (entry && st.size <= entry.size) { stats.reread++; entry = null; }
+    if (entry) {
+      let read = null;
+      const head = entry.head.length ? await readHead(found, entry.head.length, open) : entry.head;
+      if (head.equals(entry.head)) {
+        read = await readFrom(found, entry.collector, { from: entry.offset, expectTail: entry.offset ? entry.tail : null, open });
+      }
+      if (read) {
+        stats.appended++;
+        Object.assign(entry, { size: st.size, mtimeMs: st.mtimeMs, offset: read.offset, tail: read.tail });
+        if (fits(st.size)) touch(key, entry); else entries.delete(key);
+        return entry.collector;
+      }
+      stats.reread++;
+    }
+    entries.delete(key);
+    const collector = newCollector();
+    const read = await readFrom(found, collector, { from: 0, open });
+    stats.fresh++;
+    if (read && fits(st.size)) {
+      entries.set(key, { dev: st.dev, ino: st.ino, size: st.size, mtimeMs: st.mtimeMs, offset: read.offset, tail: read.tail, head: read.head, collector, usedAt: now() });
+      evict(key);
+    }
+    return collector;
+  }
+
+  return {
+    /** The collector of the transcript `found` names, with every whole line it holds now. */
+    async collectorFor(found) {
+      const key = found?.realPath;
+      if (!key || !found.realFolder) throw new Error('A checked transcript path is required.');
+      // One read per file at a time: a second request waits for it and then checks again.
+      while (running.has(key)) { try { await running.get(key); } catch {} }
+      const job = update(found);
+      running.set(key, job);
+      try { return await job; } catch (err) { entries.delete(key); throw err; } finally { if (running.get(key) === job) running.delete(key); }
+    },
+    forget(realPath) { entries.delete(realPath); },
+    /** Drop every kept transcript of a session (its file is `<sessionId>.jsonl`, in any project folder). */
+    forgetSession(sessionId) {
+      if (typeof sessionId !== 'string' || !sessionId) return 0;
+      let dropped = 0;
+      for (const key of [...entries.keys()]) {
+        const name = key.split(/[\\/]/).pop();
+        if (name === `${sessionId}.jsonl`) { entries.delete(key); dropped++; }
+      }
+      return dropped;
+    },
+    clear() { entries.clear(); },
+    get size() { return entries.size; },
+    get stats() { return { ...stats }; },
+  };
+}

package/neural-interface/lib/claude-hooks-status.js

@@ -0,0 +1,103 @@
+// ═══════════════════════════════════════════
+// SynaBun — the real state of SynaBun's Claude Code hooks (Settings → Automations)
+// ═══════════════════════════════════════════
+//
+// What GET /api/claude-code/integrations reports as `claudeHooks`, read from the files Claude Code itself reads:
+// the user's ~/.claude/settings.json (SynaBun's handlers live there), the managed settings an organization may
+// install, and the registered projects' .claude/settings.json and settings.local.json. It answers "would a Claude
+// Code session the owner starts by themselves run SynaBun's hooks?", which a count of entries alone does not:
+//   • Claude Code's own switches: disableAllHooks (any scope) runs no hook at all; allowManagedHooksOnly (managed
+//     settings) runs none of the user's or a project's;
+//   • a project whose SynaBun handlers differ from the user's: Claude Code runs one copy of identical handlers from
+//     both files and both copies of different ones (every hook twice: the 2026-09-15 bug);
+//   • macOS / Linux: a Claude Code started from the Dock, Finder, a desktop app or launchd has no login PATH. The
+//     handlers then look for Node in the usual folders and SYNABUN_NODE (lib/claude-hooks.js); `node: null` says
+//     such a launch would find none.
+// Pure apart from the file reads, which are injected (tests drive it with an in-memory tree).
+
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { hookInstallBlocker, hookInstallState, hookNodeWithoutPath, hooksSwitchedOff, managedClaudeSettingsPath, projectHooksAgree } from '../../lib/claude-hooks.js';
+import { packagedRuntime } from '../../lib/packaged-runtime.js';
+
+/** Bumped when the shape changes; the page shows the hooks' state only from a server that sends one. */
+export const CLAUDE_HOOKS_STATUS_VERSION = 1;
+
+/** A settings file: { settings } (parsed), { missing: true }, or { error } (it exists and cannot be read or parsed: why). */
+export function readSettingsFile(path, { read = (p) => readFileSync(p, 'utf8'), exists = existsSync } = {}) {
+  try {
+    if (!path || !exists(path)) return { missing: true };
+  } catch { return { missing: true }; }
+  let raw;
+  try { raw = read(path); } catch (error) { return { error: String(error?.code || error?.message || error) }; }
+  try {
+    const settings = JSON.parse(raw);
+    return settings && typeof settings === 'object' && !Array.isArray(settings) ? { settings } : { error: 'not a JSON object' };
+  } catch (error) { return { error: `not valid JSON: ${error?.message || error}` }; }
+}
+
+/**
+ * @param {object} o
+ * @param {string} o.userPath the user's ~/.claude/settings.json
+ * @param {Array<{path:string,label?:string}>} [o.projects] the registered projects
+ * @param {string} [o.managedPath] managed settings (managedClaudeSettingsPath)
+ * @param {string} [o.platform]
+ * @param {object|null} [o.runtime] lib/packaged-runtime.js packagedRuntime()
+ * @param {(path:string) => string} [o.read] @param {(path:string) => boolean} [o.exists]
+ * @param {(path:string) => boolean} [o.runnable] a file Node could be started from (tests)
+ * @param {string} [o.home]
+ */
+export function claudeHooksStatus({ userPath, projects = [], managedPath = managedClaudeSettingsPath(), platform = process.platform, runtime = packagedRuntime(), read, exists, runnable, home = homedir() } = {}) {
+  const io = { ...(read ? { read } : {}), ...(exists ? { exists } : {}) };
+  const base = { version: CLAUDE_HOOKS_STATUS_VERSION, settingsPath: userPath || null, installBlocker: hookInstallBlocker(runtime) };
+  const user = readSettingsFile(userPath, io);
+  if (user.error) return { ...base, state: 'error', error: user.error, installed: 0, current: 0, duplicates: 0, total: 0, events: {}, blockedBy: null, projects: [], node: null, nodeMissing: false, needsRepair: false };
+  const settings = user.settings || {};
+  const install = hookInstallState(settings, { runtime, platform });
+  const state = install.installed === 0 ? 'off' : install.installed === install.total ? 'on' : 'partial';
+
+  // Claude Code's own switches. Managed settings first: nothing below them can turn hooks back on.
+  let blockedBy = null;
+  const managed = readSettingsFile(managedPath, io);
+  const managedSwitch = hooksSwitchedOff(managed.settings, { managed: true });
+  if (managedSwitch) blockedBy = { setting: managedSwitch, scope: 'managed', path: managedPath };
+  else {
+    const userSwitch = hooksSwitchedOff(settings);
+    if (userSwitch) blockedBy = { setting: userSwitch, scope: 'user', path: userPath };
+  }
+
+  // The registered projects: hooks switched off there, or SynaBun handlers that would run next to the user's.
+  const projectIssues = [];
+  for (const project of Array.isArray(projects) ? projects : []) {
+    if (!project?.path) continue;
+    for (const name of ['settings.json', 'settings.local.json']) {
+      const file = join(project.path, '.claude', name);
+      const found = readSettingsFile(file, io);
+      if (!found.settings) continue;
+      let issue = hooksSwitchedOff(found.settings) ? 'disableAllHooks' : projectHooksAgree(settings, found.settings) === 'different' ? 'different' : null;
+      // Off for the user, still on there: that project's sessions keep running them.
+      if (!issue && install.installed === 0 && hookInstallState(found.settings, { targetProjectPath: project.path, runtime, platform }).installed > 0) issue = 'project-only';
+      if (issue) projectIssues.push({ path: project.path, label: project.label || null, file, issue });
+    }
+  }
+
+  // Asked of the packaged application too: its entry finds its own Node, so the answer is only shown for the others.
+  const node = platform === 'win32' || runtime ? null : hookNodeWithoutPath({ env: settings.env || {}, home, platform, ...(runnable ? { runnable } : {}) });
+  const nodeMissing = install.installed > 0 && platform !== 'win32' && !runtime && !node;
+  return {
+    ...base,
+    state,
+    installed: install.installed,
+    current: install.current,
+    duplicates: install.duplicates,
+    total: install.total,
+    events: install.events,
+    blockedBy,
+    projects: projectIssues,
+    node,
+    nodeMissing,
+    // What turning the hooks on again would put right: an old command form, an extra copy, a project out of step.
+    needsRepair: install.installed > 0 && (install.current < install.installed || install.duplicates > 0 || projectIssues.some((p) => p.issue === 'different') || nodeMissing),
+  };
+}

package/neural-interface/lib/claude-model-catalog.js

@@ -324,7 +324,7 @@ export function queryClaudeCliModels(claudeBin, { cwd, timeoutMs = DISCOVERY_TIM
 // re-discovers. A list that is merely old is still given at once, and the CLI is
 // asked again in the background (one discovery at a time): only a first read, a
 // changed key or `force` waits for the CLI.
-export async function discoverClaudeModels(claudeBin, { force = false, cwd, query = queryClaudeCliModels, account = '' } = {}) {
+export async function discoverClaudeModels(claudeBin, { force = false, nonBlocking = false, cwd, query = queryClaudeCliModels, account = '' } = {}) {
   const bin = String(claudeBin || '');
   const key = cacheKeyOf(bin, account);
   adoptStoredModels(key);
@@ -333,6 +333,10 @@ export async function discoverClaudeModels(claudeBin, { force = false, cwd, quer
     if (Date.now() - _cache.at >= CACHE_TTL_MS) discover(bin, key, cwd, query).catch(() => {});
     return { source: 'cache', models: _cache.models };
   }
+  if (!force && nonBlocking) {
+    discover(bin, key, cwd, query).catch(() => {});
+    return { source: 'fallback', models: [...CLAUDE_FALLBACK_MODELS] };
+  }
   return discover(bin, key, cwd, query);
 }
 

package/neural-interface/lib/claude-temporary.js

@@ -49,7 +49,7 @@ const READ_TOOLS = new Set([
 ]);
 // One tool, both: the actions that only read. Any other action is refused, an
 // action nobody listed included. `''` is the tool's own default action.
-// (`profile`: `set` writes the runtime's profile, to a file and to the server.)
+// (`tool_groups`: `add` / `set` write the runtime list, to a file and to the server.)
 const READ_ACTIONS = Object.freeze({
   memories: new Set(['recent', 'stats', 'by-category', 'by-project', 'get', 'get-batch', 'history', 'context']),
   category: new Set(['list']),
@@ -57,7 +57,7 @@ const READ_ACTIONS = Object.freeze({
   fb_groups: new Set(['worklist', 'list', 'stats']),
   image_staged: new Set(['list']),
   morelogin: new Set(['status', 'list']),
-  profile: new Set(['get']),
+  tool_groups: new Set(['get']),
 });
 // Acting on the outside world through the browser, an API or the desktop: what
 // Bash and Edit do too. They leave what they do where they do it (a post, a
@@ -84,19 +84,13 @@ const ACT_TOOLS = new Set([
   'gsc_removals_cancel', 'gsc_screenshot', 'gsc_security_issues', 'gsc_settings', 'gsc_shopping', 'gsc_sitemap', 'gsc_users', 'gsc_videos_report',
   'youtube_analytics', 'youtube_channel', 'youtube_download', 'youtube_endscreen', 'youtube_metadata', 'youtube_navigate',
   'youtube_playlist', 'youtube_schedule', 'youtube_source', 'youtube_thumbnail',
-  'leonardo_browser_download', 'leonardo_browser_generate', 'leonardo_browser_library', 'leonardo_browser_navigate',
   'computer', 'computer_apps', 'computer_ax', 'computer_status',
   'git',
 ]);
 // An acting tool that also changes one of SynaBun's stores unless it is told
-// not to: allowed with that input only. (`leonardo_browser_reference` deletes
-// the staged images it uploaded from SynaBun's image store by default.)
-const ACT_WHEN = Object.freeze({
-  leonardo_browser_reference: {
-    ok: (input) => input?.autoClear === false,
-    why: 'it removes the staged images from SynaBun\'s store unless it is called with autoClear: false',
-  },
-});
+// not to: allowed with that input only, as `{ ok: (input) => boolean, why }`.
+// No tool of the server needs one today.
+const ACT_WHEN = Object.freeze({});
 // Why a storing tool that looks like an acting one is off.
 const STORE_REASONS = Object.freeze({
   youtube_upload: 'it records every upload as a memory',

package/neural-interface/lib/cli-install-api.js

@@ -24,7 +24,7 @@ import { Router } from 'express';
 import { guestForbidden, noStore, requireLocal, requireLocalHost, requireSameOriginJson, sendGuardError, uiOnly } from './http-guards.js';
 import { openNdjsonStream } from './whatsapp/api.js';
 
-export const INSTALLABLE_TOOLS = Object.freeze(['claude-code', 'codex', 'opencode']);
+export const INSTALLABLE_TOOLS = Object.freeze(['claude-code', 'codex', 'opencode', 'antigravity']);
 
 /**
  * @param {object} deps