synabun 2.0.9 → 2.0.10

package/neural-interface/lib/opencode-db-schema.js

@@ -0,0 +1,75 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// Which OpenCode database SynaBun is reading.
+//
+// SynaBun reads OpenCode's own SQLite database ($XDG_DATA_HOME/opencode/
+// opencode.db) for the session lists of every registered project and for the
+// Resume cache. OpenCode 1 keeps sessions in `session` / `message` / `part`;
+// OpenCode 2 keeps them in `session_v2` / `session_message`, in the same file.
+// An OpenCode 2 that opened an OpenCode 1 database copies its sessions into
+// `session_v2` and leaves the old tables behind, frozen: read by OpenCode 1's
+// queries they would show yesterday's sessions and none of today's. So the
+// tables are picked by the OpenCode SynaBun talks to, and by what the file has.
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** The table names of an open node:sqlite database, or an empty set. */
+export function tableNamesOf(db) {
+  try {
+    return new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => String(row?.name || '')));
+  } catch {
+    return new Set();
+  }
+}
+
+/**
+ * 'v2' (OpenCode 2's tables), 'v1' (OpenCode 1's) or null (neither). `protocol`
+ * is the major SynaBun talks to (1, 2, or null when it is not known): with 2,
+ * OpenCode 2's tables are read when the file has them; with 1, OpenCode 1's;
+ * not known, OpenCode 2's when there are any.
+ */
+export function opencodeDbFlavor(db, protocol = null) {
+  if (!db) return null;
+  const tables = tableNamesOf(db);
+  const v2 = tables.has('session_v2') && tables.has('session_message');
+  const v1 = tables.has('session') && tables.has('message');
+  if (protocol === 1) return v1 ? 'v1' : null;
+  if (protocol === 2) return v2 ? 'v2' : null;
+  if (v2) return 'v2';
+  return v1 ? 'v1' : null;
+}
+
+/** The session table and the message-count expression (`s` is the session row) of a flavor. */
+export function sessionTablesFor(flavor) {
+  if (flavor === 'v2') {
+    return {
+      session: 'session_v2',
+      messageCount: "(SELECT COUNT(*) FROM session_message m WHERE m.session_id = s.id AND m.type IN ('user', 'assistant'))",
+    };
+  }
+  return { session: 'session', messageCount: '(SELECT COUNT(*) FROM message m WHERE m.session_id = s.id)' };
+}
+
+/**
+ * The visible text of one OpenCode 2 `session_message` row (its `type` and
+ * JSON `data`) as `{ role, text }`, or null for a row without any (a switch, an
+ * idle marker, a tool-only step).
+ */
+export function v2MessageText(type, data) {
+  let body = data;
+  if (typeof data === 'string') {
+    try { body = JSON.parse(data); } catch { return null; }
+  }
+  if (!body || typeof body !== 'object') return null;
+  if (type === 'user') {
+    const text = typeof body.text === 'string' ? body.text : '';
+    return text ? { role: 'user', text } : null;
+  }
+  if (type === 'assistant') {
+    const text = (Array.isArray(body.content) ? body.content : [])
+      .filter((item) => item?.type === 'text' && typeof item.text === 'string')
+      .map((item) => item.text)
+      .join('\n')
+      .trim();
+    return text ? { role: 'assistant', text } : null;
+  }
+  return null;
+}

package/neural-interface/lib/opencode-history.js

@@ -15,6 +15,13 @@ import { isMainThread, parentPort, Worker, workerData } from 'node:worker_thread
 
 export const OPENCODE_HISTORY_CONFIRMATION = 'DELETE OPENCODE HISTORY';
 
+// OpenCode 2 keeps its sessions in other tables of the same file (session_v2,
+// session_message, its event log): the OpenCode 1 list below would delete its
+// messages and events and leave its sessions, which breaks that database. So an
+// OpenCode 2 database is never cleared here.
+export const OPENCODE2_HISTORY_REFUSAL = 'This OpenCode data belongs to OpenCode 2, whose history SynaBun does not clear. Delete OpenCode 2 sessions from OpenCode itself.';
+const isOpencode2Database = (tables) => tables.has('session_v2');
+
 const HISTORY_TABLES_CHILD_FIRST = [
   'part',
   'message',
@@ -111,7 +118,14 @@ export function getOpenCodeHistoryStats({ dbPath, dataRoot = dirname(dbPath) })
     db = new DatabaseSync(database, { readOnly: true });
     db.exec('PRAGMA busy_timeout = 2000');
     const tables = tableNames(db);
-    stats.sessions = countRows(db, 'session', tables);
+    if (isOpencode2Database(tables)) {
+      stats.sessions = countRows(db, 'session_v2', tables);
+      stats.opencode2 = true;
+      stats.clearable = false;
+      stats.reason = OPENCODE2_HISTORY_REFUSAL;
+    } else {
+      stats.sessions = countRows(db, 'session', tables);
+    }
   } finally {
     try { db?.close(); } catch {}
   }
@@ -174,6 +188,7 @@ export function clearOpenCodeHistory({ dbPath, dataRoot = dirname(dbPath), vacuu
       db.exec('PRAGMA foreign_keys = ON');
       db.exec('PRAGMA busy_timeout = 10000');
       const tables = tableNames(db);
+      if (isOpencode2Database(tables)) throw new Error(OPENCODE2_HISTORY_REFUSAL);
       result.sessionsDeleted = countRows(db, 'session', tables);
       result.messagesDeleted = countRows(db, 'message', tables);
       result.partsDeleted = countRows(db, 'part', tables);

package/neural-interface/lib/opencode-protocol.js

@@ -0,0 +1,173 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// Which OpenCode SynaBun talks to, and how to know it is really there.
+//
+// OpenCode 1 and OpenCode 2 are different servers behind the same
+// `opencode serve`:
+//   • OpenCode 1 (`opencode --version` → "1.18.34"): its API at the root
+//     (/global/health, /session, /global/event, …), no password.
+//   • OpenCode 2 (→ "opencode v2.0.32"): its API under /api/*, HTTP Basic auth
+//     (user `opencode`) with a password set per launch (OPENCODE_PASSWORD,
+//     which OpenCode keeps out of its children's environment); every other
+//     path is its web app, an HTML page with status 200.
+// SynaBun reads the major version of the binary it is about to start (the CLI
+// resolver's cached `--version`, keyed by the file, so an upgrade in place is
+// read again), starts it the way that version wants, and calls a serve healthy
+// only when the right API answers JSON: an HTML page never passes.
+// ─────────────────────────────────────────────────────────────────────────────
+
+import { randomBytes } from 'node:crypto';
+
+/** Protocols SynaBun speaks, by the OpenCode major version that serves them. */
+export const OPENCODE_PROTOCOLS = Object.freeze({ 1: 'opencode1', 2: 'opencode2' });
+export const OPENCODE2_USERNAME = 'opencode';
+
+/** "1.18.34", "opencode v2.0.32", "v1.19.3" → 1 / 2; null when no version can be read. */
+export function opencodeMajorOf(version) {
+  const match = String(version ?? '').match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  const major = Number(match[1]);
+  return Number.isFinite(major) ? major : null;
+}
+
+/**
+ * The protocol for a version string: `{ protocol: 1 | 2 | null, major,
+ * version, supported, reason }`. OpenCode 0.x is the 1.x API's predecessor and
+ * speaks it; a major SynaBun does not know is refused with a sentence, never
+ * guessed at.
+ */
+export function protocolForVersion(version) {
+  const major = opencodeMajorOf(version);
+  const text = version ? String(version).trim() : '';
+  if (major == null) {
+    return { protocol: null, major: null, version: text || null, supported: false, reason: text ? `SynaBun cannot read the OpenCode version "${text}".` : 'SynaBun could not read the OpenCode version.' };
+  }
+  if (major <= 1) return { protocol: 1, major, version: text, supported: true, reason: null };
+  if (major === 2) return { protocol: 2, major, version: text, supported: true, reason: null };
+  return { protocol: null, major, version: text, supported: false, reason: `OpenCode ${major} (${text}) is newer than SynaBun supports: SynaBun works with OpenCode 1 and OpenCode 2.` };
+}
+
+/** A fresh password for one OpenCode 2 launch. */
+export function newServePassword() {
+  return randomBytes(24).toString('base64url');
+}
+
+/** The Authorization header for an OpenCode 2 serve. */
+export function basicAuthHeader(password, username = OPENCODE2_USERNAME) {
+  return `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`;
+}
+
+/**
+ * The arguments and environment of `opencode serve` on `port` for a protocol.
+ * OpenCode 1 keeps exactly what SynaBun always ran (`serve --port N`); OpenCode
+ * 2 also gets its loopback host name and the launch's password (OPENCODE_PASSWORD;
+ * any OPENCODE_SERVER_PASSWORD the environment carries is dropped, so the
+ * password SynaBun holds is the one the serve checks). A version SynaBun could
+ * not read (`protocol` null: a command line in Settings) starts like OpenCode
+ * 2: OpenCode 1 ignores OPENCODE_PASSWORD and takes --hostname too, and the
+ * health check then says which one answered.
+ */
+export function serveSpecFor(protocol, port, { env = process.env, password = null } = {}) {
+  const args = ['serve', '--port', String(port)];
+  if (protocol === 1) return { args, env, password: null };
+  const pass = password || newServePassword();
+  const next = { ...env, OPENCODE_PASSWORD: pass };
+  delete next.OPENCODE_SERVER_PASSWORD;
+  return { args: [...args, '--hostname', '127.0.0.1'], env: next, password: pass };
+}
+
+function isJsonResponse(res) {
+  return /\bapplication\/json\b/i.test(String(res?.headers?.get?.('content-type') || ''));
+}
+
+async function readJson(res) {
+  if (!isJsonResponse(res)) return { json: null, html: /text\/html/i.test(String(res?.headers?.get?.('content-type') || '')) };
+  try { return { json: await res.json(), html: false }; } catch { return { json: null, html: false }; }
+}
+
+/**
+ * Is a real OpenCode API answering on `port`? `protocol` 1 asks
+ * /global/health, 2 asks /api/info with `password`; `protocol` null asks both
+ * (an unknown serve: which one is it?). Resolves
+ * `{ ok, protocol, version, state, error }`, where `state` is
+ *   'healthy'  the protocol's API answered JSON
+ *   'locked'   an OpenCode 2 serve whose password SynaBun does not hold
+ *   'mismatch' an OpenCode of the other major answered
+ *   'html'     a web page (OpenCode 2's app, or anything else) — never healthy
+ *   'down'     nothing answered
+ *   'error'    something answered, but not an OpenCode API
+ * Never throws.
+ */
+export async function checkOpencodeServer({ port, protocol = null, password = null, fetchImpl = globalThis.fetch, timeoutMs = 2000, host = '127.0.0.1' } = {}) {
+  const base = `http://${host}:${port}`;
+  const get = async (path, headers = {}) => {
+    try {
+      return await fetchImpl(`${base}${path}`, { headers: { accept: 'application/json', ...headers }, signal: AbortSignal.timeout(timeoutMs) });
+    } catch (error) {
+      return { failed: true, error };
+    }
+  };
+  const asV1 = async () => {
+    const res = await get('/global/health');
+    if (res.failed) return { ok: false, protocol: 1, version: null, state: 'down', error: String(res.error?.message || res.error) };
+    const { json, html } = await readJson(res);
+    if (res.ok && json && (json.healthy === true || typeof json.version === 'string')) {
+      return { ok: true, protocol: 1, version: typeof json.version === 'string' ? json.version : null, state: 'healthy', error: null };
+    }
+    return { ok: false, protocol: 1, version: null, state: html ? 'html' : 'error', error: html ? 'answered with a web page, not the OpenCode 1 API' : `GET /global/health answered ${res.status}` };
+  };
+  const asV2 = async () => {
+    const res = await get('/api/info', password ? { authorization: basicAuthHeader(password) } : {});
+    if (res.failed) return { ok: false, protocol: 2, version: null, state: 'down', error: String(res.error?.message || res.error) };
+    const { json, html } = await readJson(res);
+    if (res.ok && json && typeof json.version === 'string' && Array.isArray(json.urls)) {
+      return { ok: true, protocol: 2, version: json.version, state: 'healthy', error: null };
+    }
+    if (res.status === 401 && json && /unauthori[sz]ed/i.test(String(json._tag || json.name || ''))) {
+      return { ok: false, protocol: 2, version: null, state: 'locked', error: password ? 'the OpenCode 2 serve refused SynaBun\'s password' : 'an OpenCode 2 serve SynaBun did not start (it needs that serve\'s password)' };
+    }
+    return { ok: false, protocol: 2, version: null, state: html ? 'html' : 'error', error: html ? 'answered with a web page, not the OpenCode 2 API' : `GET /api/info answered ${res.status}` };
+  };
+
+  if (protocol === 1) {
+    const v1 = await asV1();
+    if (v1.ok || v1.state === 'down') return v1;
+    // A web page where OpenCode 1 was expected: is it an OpenCode 2?
+    const v2 = await asV2();
+    if (v2.ok || v2.state === 'locked') return { ...v2, ok: false, state: 'mismatch', error: 'an OpenCode 2 serve answered where SynaBun expected OpenCode 1' };
+    return v1;
+  }
+  if (protocol === 2) {
+    const v2 = await asV2();
+    if (v2.ok || v2.state === 'down' || v2.state === 'locked') return v2;
+    const v1 = await asV1();
+    if (v1.ok) return { ...v1, ok: false, state: 'mismatch', error: 'an OpenCode 1 serve answered where SynaBun expected OpenCode 2' };
+    return v2;
+  }
+  const v1 = await asV1();
+  if (v1.ok || v1.state === 'down') return v1;
+  const v2 = await asV2();
+  return v2.ok || v2.state === 'locked' ? v2 : v1;
+}
+
+/**
+ * The sentence a person reads when OpenCode cannot be used: what was found and
+ * what to do. `check` is a checkOpencodeServer answer, `detected` a
+ * protocolForVersion answer.
+ */
+export function opencodeProblemText({ check = null, detected = null, port = null } = {}) {
+  if (detected && !detected.supported) return detected.reason;
+  if (!check || check.ok) return '';
+  const where = port ? ` on port ${port}` : '';
+  switch (check.state) {
+    case 'locked':
+      return `An OpenCode 2 server SynaBun did not start is already running${where}, and SynaBun does not have its password. Stop that server (or free the port) and start OpenCode again from SynaBun.`;
+    case 'mismatch':
+      return `The OpenCode server${where} is not the version SynaBun found on this computer (${check.error}). Stop it and start OpenCode again from SynaBun.`;
+    case 'html':
+      return `Something${where} answers with a web page instead of the OpenCode API (${check.error}).`;
+    case 'down':
+      return `OpenCode is not answering${where}.`;
+    default:
+      return `OpenCode${where} did not answer as expected: ${check.error || 'unknown error'}.`;
+  }
+}

package/neural-interface/lib/opencode-provider-view.js

@@ -0,0 +1,81 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — OpenCode provider views
+// ═══════════════════════════════════════════
+// GET /api/opencode/providers/full answers with OpenCode's provider list,
+// `{ all, default, connected }`. `all` is the whole models.dev catalog (on a
+// typical install 231 providers and 9,069 models, about 7 MB of JSON) while a
+// model picker only ever lists the providers that are connected (two or three).
+// The compact view keeps those, with every field of their models a picker,
+// the context gauge, the composer or the Assistant's catalog reads, and leaves
+// out what none of them reads (credentials and request options included).
+// Pure: no I/O, so the route, the catalog's in-process read and the tests share it.
+
+const PROVIDER_FIELDS_LEFT_OUT = new Set(['env', 'options', 'key', 'npm', 'api']);
+const MODEL_FIELDS_LEFT_OUT = new Set(['options', 'headers', 'provider']);
+
+/** An answer of OpenCode's /provider: `{ all: [...] }` (an object; a web page or an error body is not one). */
+export function isProviderCatalog(data) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return false;
+  return Array.isArray(data.all) || (!!data.all && typeof data.all === 'object');
+}
+
+function providersOf(data) {
+  if (Array.isArray(data?.all)) return data.all;
+  return data?.all && typeof data.all === 'object' ? Object.values(data.all) : [];
+}
+
+function slimModel(model) {
+  if (!model || typeof model !== 'object') return model;
+  const out = {};
+  for (const [key, value] of Object.entries(model)) if (!MODEL_FIELDS_LEFT_OUT.has(key)) out[key] = value;
+  return out;
+}
+
+function slimProvider(provider) {
+  const out = {};
+  for (const [key, value] of Object.entries(provider || {})) {
+    if (PROVIDER_FIELDS_LEFT_OUT.has(key)) continue;
+    if (key === 'models') {
+      if (Array.isArray(value)) out.models = value.map(slimModel);
+      else if (value && typeof value === 'object') out.models = Object.fromEntries(Object.entries(value).map(([id, model]) => [id, slimModel(model)]));
+      else out.models = value;
+      continue;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+/**
+ * The providers a picker lists: the connected ones (every provider when the
+ * answer names none), in OpenCode's order, `default` and `connected` as given.
+ */
+export function compactProviderCatalog(data) {
+  if (!isProviderCatalog(data)) return null;
+  const connected = Array.isArray(data.connected) ? data.connected.map((entry) => String(entry && typeof entry === 'object' ? (entry.id || entry.name || '') : entry || '')).filter(Boolean) : null;
+  const wanted = connected ? new Set(connected) : null;
+  const all = providersOf(data).filter((provider) => provider?.id && (!wanted || wanted.has(String(provider.id)))).map(slimProvider);
+  return {
+    all,
+    default: data.default && typeof data.default === 'object' ? { ...data.default } : {},
+    ...(Array.isArray(data.connected) ? { connected: [...data.connected] } : {}),
+    // How many providers the whole catalog has (Settings → OpenCode says how many it hides).
+    total: providersOf(data).length,
+  };
+}
+
+/** What makes two answers the same list for a picker: connected providers, their model ids, the defaults, the catalog's size. */
+export function providerCatalogSignature(data) {
+  if (!isProviderCatalog(data)) return '';
+  const providers = providersOf(data);
+  const connected = Array.isArray(data.connected) ? data.connected.map(String) : null;
+  const listed = providers
+    .filter((provider) => provider?.id && (!connected || connected.includes(String(provider.id))))
+    .map((provider) => {
+      const models = Array.isArray(provider.models) ? provider.models.map((m) => m?.id || '') : Object.keys(provider.models || {});
+      return `${provider.id}:${models.join(',')}`;
+    });
+  let modelCount = 0;
+  for (const provider of providers) modelCount += Array.isArray(provider?.models) ? provider.models.length : Object.keys(provider?.models || {}).length;
+  return JSON.stringify([connected, listed, data.default || {}, providers.length, modelCount]);
+}

package/neural-interface/lib/opencode-runtime-config.js

@@ -3,16 +3,23 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 /** The browser-policy plugin (assistant-brains/opencode-browser-policy.js) as a file URL a serve can load. */
 export const OPENCODE_BROWSER_POLICY_PLUGIN = pathToFileURL(resolve(dirname(fileURLToPath(import.meta.url)), 'assistant-brains', 'opencode-browser-policy.js')).href;
+/** Its OpenCode 2 form: a plugin folder, listed under `plugins` (OpenCode 1 ignores that key). */
+export const OPENCODE2_BROWSER_POLICY_PLUGIN = pathToFileURL(resolve(dirname(fileURLToPath(import.meta.url)), 'assistant-brains', 'opencode2-browser-policy')).href;
 
 /**
  * An Assistant task run's serve config gets SynaBun's browser policy as a
- * plugin (`cwd`: the run's project, for the scripts it reads). The user's own
- * plugins stay; an earlier entry of ours is replaced. Returns `config`.
+ * plugin (`cwd`: the run's project, for the scripts it reads), for OpenCode 1
+ * (`plugin`) and OpenCode 2 (`plugins`). The user's own plugins stay; an
+ * earlier entry of ours is replaced. Returns `config`.
  */
 export function withOpenCodeBrowserPolicy(config, { cwd = null } = {}) {
+  const options = cwd ? { cwd: String(cwd) } : {};
   const plugins = (Array.isArray(config.plugin) ? config.plugin : []).filter((entry) => (Array.isArray(entry) ? entry[0] : entry) !== OPENCODE_BROWSER_POLICY_PLUGIN);
-  plugins.push([OPENCODE_BROWSER_POLICY_PLUGIN, cwd ? { cwd: String(cwd) } : {}]);
+  plugins.push([OPENCODE_BROWSER_POLICY_PLUGIN, options]);
   config.plugin = plugins;
+  const plugins2 = (Array.isArray(config.plugins) ? config.plugins : []).filter((entry) => (entry && typeof entry === 'object' ? entry.package : entry) !== OPENCODE2_BROWSER_POLICY_PLUGIN);
+  plugins2.push({ package: OPENCODE2_BROWSER_POLICY_PLUGIN, options });
+  config.plugins = plugins2;
   return config;
 }