synabun 2.0.9 → 2.0.10

package/neural-interface/public/shared/settings/settings-app.js

@@ -0,0 +1,243 @@
+// ═══════════════════════════════════════════
+// SETTINGS — App (what the page says)
+// ═══════════════════════════════════════════
+//
+// The software's own controls: updates, start at login, the window, the
+// folders and a restart. Two kinds of install answer them:
+//
+//   desktop  the SynaBun desktop app: its settings are the window's
+//            (window.synabunDesktop.app, packaging/desktop/src/app-prefs.mjs),
+//            its updates the app's updater (window.synabunDesktop.updates)
+//   server   an npm or Git install: GET /api/system/app (lib/app-controls-api.js)
+//            and the update check of GET /api/system/version
+//
+// A row that does not apply to this install is not shown, or is shown off
+// with one line that says why. This file decides; settings-app-pane.js draws.
+// No imports and no DOM: `node --test` loads it as it is (tests/settings-app.test.mjs).
+
+export const APP_URL = '/api/system/app';
+const K = 'settings.redesign.app';
+
+const bool = (value) => value === true;
+const text = (value, max = 400) => (typeof value === 'string' && value ? value.slice(0, max) : null);
+const PLATFORMS = new Set(['darwin', 'win32', 'linux']);
+const LOGIN_STATUSES = new Set(['on', 'off', 'requires-approval', 'disabled', 'not-found']);
+const SERVER_STATES = new Set(['on', 'off', 'stale', 'disabled']);
+
+/** The desktop app's report (window.synabunDesktop.app.state()), checked field by field; null when there is none. */
+export function readDesktopAppState(state) {
+  if (!state || typeof state !== 'object') return null;
+  const prefs = state.prefs && typeof state.prefs === 'object' ? state.prefs : {};
+  const login = state.login && typeof state.login === 'object' ? state.login : {};
+  const gpu = state.hardwareAcceleration && typeof state.hardwareAcceleration === 'object' ? state.hardwareAcceleration : {};
+  return {
+    platform: PLATFORMS.has(state.platform) ? state.platform : null,
+    packaged: bool(state.packaged),
+    prefs: {
+      autoUpdate: prefs.autoUpdate !== false,
+      openAtLogin: bool(prefs.openAtLogin),
+      startHidden: prefs.startHidden !== false,
+      hardwareAcceleration: prefs.hardwareAcceleration !== false,
+      closeToTray: prefs.closeToTray !== false,
+    },
+    login: {
+      supported: bool(login.supported),
+      reason: text(login.reason, 40),
+      enabled: bool(login.enabled),
+      status: LOGIN_STATUSES.has(login.status) ? login.status : 'off',
+      replaced: text(login.replaced, 40),
+    },
+    gpuRestartNeeded: bool(gpu.restartNeeded),
+    tray: bool(state.tray),
+    error: text(state.error, 40),
+  };
+}
+
+/** GET /api/system/app (or a refusal of a write, which carries the same body), checked; null when it is not one. */
+export function readServerAppState(answer) {
+  if (!answer || typeof answer !== 'object' || typeof answer.install !== 'string') return null;
+  const startup = answer.startup && typeof answer.startup === 'object' ? answer.startup : {};
+  return {
+    install: text(answer.install, 20),
+    desktop: bool(answer.desktop),
+    autoUpdate: answer.updates?.auto !== false,
+    startup: {
+      supported: bool(startup.supported),
+      reason: text(startup.reason, 40),
+      enabled: bool(startup.enabled),
+      state: SERVER_STATES.has(startup.state) ? startup.state : 'off',
+      owner: text(startup.owner, 4096),
+    },
+    error: answer.ok === false ? text(answer.code, 40) || 'refused' : null,
+  };
+}
+
+/** Why GET /api/system/app gave no state: 'remote' (asked from another computer), 'old' (a server from before it), 'offline'. */
+export function serverRefusal(status, body) {
+  const code = body && typeof body === 'object' ? String(body.code || '') : '';
+  if (status === 403 && ['LOCAL_ONLY', 'REMOTE_FORBIDDEN', 'BAD_HOST', 'GUEST_FORBIDDEN'].includes(code)) return 'remote';
+  if (status === 404 || status === 405) return 'old';
+  return 'offline';
+}
+
+// ── Updates ──
+
+/**
+ * The line under the version: what the last check found. `data` is the page's
+ * update data (ui-update.js getSynabunUpdateData): the desktop app's report as
+ * versionDataFromDesktop() reads it, or GET /api/system/version.
+ * Returns { key, params, tone } (tone: ok | warn | err | off | busy).
+ */
+export function updateStatus(data) {
+  if (!data || typeof data !== 'object') return { key: `${K}.update.notChecked`, params: {}, tone: 'off' };
+  const latest = text(data.latest, 64) || '';
+  if (data.desktop) {
+    if (data.supported === false) return { key: `${K}.update.unsupported`, params: {}, tone: 'off' };
+    switch (data.status) {
+      case 'checking': return { key: `${K}.update.checking`, params: {}, tone: 'busy' };
+      case 'downloading': return { key: `${K}.update.downloading`, params: { version: latest, percent: Math.floor(Number(data.progress?.percent) || 0) }, tone: 'busy' };
+      case 'downloaded': return { key: `${K}.update.ready`, params: { version: latest }, tone: 'warn' };
+      case 'installing': return { key: `${K}.update.installing`, params: { version: latest }, tone: 'busy' };
+      case 'error': return { key: `${K}.update.failed`, params: {}, tone: 'err' };
+      case 'not-available': return { key: `${K}.update.upToDate`, params: {}, tone: 'ok' };
+      default:
+        if (data.updateAvailable && latest) return { key: `${K}.update.available`, params: { version: latest }, tone: 'warn' };
+        return { key: `${K}.update.notChecked`, params: {}, tone: 'off' };
+    }
+  }
+  if (data.updateAvailable && latest) return { key: `${K}.update.available`, params: { version: latest }, tone: 'warn' };
+  if (!data.checkedAt) return { key: `${K}.update.notChecked`, params: {}, tone: 'off' };
+  if (data.npmError && data.gitError) return { key: `${K}.update.failed`, params: {}, tone: 'err' };
+  return { key: `${K}.update.upToDate`, params: {}, tone: 'ok' };
+}
+
+/** "Checked at 14:05" (`time` writes an ISO time the page's way), or '' before any check. */
+export function checkedLine(data, { tx, time }) {
+  const at = text(data?.checkedAt, 64);
+  if (!at || !Number.isFinite(Date.parse(at))) return '';
+  return tx(`${K}.update.checkedAt`, { time: time(at) });
+}
+
+/** Is there an update to install now (the Install update button)? */
+export function canInstallUpdate(data) {
+  if (!data?.updateAvailable) return false;
+  if (data.desktop) return ['available', 'downloaded', 'error'].includes(data.status) || !data.status;
+  return true;
+}
+
+/** The automatic updates switch: { checked, disabled, helpKey }. */
+export function autoUpdateRow({ desktop, server, update }) {
+  if (desktop) {
+    return { checked: desktop.prefs.autoUpdate, disabled: update?.supported === false, helpKey: `${K}.update.autoHelpDesktop` };
+  }
+  return { checked: server ? server.autoUpdate : update?.autoCheck !== false, disabled: !server || server.desktop, helpKey: `${K}.update.autoHelpServer` };
+}
+
+// ── Startup ──
+
+/** The sentence for an error code of a change, '' for none. */
+export function startupErrorKey(code) {
+  if (!code) return '';
+  const known = ['refused', 'write-failed', 'no-wscript', 'bad-path', 'desktop-app', 'npm-entry', 'save-failed', 'network'];
+  return `${K}.startup.error.${known.includes(code) ? code : 'refused'}`;
+}
+
+/**
+ * The start at login switch and the line under it:
+ *   { shown, checked, disabled, helpKey, note: { key, params, tone } | null, settingsButton: 'darwin' | 'win32' | null }
+ * `platform` is the computer's (the desktop app says its own; the browser's guess otherwise).
+ */
+export function loginRow({ desktop, server, remote = false, platform = null }) {
+  const note = (key, tone = 'off', params = {}) => ({ key, params, tone });
+  if (desktop) {
+    const { login } = desktop;
+    const os = desktop.platform;
+    const row = {
+      shown: true, checked: login.enabled || login.status === 'requires-approval', disabled: !login.supported,
+      helpKey: `${K}.startup.helpDesktop`, note: null, settingsButton: null,
+    };
+    if (!login.supported) row.note = note(`${K}.startup.reason.${['unpackaged', 'move-to-applications', 'no-appimage'].includes(login.reason) ? login.reason : 'unsupported'}`);
+    else if (desktop.error && !['save-failed'].includes(desktop.error)) row.note = note(startupErrorKey(desktop.error), 'err');
+    else if (login.status === 'requires-approval') {
+      row.note = note(`${K}.startup.requiresApproval`, 'warn');
+      row.settingsButton = 'darwin';
+    } else if (login.status === 'disabled' || (desktop.prefs.openAtLogin && !login.enabled)) {
+      row.note = note(`${K}.startup.disabledInSystem.${os || 'linux'}`, 'warn');
+      if (os === 'darwin' || os === 'win32') row.settingsButton = os;
+    } else if (login.replaced) row.note = note(`${K}.startup.replaced`, 'ok');
+    if (desktop.error === 'save-failed') row.note = note(startupErrorKey('save-failed'), 'err');
+    return row;
+  }
+  const row = { shown: true, checked: !!server?.startup.enabled, disabled: true, helpKey: `${K}.startup.helpServer`, note: null, settingsButton: null };
+  if (remote) { row.note = note(`${K}.remote`); return row; }
+  if (!server) { row.note = note(`${K}.serverOld`); return row; }
+  const { startup } = server;
+  if (!startup.supported) {
+    // 'desktop': the SynaBun app answers for itself, and this one is from before its own settings.
+    row.note = note(`${K}.startup.reason.${['not-here', 'desktop'].includes(startup.reason) ? startup.reason : 'unsupported'}`);
+    return row;
+  }
+  row.disabled = false;
+  if (server.error) row.note = note(startupErrorKey(server.error), 'err');
+  else if (startup.owner && !startup.enabled) {
+    row.note = note(`${K}.startup.owner`, 'off');
+    row.disabled = true;
+  } else if (startup.state === 'disabled') {
+    row.note = note(`${K}.startup.disabledInSystem.${PLATFORMS.has(platform) ? platform : 'linux'}`, 'warn');
+  }
+  return row;
+}
+
+/** Start in the background (desktop only; shown under start at login, live while it is on). */
+export function hiddenRow({ desktop }) {
+  if (!desktop) return { shown: false, checked: false, disabled: true };
+  const on = desktop.login.enabled || desktop.login.status === 'requires-approval';
+  return { shown: true, checked: desktop.prefs.startHidden, disabled: !desktop.login.supported || !on, noteKey: on ? '' : `${K}.startup.hiddenNeedsLogin` };
+}
+
+// ── Window ──
+
+/**
+ * The window section: { reasonKey, closeToTray: { shown, checked, disabled, noteKey }, gpu: { checked, disabled, restartNeeded } }.
+ * Outside the desktop app the rows are shown off, with the one line that says they belong to it.
+ */
+export function windowRows({ desktop }) {
+  if (!desktop) {
+    return {
+      reasonKey: `${K}.window.desktopOnly`,
+      closeToTray: { shown: true, checked: false, disabled: true, noteKey: '' },
+      gpu: { checked: false, disabled: true, restartNeeded: false },
+    };
+  }
+  const mac = desktop.platform === 'darwin';
+  return {
+    reasonKey: '',
+    closeToTray: {
+      shown: true,
+      checked: mac ? true : desktop.prefs.closeToTray,
+      disabled: mac,
+      // macOS keeps an app in the Dock; elsewhere without a tray icon, opening SynaBun again shows the window.
+      noteKey: mac ? `${K}.window.macDock` : (!desktop.tray && desktop.prefs.closeToTray ? `${K}.window.noTray` : ''),
+    },
+    gpu: { checked: desktop.prefs.hardwareAcceleration, disabled: false, restartNeeded: desktop.gpuRestartNeeded },
+  };
+}
+
+// ── Maintenance ──
+
+/** The folder buttons and the restart: { folders: boolean, restart: boolean, noteKey }. */
+export function maintenanceRow({ desktop, server, remote = false, restartAvailable = true }) {
+  if (desktop) return { folders: true, restart: restartAvailable, noteKey: '' };
+  if (remote) return { folders: false, restart: restartAvailable, noteKey: `${K}.remote` };
+  if (!server) return { folders: false, restart: restartAvailable, noteKey: `${K}.serverOld` };
+  return { folders: true, restart: restartAvailable, noteKey: '' };
+}
+
+/** The platform of this computer as the browser says it, when nothing better is known. */
+export function guessPlatform(userAgent = '') {
+  const ua = String(userAgent);
+  if (/Mac OS X|Macintosh/i.test(ua)) return 'darwin';
+  if (/Windows/i.test(ua)) return 'win32';
+  if (/Linux|X11/i.test(ua)) return 'linux';
+  return null;
+}

package/neural-interface/public/shared/settings/settings-data.js

@@ -0,0 +1,88 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Settings' reads
+// ═══════════════════════════════════════════
+// The answers the Settings modal is built from (openSettingsModal in
+// ui-settings.js), kept in the page's data cache (data-cache.js): Settings
+// opens from them at once and they are read again in the background once they
+// are old. Only a first open waits for them; the launch prefetch reads them
+// once the page has painted, and closing Settings reads them again, so the next
+// open shows what was changed in this one. Each open gets its own copy (the
+// panes edit theirs in place). Never kept in sessionStorage: this is
+// configuration.
+// No DOM: runs under node --test as well.
+
+import { createDataCache } from '../data-cache.js';
+
+const MINUTE = 60_000;
+
+// `ok`: the endpoint says it answered (`{ ok: true, … }`). `raw`: the status and body are kept as they came, for
+// a reader that tells the states apart itself (settings-greeting.js, settings-user-context.js).
+const okBody = (body) => !!body && typeof body === 'object' && body.ok !== false && !body.error;
+export const SETTINGS_READS = Object.freeze({
+  settings: { url: '/api/settings', accept: okBody },
+  connections: { url: '/api/connections', accept: (body) => Array.isArray(body?.connections) },
+  integrations: { url: '/api/claude-code/integrations', accept: (body) => body?.ok === true },
+  skills: { url: '/api/claude-code/skills', accept: (body) => body?.ok === true },
+  // The tunnel changes by itself (starting, stopping from the Share menu): asked again after a few seconds.
+  tunnel: { url: '/api/tunnel/status', accept: (body) => body?.ok === true, ttlMs: 10_000 },
+  mcpKey: { url: '/api/mcp-key', accept: (body) => body?.ok === true },
+  openclaw: { url: '/api/bridges/openclaw', accept: (body) => body?.ok === true },
+  greeting: { url: '/api/greeting', raw: true },
+  setup: { url: '/api/setup/status', accept: (body) => body?.ok === true },
+  cli: { url: '/api/cli/config', accept: (body) => body?.ok === true },
+  toolPermissions: { url: '/api/claude-code/tool-permissions', accept: (body) => body?.ok === true },
+  toolCategories: { url: '/api/claude-code/tool-categories', accept: (body) => body?.ok === true, ttlMs: 10 * MINUTE },
+  discord: { url: '/api/discord/config', accept: (body) => body?.ok === true },
+  skins: { url: '/api/skins', accept: (body) => body?.ok === true },
+  icons: { url: '/api/file-icons', accept: (body) => body?.ok === true },
+  youtube: { url: '/api/youtube/config', accept: (body) => body?.ok === true },
+  typesafe: { url: '/api/typesafe/config', accept: (body) => body?.ok === true },
+  userContext: { url: '/api/assistant/user-context', raw: true },
+});
+
+const caches = Object.fromEntries(Object.entries(SETTINGS_READS).map(([name, spec]) => [name, createDataCache(`settings:${name}`, {
+  ttlMs: spec.ttlMs || MINUTE,
+  load: async () => {
+    const res = await fetch(spec.url);
+    if (spec.raw) return { status: res.status, body: await res.json().catch(() => null) };
+    if (!res.ok) throw new Error(`${spec.url}: HTTP ${res.status}`);
+    return res.json();
+  },
+  accept: spec.raw ? (value) => value?.status >= 200 && value.status < 300 && !!value.body : spec.accept,
+})]));
+
+function copy(value) {
+  try { return typeof structuredClone === 'function' ? structuredClone(value) : JSON.parse(JSON.stringify(value)); } catch { return value; }
+}
+
+/**
+ * Every read, as Promise.allSettled gives them: `{ [name]: { status: 'fulfilled', value } | { status: 'rejected',
+ * reason } }`. A kept answer is given at once (a copy of it) and read again in the background when it is old;
+ * a read never made waits for its request, as the modal always did.
+ */
+export async function readSettingsData() {
+  const names = Object.keys(SETTINGS_READS);
+  const settled = await Promise.allSettled(names.map((name) => caches[name].get('')));
+  return Object.fromEntries(names.map((name, i) => [name, settled[i].status === 'fulfilled' ? { status: 'fulfilled', value: copy(settled[i].value) } : settled[i]]));
+}
+
+/** Read whatever is not fresh now (launch prefetch); resolves when done, never rejects. */
+export function prefetchSettingsData() {
+  return Promise.allSettled(Object.values(caches).map((cache) => cache.prefetch(''))).then(() => undefined);
+}
+
+/**
+ * The answers are due (Settings closed: something may have been changed in it; a sync event said so): the next
+ * open waits for none of them that are read again in time, and `names` limits it to some.
+ */
+export function refreshSettingsData(names = null) {
+  for (const [name, cache] of Object.entries(caches)) {
+    if (names && !names.includes(name)) continue;
+    cache.invalidate('', { refetch: true });
+  }
+}
+
+/** True when every read has an answer kept (Settings can open without waiting). */
+export function settingsDataReady() {
+  return Object.values(caches).every((cache) => cache.has(''));
+}

package/neural-interface/public/shared/settings/settings-ia.js

@@ -184,6 +184,19 @@ export const SETTINGS_PAGES = [
       { id: 'stg-sec-2d-graph',      key: 'd2_graph',               state: 'advanced', variant: 'graphics' },
     ],
   },
+  {
+    // The software itself (settings-app-pane.js): updates, start at login, the window, the folders and a restart.
+    // A row shows where it applies: the desktop app's own settings come from the app (window.synabunDesktop.app),
+    // an npm or Git install's from GET /api/system/app; settings-app.js decides what each install shows.
+    id: 'app', key: 'app', group: 'app', icon: 'app',
+    panes: [{ id: 'app' }],
+    sections: [
+      { id: 'stg-sec-app-updates',     key: 'updates',     state: 'open' },
+      { id: 'stg-sec-app-startup',     key: 'startup',     state: 'open' },
+      { id: 'stg-sec-app-window',      key: 'window',      state: 'open' },
+      { id: 'stg-sec-app-maintenance', key: 'maintenance', state: 'open' },
+    ],
+  },
   {
     // The last page: version, links, system and dependencies (settings-about-pane.js, GET /api/system/about).
     // Its header (icon, version, Check for updates, Copy info) is not a section: it is always shown.
@@ -290,6 +303,10 @@ export const SETTINGS_CONTROLS = {
   'stg-sec-visual-tuning': 'UI003 UI004 UI005 UI006 UI007 UI008 UI009 UI010',
   'stg-sec-file-icons': 'ICO001 ICO003 ICO002 ICO004 ICO005',
   'stg-sec-2d-graph': 'GFX001 GFX002 GFX003 GFX004 GFX005 GFX006 GFX007 GFX008',
+  'stg-sec-app-updates': 'SYS001 SYS002 SYS003',
+  'stg-sec-app-startup': 'SYS004 SYS005',
+  'stg-sec-app-window': 'SYS006 SYS007 SYS008',
+  'stg-sec-app-maintenance': 'SYS009 SYS010 SYS011',
   'stg-sec-about-dependencies': 'ABT003',
 };
 /** Controls of a page that sit outside its sections (a pane's save bar, the tabs of a pane). */

package/neural-interface/public/shared/sidepanel-session-status.js

@@ -0,0 +1,49 @@
+// What a detached session window (ui-sidepanel-sessions.js) is doing, for the
+// pill the main window shows for it. It is read from the window's own tray
+// pills, the ones its provider panel paints from its sessions' state: Claude
+// (tabWorking: a turn or background agents and shells; tabNeedsYou: a
+// permission or a question waiting), Codex (a turn or a thread being made; an
+// approval or a question card waiting), OpenCode (tabPillState: a turn, an
+// automation's turn, a sub-agent's, one waiting on you) and the SynaBun
+// Assistant (sessionStatus). The same source as the tray pills, never a second
+// guess. DOM-free.
+
+const WORKING = /^(cp|cxp|ocpv2|asp)-pill-running$/;
+const NEEDS_YOU = /^((cp|cxp|asp)-pill-attention|ocpv2-pill-waiting)$/;
+
+/** The states a detached window's pill shows: a session in it needs you > one works > none. */
+export const SESSION_WINDOW_STATES = Object.freeze(['action', 'working', 'idle']);
+
+/**
+ * 'action' when a session in the window waits on you, 'working' when one works,
+ * else 'idle'. `pills`: the class names of each tray pill of the window.
+ */
+export function sessionWindowStatus(pills) {
+  let working = false;
+  for (const classes of pills || []) {
+    for (const cls of classes || []) {
+      if (NEEDS_YOU.test(cls)) return 'action';
+      if (WORKING.test(cls)) working = true;
+    }
+  }
+  return working ? 'working' : 'idle';
+}
+
+/** A status a window reported, or 'idle' for anything else. */
+export function normalizeSessionWindowStatus(status) {
+  return SESSION_WINDOW_STATES.includes(status) ? status : 'idle';
+}
+
+/**
+ * A dispatched worker's run (its descriptor) waits on your answer with no card
+ * in its tab: its turn ended asking you something (the run's outcome is
+ * needs_input while the warm worker rests between turns). Claude's and Codex's
+ * tabs say "needs you" for it, as OpenCode's do (automationTurnPhase); a card
+ * of their own (a permission, a question) says it already. A run that ended
+ * waits on nobody.
+ */
+export function runAwaitsAnswer(run) {
+  if (run?.status !== 'starting' && run?.status !== 'running') return false;
+  if (run.turnState === 'needs_input') return true;
+  return run.turnState === 'idle' && (run.outcome || run.lastResult?.status) === 'needs_input';
+}