synabun 1.3.0 → 2.0.0

package/neural-interface/public/shared/ocp-v2/ocp-v2-binding.js

@@ -0,0 +1,280 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// OpenCode V2 — the binding rule (no DOM)
+// A panel has one store, and that store is bound to one session at a time. Its
+// state object is rebound in place when the session changes and
+// store.getState() hands out that live object: after an `await`, `s.sessionId`,
+// `s.cwd`, the plan, the queue or the session info are those of whatever the
+// panel is on by then, not of the session the action started on.
+//
+// So every flow that waits (an await, a promise callback, a timer, a handler
+// that fires later) does this, and nothing else:
+//   const at = captureBinding(store);        // before the first await
+//   const res = await api.something({ sessionId: at.sessionId, cwd: at.cwd });
+//   if (!at.isCurrent()) return;             // the panel moved on: drop it
+// `at` is a frozen snapshot: what goes into a request, a file name or a
+// persistence key after the wait is read from it, never from the store.
+//
+// The identity is the store's `binding` revision (ocp-v2-state.js): it changes
+// on every rebinding, also when the panel leaves a session and comes back to it
+// (A → B → A is a new binding), and it is the same counter the recovery guards
+// in ocp-v2-rehydrate.js use. A stale continuation drops its result; where the
+// result is still worth something to the session it belongs to (a download, a
+// saved setting, a prompt that failed to send) the flow applies it to
+// `at.sessionId` explicitly, never to the store.
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** The store's binding identity (0 for a store that has none). */
+export function bindingOf(store) {
+  if (typeof store?.getBinding === 'function') return store.getBinding();
+  if (typeof store?.getRevisions === 'function') return store.getRevisions().binding || 0;
+  return 0;
+}
+
+const directoryOf = (s) => s.cwd || s.sessionInfo?.directory || null;
+
+// A frozen copy of plain data (objects and arrays, all the way down). What a
+// token carries is what the store held when it was captured: the store's own
+// objects are rebound and edited in place afterwards (session.updated merges
+// into sessionInfo, the model picker replaces the model), and a continuation
+// must neither see that nor be able to change the store through its token.
+function frozenCopy(value, seen = new Map()) {
+  if (value === null || typeof value !== 'object') return value;
+  if (seen.has(value)) return seen.get(value);
+  if (Array.isArray(value)) {
+    const out = [];
+    seen.set(value, out);
+    for (const item of value) out.push(frozenCopy(item, seen));
+    return Object.freeze(out);
+  }
+  const proto = Object.getPrototypeOf(value);
+  // Not plain data (a Map, a Date, a DOM node): nothing a snapshot should hold.
+  if (proto !== Object.prototype && proto !== null) return undefined;
+  const out = {};
+  seen.set(value, out);
+  for (const key of Object.keys(value)) out[key] = frozenCopy(value[key], seen);
+  return Object.freeze(out);
+}
+
+/**
+ * The binding the store has right now, with what a flow needs from it later.
+ *   sessionId    pin the token to this session instead of the one the store is
+ *                on (recovery is asked for a session by id): it is current only
+ *                while the store is on that session under this binding
+ *   isCurrent()  an extra veto, e.g. "this child panel is still the open one"
+ * Returns a frozen token:
+ *   binding, sessionId, cwd, directory (cwd, else the session's directory),
+ *   model, variant, agent, mode, mcpProfile, sessionInfo (model and
+ *   sessionInfo are frozen copies, nested objects included)
+ *   isCurrent()  the store is still on this binding
+ *   isStale()    the opposite
+ *   sameCwd()    the store's project directory is still the captured one
+ */
+export function captureBinding(store, { sessionId, isCurrent } = {}) {
+  const s = store.getState();
+  const binding = bindingOf(store);
+  const boundSessionId = sessionId === undefined ? (s.sessionId || null) : (sessionId || null);
+  const veto = typeof isCurrent === 'function' ? isCurrent : null;
+  const cwd = s.cwd || null;
+  const current = () => {
+    if (bindingOf(store) !== binding) return false;
+    if ((store.getState().sessionId || null) !== boundSessionId) return false;
+    if (!veto) return true;
+    try { return veto() === true; } catch { return false; }
+  };
+  return Object.freeze({
+    binding,
+    sessionId: boundSessionId,
+    cwd,
+    directory: directoryOf(s),
+    model: frozenCopy(s.model) || null,
+    variant: s.variant || null,
+    agent: s.agent || null,
+    mode: s.mode || null,
+    mcpProfile: s.mcpProfile || null,
+    sessionInfo: s.sessionInfo ? frozenCopy(s.sessionInfo) : null,
+    isCurrent: current,
+    isStale: () => !current(),
+    sameCwd: () => (store.getState().cwd || null) === cwd,
+  });
+}
+
+/** True for a token captureBinding made (a session id or nothing is not one). */
+export const isBindingToken = (value) => !!value && typeof value === 'object' && typeof value.isCurrent === 'function';
+
+/**
+ * Notices a rebinding from inside a store listener: `changed()` is true once
+ * per move. For a module that already subscribes and has to do something
+ * first when the binding changes (forget what belonged to the old one).
+ */
+export function trackBinding(store) {
+  let last = bindingOf(store);
+  return {
+    changed() {
+      const now = bindingOf(store);
+      if (now === last) return false;
+      last = now;
+      return true;
+    },
+  };
+}
+
+/**
+ * Calls `listener(token)` once for every rebinding of `store`, with the new
+ * binding. Returns the unsubscribe. For things that live across sessions (an
+ * overlay, a popover, a busy flag) and must be closed or reset when the panel
+ * moves.
+ */
+export function onRebind(store, listener) {
+  const tracker = trackBinding(store);
+  return store.subscribe(() => {
+    if (!tracker.changed()) return;
+    try { listener(captureBinding(store)); } catch (err) { console.warn('[ocp-v2-binding] rebind listener failed', err); }
+  });
+}
+
+/**
+ * "The latest one wins" for a view that asks again before the previous answer
+ * is back (a search per keystroke, a tab, a popover that re-renders): `begin()`
+ * returns `() => boolean`, true while no newer request began and nothing
+ * called `cancel()`.
+ */
+export function latestOnly() {
+  let seq = 0;
+  return {
+    begin() { const mine = ++seq; return () => mine === seq; },
+    cancel() { seq += 1; },
+  };
+}
+
+/**
+ * latestOnly for a list that is read again whenever its filters change (a
+ * search box, a "show archived" switch): `begin(filters)` returns
+ * `(filtersNow) => boolean`, true while no newer read began AND the filters
+ * are still the ones this read was asked with. A read that was overtaken, or
+ * whose filters changed while the next read is still scheduled, paints
+ * nothing: neither its rows nor its failure.
+ */
+export function latestFor() {
+  const reads = latestOnly();
+  const keyOf = (filters) => JSON.stringify(filters ?? null);
+  return {
+    begin(filters) {
+      const mine = reads.begin();
+      const key = keyOf(filters);
+      return (filtersNow) => mine() && keyOf(filtersNow) === key;
+    },
+    cancel() { reads.cancel(); },
+  };
+}
+
+/**
+ * Wraps a search so its answer is only handed out for the binding and the
+ * directory it was asked under. `search(query, { sessionId, cwd })` does the
+ * asking; the wrapper resolves its answer, or null when the store was rebound
+ * or `getCwd()` changed while it was out (rows of another session's project
+ * are never offered).
+ */
+export function searchOnBinding(store, getCwd, search) {
+  return async (query) => {
+    const at = captureBinding(store);
+    const cwd = getCwd();
+    const answer = await search(query, { sessionId: at.sessionId, cwd });
+    return at.isCurrent() && getCwd() === cwd ? answer : null;
+  };
+}
+
+/**
+ * A reader for a view that outlives a session (a popover, an overlay) and asks
+ * the server about the session on screen. `read(load, apply)`:
+ *   load(at)          asks, with the binding snapshot `at` for its parameters
+ *   apply(value, at)  paints, and runs only when this is still the latest read
+ *                     AND the store is still on the binding it was asked under
+ * Resolves true when `apply` ran. An answer for a session the panel has left
+ * (or left and came back to) is dropped, and so is its error.
+ */
+export function boundReader(store) {
+  const reads = latestOnly();
+  const read = async (load, apply) => {
+    const at = captureBinding(store);
+    const mine = reads.begin();
+    const fresh = () => mine() && at.isCurrent();
+    let value;
+    try { value = await load(at); } catch (err) {
+      if (fresh()) throw err;
+      return false;
+    }
+    if (!fresh()) return false;
+    apply(value, at);
+    return true;
+  };
+  read.cancel = () => reads.cancel();
+  return read;
+}
+
+// ── Navigation intents ───────────────────────────────────────────────────────
+// A binding token says "the panel is still on the session this started on". It
+// cannot tell two navigations apart while neither has bound anything yet: a
+// click on one tab that is still waiting for the panel to open, and a click on
+// another tab after it. Both were started on the same binding.
+//
+// So where the panel goes has an identity of its own. Every choice of the user
+// (a tab, a session in the menu, New session, another project, a new worktree)
+// begins an intent, and a navigation binds the panel only while its intent is
+// the latest one: after every wait it checks `isCurrent()`, and it binds
+// through `apply()`. A later choice always wins over an older one that is
+// still in flight. A rebinding nobody announced (the active tab was closed)
+// overtakes every intent that is still out.
+//
+//   const nav = navigation.begin();          // at the gesture, before any await
+//   await something();
+//   nav.apply(() => store.setSession(id));   // false, and not run, when overtaken
+//
+// `observe()` is for a navigation the panel starts by itself (boot, an
+// automation that asks for focus). It overtakes nothing, so a choice the user
+// made before it still stands, and it stands down for everything that happens
+// after it: a newer intent, and any rebinding it did not make itself.
+//
+// `repair()` is for a rebinding the panel has to make because the session on
+// screen is gone (the recovery found it deleted). It overtakes nothing either,
+// and stands down only when the panel was taken somewhere else: a choice that
+// has bound nothing yet does not leave the dead session on screen, and still
+// wins when it binds later.
+export function createNavigation(store) {
+  let latest = 0;                  // the newest intent
+  let moves = 0;                   // every rebinding of the store, whoever made it
+  let applying = 0;                // > 0 while a navigation applies its own rebinding
+  let seen = bindingOf(store);
+  const unsubscribe = store.subscribe(() => {
+    const now = bindingOf(store);
+    if (now === seen) return;
+    seen = now;
+    moves += 1;
+    if (!applying) latest += 1;    // bound by something that announced no intent
+  });
+  const token = (mine, observing, yields = true) => {
+    let ownMoves = moves;          // observing: the rebindings it has seen or made
+    const isCurrent = () => (!yields || mine === latest) && (!observing || moves === ownMoves);
+    return Object.freeze({
+      intent: mine,
+      // Where the panel was when the navigation began (what it leaves).
+      sessionId: store.getState().sessionId || null,
+      cwd: store.getState().cwd || null,
+      isCurrent,
+      isStale: () => !isCurrent(),
+      /** Runs `fn` (this navigation's own rebinding) only while it is current. */
+      apply(fn) {
+        if (!isCurrent()) return false;
+        applying += 1;
+        try { fn(); } finally { applying -= 1; seen = bindingOf(store); ownMoves = moves; }
+        return true;
+      },
+    });
+  };
+  return {
+    begin() { latest += 1; return token(latest, false); },
+    observe() { return token(latest, true); },
+    repair() { return token(latest, true, false); },
+    latest: () => latest,
+    destroy() { try { unsubscribe(); } catch { /* already gone */ } },
+  };
+}

package/neural-interface/public/shared/ocp-v2/ocp-v2-caps.js

@@ -0,0 +1,67 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// OpenCode V2 — what the connected server understands (no DOM, no socket)
+// Panel files are served statically and reload at any moment; server.js only
+// changes when SynaBun restarts. So the server lists its request types
+// (`capabilities` in init:result and after identify) and the panel shows a
+// feature that needs a newer type only while that type is listed. A server
+// that predates the list advertises nothing, and every gated feature stays
+// hidden instead of failing with "unknown message type".
+// ─────────────────────────────────────────────────────────────────────────────
+
+export const UNSUPPORTED_MESSAGE = 'Restart SynaBun to enable this: the running server predates it.';
+
+export function createCapabilities() {
+  let types = new Set();
+  const listeners = new Set();
+  const emit = () => {
+    for (const fn of listeners) {
+      try { fn(api); } catch (e) { console.warn('[ocp-v2-caps] listener error', e); }
+    }
+  };
+  const same = (next) => next.size === types.size && [...next].every((t) => types.has(t));
+  const api = {
+    /** Replace the list; anything that is not an array of strings clears it. */
+    set(list) {
+      const next = new Set((Array.isArray(list) ? list : []).filter((t) => typeof t === 'string' && t));
+      if (same(next)) return;
+      types = next;
+      emit();
+    },
+    clear() { api.set([]); },
+    has(type) { return types.has(type); },
+    hasAll(...needed) { return needed.every((t) => types.has(t)); },
+    list() { return [...types]; },
+    subscribe(fn) { listeners.add(fn); return () => listeners.delete(fn); },
+  };
+  return api;
+}
+
+/**
+ * Send `payload` only when the server lists its type; otherwise resolve the
+ * reply a failed request would have produced, without touching the socket.
+ */
+export function gatedRequest(caps, send, payload, timeoutMs) {
+  if (!caps.has(payload?.type)) {
+    return Promise.resolve({
+      type: `${payload?.type}:result`, ok: false, unsupported: true, status: 501, error: UNSUPPORTED_MESSAGE,
+    });
+  }
+  return send(payload, timeoutMs);
+}
+
+/** True when a reply is a failure: transport error, ok:false, or HTTP >= 400. */
+export function replyFailed(res) {
+  if (!res) return true;
+  if (res.type === 'error' || res.ok === false || res.error) return true;
+  return typeof res.status === 'number' && res.status >= 400;
+}
+
+export function replyError(res, fallback = 'Request failed') {
+  if (!res) return fallback;
+  const detail = res.error || res.data?.error || res.data?.message;
+  if (typeof detail === 'string' && detail) return detail;
+  if (detail && typeof detail === 'object') {
+    try { return JSON.stringify(detail); } catch { /* fall through */ }
+  }
+  return typeof res.status === 'number' && res.status >= 400 ? `${fallback} (HTTP ${res.status})` : fallback;
+}

package/neural-interface/public/shared/ocp-v2/ocp-v2-changes-logic.js

@@ -0,0 +1,179 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// OpenCode V2 — changes review, decisions (no DOM)
+// File diffs come from three places with one shape (SnapshotFileDiff):
+//   session.diff event / session:diff   what this session changed
+//   Session.summary                     the totals OpenCode keeps on the session
+//   vcs:diff                            the working tree against HEAD
+// `file` and `patch` are optional in the SDK, so everything is null-checked.
+// ─────────────────────────────────────────────────────────────────────────────
+
+const STATUS_MARKS = { added: 'A', deleted: 'D', modified: 'M' };
+
+export function normalizeFileDiffs(list) {
+  return (Array.isArray(list) ? list : [])
+    .filter((row) => row && typeof row === 'object')
+    .map((row) => ({
+      file: typeof row.file === 'string' && row.file ? row.file : '(unnamed file)',
+      patch: typeof row.patch === 'string' ? row.patch : '',
+      additions: Number(row.additions) || 0,
+      deletions: Number(row.deletions) || 0,
+      status: typeof row.status === 'string' ? row.status : 'modified',
+      mark: STATUS_MARKS[row.status] || 'M',
+      patchTruncated: row.patchTruncated === true,
+    }))
+    .sort((a, b) => a.file.localeCompare(b.file));
+}
+
+/** Totals for the changes bar: from the diffs when there are any, else from Session.summary. */
+export function changesSummary(diffs, sessionSummary) {
+  const rows = normalizeFileDiffs(diffs);
+  if (rows.length) {
+    return {
+      files: rows.length,
+      additions: rows.reduce((sum, row) => sum + row.additions, 0),
+      deletions: rows.reduce((sum, row) => sum + row.deletions, 0),
+    };
+  }
+  return {
+    files: Number(sessionSummary?.files) || 0,
+    additions: Number(sessionSummary?.additions) || 0,
+    deletions: Number(sessionSummary?.deletions) || 0,
+  };
+}
+
+/** `{ visible, label, stat }` for the bar above the composer. */
+export function changesBarView(state) {
+  const summary = changesSummary(state?.sessionDiff, state?.sessionInfo?.summary);
+  return {
+    visible: summary.files > 0,
+    label: `${summary.files} file${summary.files === 1 ? '' : 's'} changed`,
+    stat: `+${summary.additions} −${summary.deletions}`,
+    ...summary,
+  };
+}
+
+/** Which tabs the viewer offers. The session tab works from the event data alone. */
+export function changesTabs(supports = () => false) {
+  const tabs = [{ id: 'session', label: 'This session' }];
+  if (supports('vcs:diff')) tabs.push({ id: 'worktree', label: 'Working tree' });
+  return tabs;
+}
+
+// ── Worktrees ───────────────────────────────────────────────────────────────
+
+/**
+ * Watch one worktree creation from request to ready.
+ *
+ * Subscribe before asking OpenCode to create the worktree (worktree.ready can
+ * beat the reply), then call `identify(name)` with the name the reply carries.
+ * Until then events are kept, not acted on: `worktree.ready` names its
+ * worktree, so only the one for `name` counts, and another window's or
+ * project's creation finishing first changes nothing.
+ *
+ * The outcome is decided by that ready event and nothing else. `worktree.failed`
+ * carries a message and no name (1.18.34: `{ message }`), so a failure cannot
+ * be told apart from the failure of another creation on the same serve
+ * (another window, another project). It therefore never ends this creation:
+ * the message is kept, the wait goes on, and a ready for `name` still wins. If
+ * no ready arrives before `timeoutMs`, the last resort, the result says so and
+ * quotes the failure that was seen, as what it is: possibly this creation's,
+ * possibly not. What this costs: a creation that really failed is reported
+ * after the timeout instead of at once.
+ *
+ *   subscribe(listener)  raw event subscription, returns unsubscribe
+ *   returns { result, identify(name), cancel(error?) }
+ *   result resolves { ok: true } or { ok: false, error, failureSeen? }
+ */
+export function watchWorktree(subscribe, {
+  timeoutMs = 60_000, setTimer = setTimeout, clearTimer = clearTimeout,
+} = {}) {
+  let name = '';
+  let done = false;
+  let unsubscribe = () => {};
+  let timer = null;
+  let failure = '';                    // the last unattributable worktree.failed message
+  const readyNames = new Set();        // worktree.ready seen before identify()
+  let resolveResult;
+  const result = new Promise((resolve) => { resolveResult = resolve; });
+
+  const finish = (outcome) => {
+    if (done) return;
+    done = true;
+    if (timer) clearTimer(timer);
+    try { unsubscribe(); } catch { /* already gone */ }
+    resolveResult(outcome);
+  };
+
+  unsubscribe = subscribe((eventType, ev) => {
+    if (done) return;
+    if (eventType === 'worktree.ready') {
+      const readyName = typeof ev?.name === 'string' ? ev.name : '';
+      if (!readyName) return;
+      if (!name) readyNames.add(readyName);
+      else if (readyName === name) finish({ ok: true });
+    } else if (eventType === 'worktree.failed') {
+      failure = ev?.message || 'OpenCode could not prepare a worktree.';
+    }
+  });
+  timer = setTimer(() => finish(worktreeTimeoutOutcome(failure)), timeoutMs);
+
+  return {
+    result,
+    /** The create reply named the worktree: act on what was seen so far. */
+    identify(worktreeName) {
+      if (done || name) return;
+      name = String(worktreeName || '');
+      if (!name) { finish({ ok: false, error: 'OpenCode did not name the new worktree.' }); return; }
+      if (readyNames.has(name)) finish({ ok: true });
+    },
+    cancel(error = 'Worktree creation was cancelled.') { finish({ ok: false, error }); },
+  };
+}
+
+/** What the wait reports when no ready event for the worktree came in time. */
+export function worktreeTimeoutOutcome(failure) {
+  if (!failure) return { ok: false, error: 'The worktree was not ready in time.' };
+  return {
+    ok: false,
+    failureSeen: failure,
+    error: `The worktree was not ready in time. OpenCode reported a worktree failure meanwhile, which may or may not be this one (the report names no worktree): ${failure}`,
+  };
+}
+
+/**
+ * Wait for the worktree called `name` (already known) to be ready.
+ * Resolves { ok: true } on its worktree.ready, { ok: false, error } on a
+ * failure or after `timeoutMs`.
+ */
+export function waitForWorktree(subscribe, name, options = {}) {
+  const watch = watchWorktree(subscribe, options);
+  watch.identify(name);
+  return watch.result;
+}
+
+// ── New-session dialog ──────────────────────────────────────────────────────
+
+/**
+ * What "Save" in the new-session dialog does.
+ *   { project, branch, currentBranch, wantsWorktree, cwd }
+ * → { worktree, checkout, projectChanged }
+ * A session in a new worktree never touches the project's own checkout: the
+ * worktree is created from what the project has checked out now (OpenCode's
+ * worktree.create takes no base), so no branch is switched for it.
+ */
+export function newSessionPlan({ project = '', branch = '', currentBranch = '', wantsWorktree = false, cwd = '' } = {}) {
+  const worktree = !!wantsWorktree && !!project;
+  const switchBranch = !worktree && !!project && !!branch && !!currentBranch && branch !== currentBranch;
+  return {
+    worktree,
+    checkout: switchBranch ? { path: project, branch } : null,
+    projectChanged: !!project && project !== (cwd || ''),
+  };
+}
+
+/** The answer of POST /api/terminal/checkout as `{ ok, error }`. */
+export function checkoutOutcome(status, body) {
+  if (status >= 200 && status < 300 && body?.ok !== false && !body?.error) return { ok: true };
+  const detail = typeof body?.error === 'string' && body.error ? body.error : `HTTP ${status}`;
+  return { ok: false, error: `Could not switch branch: ${detail}` };
+}