synabun 2.0.10 → 2.1.0

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

@@ -6,6 +6,7 @@
 // listeners (used by the panel manager to spawn child panels).
 // ─────────────────────────────────────────────────────────────────────────────
 
+import { createOutcomeNotifications } from './ocp-v2-outcome-notifications.js';
 import { getDefaultStore } from './ocp-v2-state.js';
 import { notify as uiNotify, NOTIF_TYPE } from '../ui-notifications.js';
 import { nativeLoopWindowId } from '../ui-native-window-id.js';
@@ -20,24 +21,13 @@ import { createAskTracker, createTurnClock, readOpenAsks, unreadAsksNotice, TURN
 // predates the list; cleared on every disconnect and refilled on reconnect.
 export const capabilities = createCapabilities();
 export const supports = (...types) => capabilities.hasAll(...types);
-// The @opencode-ai/sdk version the server answered `init` with ('' from a
-// server that does not say).
-let _sdkVersion = '';
-export const sdkVersion = () => _sdkVersion;
 
 const _notifiedPermissionIds = new Set();
-// Per-store DONE/ERROR dedup: once an outcome fires for a turn, suppress
-// duplicates until the next time `running` flips back to true (new turn).
-// ERROR locks out future DONE; DONE allows a later ERROR through.
-const _outcomeKey = new WeakMap();        // store → NOTIF_TYPE.DONE | NOTIF_TYPE.ERROR
-const _outcomeSubscribed = new WeakSet(); // stores already wired for reset
+const _outcomes = createOutcomeNotifications();
 
 function _fireOutcomeNotify(store, type) {
-  const last = _outcomeKey.get(store);
-  if (last === type) return;
-  if (last === NOTIF_TYPE.ERROR && type === NOTIF_TYPE.DONE) return;
-  _outcomeKey.set(store, type);
   const s = store.getState();
+  if (!_outcomes.take(s, type === NOTIF_TYPE.ERROR ? 'error' : 'done')) return;
   const baseLabel = s.sessionInfo?.title || s.sessionInfo?.info?.title || 'OpenCode';
   const label = s.parentSessionId ? `↳ ${baseLabel}` : baseLabel;
   try {
@@ -45,18 +35,6 @@ function _fireOutcomeNotify(store, type) {
   } catch (err) { console.warn('[ocp-v2-ws] outcome notify failed', err); }
 }
 
-function _ensureOutcomeReset(store) {
-  if (_outcomeSubscribed.has(store)) return;
-  _outcomeSubscribed.add(store);
-  try {
-    store.subscribe((event, state) => {
-      if (event?.type === 'running:set' && state.running) {
-        _outcomeKey.delete(store);
-      }
-    });
-  } catch (err) { console.warn('[ocp-v2-ws] outcome subscribe failed', err); }
-}
-
 let _ws = null;
 let _connecting = null;
 let _reqSeq = 0;
@@ -146,7 +124,7 @@ function broadcastServerStatus(payload) {
 }
 
 // Why OpenCode cannot be used, as the server says it (an OpenCode version
-// SynaBun does not speak, a port held by an OpenCode 2 server it did not start,
+// SynaBun does not drive, a port held by an OpenCode server it did not start,
 // a web page where the API should be): one line in each panel's error list,
 // never a second copy of the same sentence while the panel keeps retrying.
 function broadcastServerProblem(text) {
@@ -173,7 +151,6 @@ export function disconnect() {
 export function subscribeSession(sessionId, store) {
   if (!store) return () => {};
   _allStores.add(store);
-  _ensureOutcomeReset(store);
   if (!sessionId) {
     // Not yet bound — caller should call again once a session exists.
     return () => { _allStores.delete(store); };
@@ -252,7 +229,6 @@ function handleMessage(msg) {
     p.timeout.cancel();
     if (msg.type === 'init:result') {
       capabilities.set(msg.capabilities);
-      if (typeof msg.sdkVersion === 'string') _sdkVersion = msg.sdkVersion;
       if (msg.ready === false && msg.problem) broadcastServerProblem(msg.problem);
       asksReady();
     }
@@ -382,7 +358,7 @@ export function isKnownDescendantSession(sessionId, ancestorId) {
 // ── What waits on the user, read from the server ───────────────────────────
 // The stream says what is asked and answered while the socket is up. What was asked before (the page loaded,
 // a panel was bound to another session, the socket was down) is read from the server (permission:list and
-// question:list, on OpenCode 1 and 2 alike), one session at a time: its clocks wait until then. After a
+// question:list), one session at a time: its clocks wait until then. After a
 // reconnect every bound session is read again (rebuildAsks). A list that cannot be read is read again a few
 // times; then the session's clocks count again and its panel says so (noteUnreadAsks).
 
@@ -663,17 +639,17 @@ export const api = {
   sessionMessages:(sessionId)     => request({ type: 'session:messages', sessionId }),
   sessionContext: ({ sessionId, cwd } = {}) => request({ type: 'session:context', sessionId, cwd }),
   // `human` / `greetingId`: lib/greeting/ (a server that does not know them ignores them).
-  send: ({ sessionId, parts, model, agent, mode, variant, cwd, mcpProfile, noAbortPrev, human, greetingId }) =>
-    request({ type: 'message:send', sessionId, parts, model, agent, mode, variant, cwd, mcpProfile, noAbortPrev: !!noAbortPrev, ...(human ? { human: true } : {}), ...(greetingId ? { greetingId } : {}) }, TURN_LIMIT_MS, { turnOf: sessionId }),
+  send: ({ sessionId, parts, model, agent, mode, variant, cwd, tools, noAbortPrev, human, greetingId }) =>
+    request({ type: 'message:send', sessionId, parts, model, agent, mode, variant, cwd, tools, noAbortPrev: !!noAbortPrev, ...(human ? { human: true } : {}), ...(greetingId ? { greetingId } : {}) }, TURN_LIMIT_MS, { turnOf: sessionId }),
   abort: (sessionId) => request({ type: 'message:abort', sessionId }),
-  compact: ({ sessionId, cwd, mcpProfile, model } = {}) => request({ type: 'session:compact', sessionId, cwd, mcpProfile, model }, 5 * 60 * 1000),
+  compact: ({ sessionId, cwd, tools } = {}) => request({ type: 'session:compact', sessionId, cwd, tools }, 5 * 60 * 1000),
   permissionReply: ({ sessionId, permissionId, response, cwd, message }) =>
     request({ type: 'permission:reply', sessionId, permissionId, response, cwd, message }),
   questionList:   ({ cwd, sessionId } = {})   => request({ type: 'question:list', cwd, sessionId }),
   questionReply:  ({ requestId, answers, cwd, sessionId }) => request({ type: 'question:reply', requestId, answers, cwd, sessionId }),
   questionReject: ({ requestId, sessionId })  => request({ type: 'question:reject', requestId, sessionId }),
-  mcpProfileGet:  (sessionId) => request({ type: 'mcp:profile:get', sessionId }),
-  mcpProfileSet:  (sessionId, profile) => request({ type: 'mcp:profile:set', sessionId, profile }, 45_000),
+  toolsGet:  (sessionId) => gated({ type: 'mcp:tools:get', sessionId }),
+  toolsSet:  (sessionId, tools) => gated({ type: 'mcp:tools:set', sessionId, tools }, 45_000),
 
   // ── Newer request types: sent only when the server lists them (see
   //    ocp-v2-caps.js); otherwise they resolve { ok:false, unsupported:true }.
@@ -684,16 +660,12 @@ export const api = {
   sessionUnrevert: ({ sessionId, cwd } = {}) => gated({ type: 'session:unrevert', sessionId, cwd }),
   sessionFork:     ({ sessionId, messageID, cwd } = {}) => gated({ type: 'session:fork', sessionId, messageID, cwd }),
   sessionChildren: ({ sessionId, cwd } = {}) => gated({ type: 'session:children', sessionId, cwd }),
-  sessionShare:    ({ sessionId, cwd } = {}) => gated({ type: 'session:share', sessionId, cwd }),
-  sessionUnshare:  ({ sessionId, cwd } = {}) => gated({ type: 'session:unshare', sessionId, cwd }),
-  sessionSharePolicy: ({ cwd } = {}) => gated({ type: 'session:share:policy', cwd }),
-  messageDelete:   ({ sessionId, messageID, cwd } = {}) => gated({ type: 'message:delete', sessionId, messageID, cwd }),
   commandList:     ({ cwd } = {}) => gated({ type: 'command:list', cwd }),
   // A command is a turn: it can run as long as a prompt does.
-  commandRun:      ({ sessionId, command, arguments: args, agent, model, variant, parts, cwd, mcpProfile } = {}) =>
-    gated({ type: 'command:run', sessionId, command, arguments: args, agent, model, variant, parts, cwd, mcpProfile }, TURN_LIMIT_MS, { turnOf: sessionId }),
-  sessionShell:    ({ sessionId, command, agent, model, cwd, mcpProfile } = {}) =>
-    gated({ type: 'session:shell', sessionId, command, agent, model, cwd, mcpProfile }, 10 * 60 * 1000),
+  commandRun:      ({ sessionId, command, arguments: args, agent, model, variant, parts, cwd, tools } = {}) =>
+    gated({ type: 'command:run', sessionId, command, arguments: args, agent, model, variant, parts, cwd, tools }, TURN_LIMIT_MS, { turnOf: sessionId }),
+  sessionShell:    ({ sessionId, command, agent, model, cwd, tools } = {}) =>
+    gated({ type: 'session:shell', sessionId, command, agent, model, cwd, tools }, 10 * 60 * 1000),
   findFiles:       ({ query, cwd, dirs } = {}) => gated({ type: 'find:files', query, cwd, dirs }, 10000),
   findSymbols:     ({ sessionId, query, cwd } = {}) => gated({ type: 'find:symbols', sessionId, query, cwd }, 10000),
   resourceList:    ({ sessionId, cwd } = {}) => gated({ type: 'resource:list', sessionId, cwd }, 15000),
@@ -703,14 +675,9 @@ export const api = {
   vcsGet:          ({ cwd } = {}) => gated({ type: 'vcs:get', cwd }),
   vcsStatus:       ({ cwd } = {}) => gated({ type: 'vcs:status', cwd }),
   vcsDiff:         ({ cwd, mode } = {}) => gated({ type: 'vcs:diff', cwd, mode }, 60_000),
-  worktreeList:    ({ cwd } = {}) => gated({ type: 'worktree:list', cwd }),
-  worktreeCreate:  ({ cwd, name } = {}) => gated({ type: 'worktree:create', cwd, name }, 60_000),
-  worktreeRemove:  ({ cwd, directory } = {}) => gated({ type: 'worktree:remove', cwd, directory }, 60_000),
   mcpStatus:       ({ sessionId, cwd } = {}) => gated({ type: 'mcp:status', sessionId, cwd }),
   mcpConnect:      ({ sessionId, name, cwd } = {}) => gated({ type: 'mcp:connect', sessionId, name, cwd }, 60_000),
   mcpDisconnect:   ({ sessionId, name, cwd } = {}) => gated({ type: 'mcp:disconnect', sessionId, name, cwd }, 60_000),
-  // OAuth: OpenCode opens the browser and waits for the callback.
-  mcpAuthenticate: ({ sessionId, name, cwd } = {}) => gated({ type: 'mcp:authenticate', sessionId, name, cwd }, 5 * 60 * 1000 + 5000),
   // Registers a server on the serve running this session and, with `persist`,
   // saves it to the OpenCode config in the same request (see ocp-v2-status.js).
   mcpAdd:          ({ sessionId, name, config, persist, cwd } = {}) => gated({ type: 'mcp:add', sessionId, name, config, persist: persist === true, cwd }, 60_000),

package/neural-interface/public/shared/page-session.js

@@ -0,0 +1,96 @@
+// ═══════════════════════════════════════════
+// SynaBun — the page secret's recovery: an open tab outlives a server restart
+// ═══════════════════════════════════════════
+//
+// The server tells the owner's own page from a local process by a secret it mints per boot and hands the page as
+// an HttpOnly cookie (lib/page-session.js). The page's code never sees or sends that cookie: the browser does. A
+// restart mints a new secret, and a tab that stayed open still carries the old cookie, so its first owner write
+// (a dispatch, Protect workers, a route card, a Skills Studio install…) would come back 403 UI_ONLY or
+// PAGE_SECRET_REQUIRED and the owner would have to reload. The owner wants zero friction, so this module wraps the
+// page's fetch once: when a same-origin write is refused with one of those two codes, it asks GET /api/page-session
+// (which sets this boot's cookie), then sends the very same request once more and hands back that answer. No
+// reload, no toast (the toast fires on the error jsonFetch throws, and it throws only on the final answer), no lost
+// action. Anything else (a read, another 403, a refusal the refresh did not cure, a body that cannot be sent
+// twice) is handed back as it came, so nothing changes for a request this is not about.
+//
+// No imports and nothing done at load under Node: tests load it with node --test and a fake fetch. In a browser it
+// installs itself on window.fetch when the page loads it (index.html, index2d.html and sidepanel-session.html load
+// it as their first module script, before any module that writes), and once only.
+
+/** The route that hands an open tab this boot's cookie (lib/page-session.js PAGE_SECRET_REFRESH_PATH). */
+export const PAGE_SECRET_REFRESH_PATH = '/api/page-session';
+/** The refusals that mean "the page secret is missing or stale", and nothing else. */
+export const PAGE_SECRET_CODES = Object.freeze(['UI_ONLY', 'PAGE_SECRET_REQUIRED']);
+const SAFE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+
+/** Whether an answer is the server refusing a write for want of this boot's page secret. */
+export function isPageSecretRefusal(status, body) {
+  return Number(status) === 403 && !!body && typeof body === 'object' && PAGE_SECRET_CODES.includes(body.code);
+}
+
+/**
+ * What a request is, for the retry: its method, whether it is same-origin, and the arguments that send it again,
+ * or null when it is not a write, goes elsewhere, or cannot be sent twice (a streamed body).
+ */
+export function replayPlan(input, init, origin = null) {
+  const isRequest = typeof Request !== 'undefined' && input instanceof Request;
+  const method = String(init?.method || (isRequest ? input.method : '') || 'GET').toUpperCase();
+  if (SAFE_METHODS.has(method)) return null;
+  const url = isRequest ? input.url : (input instanceof URL ? input.href : String(input ?? ''));
+  if (!sameOrigin(url, origin)) return null;
+  const body = init?.body;
+  if (body && typeof body === 'object' && typeof body.getReader === 'function') return null; // a stream is read once
+  // fetch(request) reads the request's body: a copy taken before the first send is what the second one sends.
+  const again = isRequest ? input.clone() : input;
+  return { method, url, args: init === undefined ? [again] : [again, init] };
+}
+
+function sameOrigin(url, origin) {
+  if (!/^[a-z][a-z0-9+.-]*:/i.test(url) && !url.startsWith('//')) return true; // a path of this page
+  if (!origin) return false;
+  try { return new URL(url).origin === new URL(origin).origin; } catch { return false; }
+}
+
+/**
+ * A fetch over `fetchImpl` that recovers the page secret once: the refresh is one request at a time (writes refused
+ * together share it), the refused request is sent again only when the refresh answered, and the second answer is
+ * final whatever it says.
+ */
+export function createPageSessionFetch(fetchImpl, { refreshPath = PAGE_SECRET_REFRESH_PATH, origin = null, onRecover = null } = {}) {
+  if (typeof fetchImpl !== 'function') throw new TypeError('createPageSessionFetch needs a fetch');
+  let refreshing = null;
+  function refreshCookie() {
+    if (!refreshing) {
+      refreshing = (async () => {
+        try {
+          const res = await fetchImpl(refreshPath, { method: 'GET', credentials: 'same-origin', cache: 'no-store', headers: { Accept: 'application/json' } });
+          return !!res && res.ok === true;
+        } catch { return false; } finally { refreshing = null; }
+      })();
+    }
+    return refreshing;
+  }
+  return async function pageSessionFetch(input, init) {
+    const plan = replayPlan(input, init, origin);
+    const res = await fetchImpl(input, init);
+    if (!plan || !res || res.status !== 403 || typeof res.clone !== 'function') return res;
+    let body = null;
+    try { body = await res.clone().json(); } catch { return res; }
+    if (!isPageSecretRefusal(res.status, body)) return res;
+    if (!(await refreshCookie())) return res;
+    try { onRecover?.({ method: plan.method, url: plan.url, code: body.code }); } catch { /* a listener's own error */ }
+    return fetchImpl(...plan.args);
+  };
+}
+
+/** Wrap `target.fetch` (the window's) once; returns true when it did, false when it already had or there is none. */
+export function installPageSessionRecovery(target = globalThis) {
+  if (!target || typeof target.fetch !== 'function' || target.__synabunPageSession) return false;
+  const original = target.fetch.bind(target);
+  const origin = target.location && typeof target.location.origin === 'string' ? target.location.origin : null;
+  target.fetch = createPageSessionFetch(original, { origin });
+  try { Object.defineProperty(target, '__synabunPageSession', { value: true, configurable: true }); } catch { target.__synabunPageSession = true; }
+  return true;
+}
+
+if (typeof window !== 'undefined' && typeof document !== 'undefined') installPageSessionRecovery(window);

package/neural-interface/public/shared/registry.js

@@ -5,8 +5,10 @@
 // Each variant (3D / 2D) registers its identity, capabilities, and UI
 // extensions on boot. Shared UI reads the registry to decide what to render.
 
+import { resolveViewVariant } from './view-variant.js';
+
 const _registry = {
-  variant: null,            // '3d' | '2d' | future variants
+  variant: resolveViewVariant(), // 3D only; the 2D implementation is deprecated
   capabilities: new Set(),  // e.g. 'camera-hud', 'minimap', 'hulls', 'lasso', 'controls-panel'
   navbarButtons: [],        // { zone, order, html, init }  (legacy, kept for compat)
   menuItems: [],            // { menu, order, type, id, label, shortcut?, init }
@@ -23,7 +25,7 @@ const _registry = {
  * @param {{ variant: string, capabilities?: string[] }} config
  */
 export function registerVariant(config) {
-  _registry.variant = config.variant;
+  _registry.variant = resolveViewVariant(config.variant);
   _registry.capabilities = new Set(config.capabilities || []);
 }
 
@@ -72,7 +74,7 @@ export function registerKeyboardShortcut(spec) {
 
 // ── Query API ──
 
-export function getVariant() { return _registry.variant; }
+export function getVariant() { return resolveViewVariant(_registry.variant); }
 export function hasCapability(name) { return _registry.capabilities.has(name); }
 export function getNavbarButtons() { return _registry.navbarButtons; }
 export function getMenuItems() { return _registry.menuItems; }

package/neural-interface/public/shared/retired-2d.js

@@ -0,0 +1,3 @@
+// Deprecated 2D page: static hosts also resolve old bookmarks to the supported 3D page.
+import { normalizeViewUrl } from './view-variant.js';
+window.location.replace(normalizeViewUrl(window.location.href));