synabun 2.0.5 → 2.0.7

package/neural-interface/public/shared/desktop-update-view.js

@@ -0,0 +1,462 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — the desktop app's updates: what the page shows
+// ═══════════════════════════════════════════
+//
+// Inside the SynaBun desktop app the updater is the app's own (packaging/desktop):
+// it reads the release feed, downloads at once, and installs by itself when
+// SynaBun is idle, after a one-minute notice the user can postpone. The page
+// only shows what the updater reports through window.synabunDesktop.updates
+// (desktop-bridge.js): the top-right badge, the Notifications drawer, the toast
+// of Apps > Check for updates, the update dialog and the notice (countdown,
+// "updated", a failed install) in ui-update.js. One reading of a report for all
+// of them, so they never disagree.
+//
+// No imports and no DOM: `node --test` loads this file as it is
+// (tests/desktop-update-view.test.mjs). DESKTOP_COPY is the English of every
+// sentence; `desktop` in i18n/en.json must equal it and i18n/pt-BR.json must
+// have the same keys with the same {values} (the test checks both). The
+// offline page, which can load nothing, writes DESKTOP_COPY.offline.hint as it
+// is.
+
+export const DESKTOP_COPY = Object.freeze({
+  update: Object.freeze({
+    source: 'SynaBun app',
+    tooltip: 'SynaBun update available: v{current} → v{latest}',
+    tooltipDownloading: 'Downloading SynaBun v{latest}',
+    tooltipReady: 'SynaBun v{latest} is ready: it installs when SynaBun is idle',
+    titleAvailable: 'Update available',
+    titleDownloading: 'Downloading the update',
+    titleDownloaded: 'Update ready',
+    titleInstalling: 'Installing the update',
+    titleMove: 'Move SynaBun to Applications',
+    titleManual: 'Install the update yourself',
+    titleError: 'The update did not finish',
+    notesLabel: 'What\'s new',
+    notesEmpty: 'This release has no notes.',
+    snapshot: 'Before v{version} starts for the first time, SynaBun takes a verified snapshot of your data.',
+    backup: 'Download full backup',
+    backupWorking: 'Creating backup...',
+    backupDone: '{file} ({size} MB)',
+    backupFailed: 'Backup failed: {reason}',
+    later: 'Later',
+    download: 'Download update',
+    downloadStarting: 'Starting the download.',
+    progress: '{transferred} of {total} MB',
+    progressUnknown: '{transferred} MB downloaded',
+    hide: 'Hide',
+    hideHint: 'The download continues while this is hidden. SynaBun installs the update by itself when nothing is running.',
+    readyBody: 'SynaBun v{version} is downloaded. It installs by itself once nothing is running: SynaBun shows a one-minute notice, then restarts into it. It also installs when you quit SynaBun.',
+    waitingBody: 'Waiting for: {list}.',
+    countdownBody: 'SynaBun restarts into v{version} in {seconds} s.',
+    postponedBody: 'Postponed until {time}. It also installs when you quit SynaBun.',
+    nowBody: 'SynaBun restarts into v{version} as soon as nothing is running.',
+    installNow: 'Install now',
+    installingBody: 'SynaBun is stopping its server and installing v{version}. It closes and opens again by itself.',
+    moveBody: 'macOS is running SynaBun from a disk image or a temporary location, where it cannot update itself. Move it to the Applications folder; SynaBun opens again from there and can update.',
+    move: 'Move to Applications',
+    manualBody: 'SynaBun cannot replace itself in its current folder. Download the disk image of v{version}, open it and drag SynaBun to the Applications folder.',
+    manualReady: 'The disk image of v{version} is downloaded. Open it and drag SynaBun to the Applications folder to replace the old copy.',
+    manualFile: 'File: {path}',
+    manualDownload: 'Download disk image',
+    showFile: 'Show disk image',
+    errorFallback: 'SynaBun could not check for updates. Check the connection and try again.',
+    errorNext: 'SynaBun keeps the version it runs and tries again at its next check. You can try now, or download the new version yourself.',
+    manualLink: 'Download it yourself',
+    close: 'Close',
+    retry: 'Try again',
+    testFeed: 'test feed',
+    metaAvailable: 'From the SynaBun app',
+    metaDownloading: 'Downloading: {percent}%',
+    metaDownloaded: 'Ready: installs when SynaBun is idle',
+    metaCountdown: 'Restarting to install it',
+    metaPostponed: 'Postponed: installs on quit or later',
+  }),
+  // What an update waits for (the app's server names it, GET /api/system/activity).
+  busy: Object.freeze({
+    assistant: 'an Assistant run or dispatched agent',
+    'claude-panel': 'a Claude Code panel reply',
+    'codex-panel': 'a Codex panel reply',
+    'opencode-panel': 'an OpenCode panel reply',
+    'claude-cli': 'a Claude Code session in use',
+    loop: 'a loop',
+    schedule: 'a schedule',
+    backup: 'a backup',
+    maintenance: 'indexing or an install',
+    unknown: 'work SynaBun cannot see the end of',
+    test: 'the test switch',
+  }),
+  // The notice at the bottom right: the countdown before the restart, "updated", a failed install.
+  notice: Object.freeze({
+    countdownTitle: 'Updating to v{version}',
+    countdownLine: 'SynaBun restarts in {seconds} s.',
+    later: 'Later',
+    postponed: 'SynaBun asks again in an hour, or installs the update when you quit it.',
+    updatedTitle: 'SynaBun is updated',
+    updatedLine: 'Now v{version}, updated from v{previous}.',
+    updatedLineShort: 'Now v{version}.',
+    failedTitle: 'The update did not finish',
+    details: 'Details',
+    close: 'Close',
+  }),
+  menu: Object.freeze({
+    quit: 'Quit SynaBun',
+  }),
+  offline: Object.freeze({
+    hint: 'The SynaBun app restarts its server by itself. If it stays offline, quit SynaBun and open it again.',
+    stalled: 'The server has not come back. Quit SynaBun and open it again.',
+    failedHint: 'Quit SynaBun and open it again. If the start fails, the start screen says why.',
+  }),
+  // The window's title bar (desktop-titlebar.js): Windows and Linux open the app's menu from a button in it.
+  titleBar: Object.freeze({
+    appMenu: 'SynaBun menu',
+  }),
+});
+
+/** Where SynaBun is downloaded by hand, when the app names nothing better. */
+export const DESKTOP_RELEASES_URL = 'https://github.com/danilokhury/Synabun/releases/latest';
+
+/** A DESKTOP_COPY sentence (`update.download`, `offline.hint`) with its `{params}` filled in: the translator when the page gives none. */
+export function fillDesktopCopy(key, params = {}) {
+  const value = String(key ?? '').split('.').reduce((node, part) => (node && typeof node === 'object' ? node[part] : undefined), DESKTOP_COPY);
+  if (typeof value !== 'string') return String(key ?? '');
+  return value.replace(/\{(\w+)\}/g, (all, name) => (params && params[name] != null ? String(params[name]) : all));
+}
+
+const STATUSES = new Set(['idle', 'checking', 'not-available', 'available', 'downloading', 'downloaded', 'installing', 'error']);
+const INSTALL_MODES = new Set(['restart', 'move-to-applications', 'manual-download']);
+const PHASES = new Set(['waiting', 'countdown', 'postponed']);
+const BUSY_KINDS = Object.keys(DESKTOP_COPY.busy);
+// The statuses in which a version is on offer, between the check that found it and the install.
+const OFFERED = new Set(['available', 'downloading', 'downloaded', 'installing']);
+
+const text = (value, max) => (typeof value === 'string' && value.trim() ? value.trim().slice(0, max) : null);
+const amount = (value) => {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+};
+const instant = (value) => (typeof value === 'string' && value.length <= 64 && Number.isFinite(Date.parse(value)) ? value : null);
+
+function readProgress(value) {
+  if (!value || typeof value !== 'object') return null;
+  const total = amount(value.total);
+  const transferred = total > 0 ? Math.min(amount(value.transferred), total) : amount(value.transferred);
+  const given = value.percent === null || value.percent === undefined || value.percent === '' ? NaN : Number(value.percent);
+  const percent = Number.isFinite(given) ? given : total > 0 ? (transferred / total) * 100 : 0;
+  return { percent: Math.max(0, Math.min(100, percent)), transferred, total, bytesPerSecond: amount(value.bytesPerSecond) };
+}
+
+/** The automatic install's moment: what it waits for, when it restarts, until when it is postponed. */
+function readAuto(value) {
+  if (!value || typeof value !== 'object' || !PHASES.has(value.phase)) return null;
+  const busy = (Array.isArray(value.busy) ? value.busy : [])
+    .filter((item) => item && typeof item === 'object')
+    .map((item) => ({ kind: BUSY_KINDS.includes(item.kind) ? item.kind : 'unknown', count: Math.max(1, Math.floor(Number(item.count)) || 1) }))
+    .slice(0, 12);
+  return {
+    phase: value.phase,
+    busy,
+    installAt: value.phase === 'countdown' ? instant(value.installAt) : null,
+    postponedUntil: value.phase === 'postponed' ? instant(value.postponedUntil) : null,
+    now: value.now === true,
+  };
+}
+
+function readUpdated(value) {
+  if (!value || typeof value !== 'object') return null;
+  const version = text(value.version, 64);
+  return version ? { version, previous: text(value.previous, 64) } : null;
+}
+
+/** Only SynaBun's own releases page: a report cannot point the page anywhere else. */
+function readReleasesUrl(value) {
+  return typeof value === 'string' && /^https:\/\/github\.com\/danilokhury\/Synabun\/releases(?:\/[\w./-]*)?$/.test(value) ? value : DESKTOP_RELEASES_URL;
+}
+
+/**
+ * One report of the app's updater, checked field by field: whatever is missing
+ * or of the wrong kind reads as nothing (an unknown status is 'idle', an
+ * unknown install mode is 'restart'), so a page never draws a half answer.
+ */
+export function readDesktopUpdateState(state) {
+  const s = state && typeof state === 'object' ? state : {};
+  return {
+    supported: s.supported === true,
+    status: STATUSES.has(s.status) ? s.status : 'idle',
+    current: text(s.current, 64) || '',
+    latest: text(s.latest, 64),
+    notes: text(s.notes, 20000),
+    releaseDate: text(s.releaseDate, 64),
+    progress: readProgress(s.progress),
+    error: text(s.error, 1000),
+    checkedAt: text(s.checkedAt, 64),
+    install: INSTALL_MODES.has(s.install) ? s.install : 'restart',
+    manualFile: text(s.manualFile, 4096),
+    testFeed: s.testFeed === true,
+    auto: readAuto(s.auto),
+    updated: readUpdated(s.updated),
+    releasesUrl: readReleasesUrl(s.releasesUrl),
+  };
+}
+
+/** True when the report offers a version: it is supported, says which one, and is between the check and the install. */
+function offers(s) {
+  return s.supported && OFFERED.has(s.status) && !!s.latest;
+}
+
+/** Whole seconds until `at` (an ISO time), never below 0. */
+export function secondsUntil(at, now = Date.now()) {
+  const target = Date.parse(at);
+  return Number.isFinite(target) ? Math.max(0, Math.ceil((target - now) / 1000)) : 0;
+}
+
+/**
+ * What the rest of the page reads as `_versionData` (ui-update.js), in the
+ * shape the npm / Git check gives it: `updateAvailable`, `current`, `latest`,
+ * `source`. `desktop: true` says where it came from; the report's own fields
+ * ride along for the dialog.
+ */
+export function versionDataFromDesktop(state) {
+  const s = readDesktopUpdateState(state);
+  const offered = offers(s);
+  return {
+    desktop: true,
+    supported: s.supported,
+    updateAvailable: offered,
+    current: s.current,
+    latest: offered ? s.latest : null,
+    source: 'app',
+    installedChannel: 'stable',
+    installPlan: null,
+    status: s.status,
+    progress: s.progress,
+    error: s.error,
+    notes: s.notes,
+    install: s.install,
+    manualFile: s.manualFile,
+    testFeed: s.testFeed,
+    checkedAt: s.checkedAt,
+    auto: s.auto,
+  };
+}
+
+/**
+ * Which page of the dialog a report is: 'available', 'downloading',
+ * 'downloaded', 'installing', 'move' (macOS runs this copy where it cannot be
+ * replaced: move it to Applications first), 'manual' (a folder SynaBun cannot
+ * write: the disk image, by hand), 'error', or 'none' (nothing to show: no
+ * update, a check under way, an unsupported run).
+ */
+export function desktopUpdateStep(state) {
+  const s = readDesktopUpdateState(state);
+  if (!s.supported) return 'none';
+  if (s.status === 'error') return 'error';
+  if (!offers(s)) return 'none';
+  if (s.status === 'downloading') return 'downloading';
+  if (s.status === 'installing') return 'installing';
+  if (s.install === 'move-to-applications') return 'move';
+  if (s.install === 'manual-download') return 'manual';
+  return s.status === 'downloaded' ? 'downloaded' : 'available';
+}
+
+/** The bar and its words: whole percent (never 100 before it is), megabytes with one decimal. */
+function progressOf(progress, say, number) {
+  if (!progress || (!progress.total && !progress.transferred)) return { percent: 0, text: say('downloadStarting') };
+  const megabytes = (bytes) => number(bytes / 1048576, 1);
+  if (progress.total > 0) {
+    return { percent: Math.floor(progress.percent), text: say('progress', { transferred: megabytes(progress.transferred), total: megabytes(progress.total) }) };
+  }
+  return { percent: null, text: say('progressUnknown', { transferred: megabytes(progress.transferred) }) };
+}
+
+/** What an update waits for, as words: "a loop, a Codex panel reply". */
+export function desktopBusyList(busy = [], { t = fillDesktopCopy } = {}) {
+  return (Array.isArray(busy) ? busy : []).map((item) => t(`busy.${BUSY_KINDS.includes(item?.kind) ? item.kind : 'unknown'}`)).join(', ');
+}
+
+/**
+ * Everything the update dialog draws for one report, as data:
+ *   step       desktopUpdateStep()
+ *   dot        1 (offered) · 2 (downloading) · 3 (ready, installing) · 0 (no dots)
+ *   title      the heading
+ *   body       sentences, in order
+ *   notesLabel, notes   the release notes (plain text: drawn as text, line breaks kept)
+ *   progress   { percent (whole, or null when the size is not known), text } while downloading
+ *   file       where the disk image was saved (manual, once it is downloaded)
+ *   link       { href, label }: SynaBun's releases page, after an update that did not finish
+ *   backup     { id: 'backup', label } next to the offer: a full backup, if the user wants one first
+ *   actions    [{ id, kind: 'ghost' | 'primary', label }] in the order they are drawn
+ *              ids: later, download, hide, install-now, move, manual-download, show-file, close, retry
+ *   retry      what Try again does after an error: 'download' (a version was on offer) or 'check'
+ *   busy       the step is the app working (downloading, installing)
+ *   ticking    a sentence counts down: the page draws it again every second
+ * `t` translates `update.<key>` (and `busy.<kind>`) with its params; DESKTOP_COPY
+ * is the default. `now` is the time the countdown counts from; `time` writes an
+ * ISO time the way the page's language writes a time of day.
+ */
+export function desktopUpdateView(state, {
+  t = fillDesktopCopy, number = (value, digits) => value.toFixed(digits), now = Date.now(),
+  time = (iso) => new Date(iso).toISOString().slice(11, 16),
+} = {}) {
+  const s = readDesktopUpdateState(state);
+  const step = desktopUpdateStep(s);
+  const say = (key, params) => t(`update.${key}`, params);
+  const version = s.latest || '';
+  const action = (id, kind, key) => ({ id, kind, label: say(key) });
+  const view = {
+    step, dot: 0, title: '', body: [], notesLabel: '', notes: null, progress: null, file: null, link: null,
+    backup: null, actions: [], retry: null, busy: false, ticking: false,
+    current: s.current, latest: s.latest, testFeed: s.testFeed,
+  };
+  switch (step) {
+    case 'available':
+      view.dot = 1;
+      view.title = say('titleAvailable');
+      view.body = [say('snapshot', { version })];
+      view.notesLabel = say('notesLabel');
+      view.notes = s.notes || say('notesEmpty');
+      view.backup = { id: 'backup', label: say('backup') };
+      view.actions = [action('later', 'ghost', 'later'), action('download', 'primary', 'download')];
+      break;
+    case 'downloading':
+      view.dot = 2;
+      view.title = say('titleDownloading');
+      view.progress = progressOf(s.progress, say, number);
+      view.body = [say('hideHint')];
+      view.actions = [action('hide', 'ghost', 'hide')];
+      view.busy = true;
+      break;
+    case 'downloaded': {
+      view.dot = 3;
+      view.title = say('titleDownloaded');
+      view.body = [say('readyBody', { version })];
+      const auto = s.auto;
+      if (auto?.phase === 'countdown' && auto.installAt) {
+        view.body.push(say('countdownBody', { version, seconds: secondsUntil(auto.installAt, now) }));
+        view.ticking = true;
+      } else if (auto?.phase === 'postponed' && auto.postponedUntil) {
+        view.body.push(say('postponedBody', { time: time(auto.postponedUntil) }));
+      } else if (auto?.now) {
+        view.body.push(say('nowBody', { version }));
+      }
+      if (auto?.phase === 'waiting' && auto.busy.length) view.body.push(say('waitingBody', { list: desktopBusyList(auto.busy, { t }) }));
+      view.actions = [
+        auto?.phase === 'countdown' ? action('later', 'ghost', 'later') : action('close', 'ghost', 'close'),
+        action('install-now', 'primary', 'installNow'),
+      ];
+      break;
+    }
+    case 'installing':
+      view.dot = 3;
+      view.title = say('titleInstalling');
+      view.body = [say('installingBody', { version })];
+      view.busy = true;
+      break;
+    case 'move':
+      view.dot = 1;
+      view.title = say('titleMove');
+      view.body = [say('moveBody')];
+      view.actions = [action('later', 'ghost', 'later'), action('move', 'primary', 'move')];
+      break;
+    case 'manual':
+      view.title = say('titleManual');
+      if (s.status === 'downloaded') {
+        view.dot = 3;
+        view.body = [say('manualReady', { version })];
+        view.file = s.manualFile ? say('manualFile', { path: s.manualFile }) : null;
+        view.actions = [action('close', 'ghost', 'close'), action('show-file', 'primary', 'showFile')];
+      } else {
+        view.dot = 1;
+        view.body = [say('manualBody', { version })];
+        view.actions = [action('later', 'ghost', 'later'), action('manual-download', 'primary', 'manualDownload')];
+      }
+      break;
+    case 'error':
+      view.title = say('titleError');
+      view.body = [s.error || say('errorFallback')];
+      view.retry = s.latest ? 'download' : 'check';
+      if (s.latest) {
+        // A version was on offer and did not arrive or install: the app keeps the old one, and a person can fetch the new one.
+        view.body.push(say('errorNext'));
+        view.link = { href: s.releasesUrl, label: say('manualLink') };
+      }
+      view.actions = [action('close', 'ghost', 'close'), action('retry', 'primary', 'retry')];
+      break;
+    default:
+      break;
+  }
+  return view;
+}
+
+/** The line under the SynaBun item of Notifications > Updates, or '' when there is nothing on offer. */
+export function desktopUpdateMeta(state, { t = fillDesktopCopy } = {}) {
+  const s = readDesktopUpdateState(state);
+  switch (desktopUpdateStep(s)) {
+    case 'downloading': return t('update.metaDownloading', { percent: Math.floor(s.progress?.percent || 0) });
+    case 'downloaded':
+      if (s.auto?.phase === 'countdown') return t('update.metaCountdown');
+      if (s.auto?.phase === 'postponed') return t('update.metaPostponed');
+      return t('update.metaDownloaded');
+    case 'installing': return t('update.titleInstalling');
+    case 'available': case 'move': case 'manual': return t('update.metaAvailable');
+    default: return '';
+  }
+}
+
+/** The badge's tooltip: what the update is doing, never only that one exists. */
+export function desktopUpdateTooltip(state, { t = fillDesktopCopy } = {}) {
+  const s = readDesktopUpdateState(state);
+  const params = { current: s.current, latest: s.latest || '' };
+  const step = desktopUpdateStep(s);
+  if (step === 'downloading') return t('update.tooltipDownloading', params);
+  if (step === 'downloaded') return t('update.tooltipReady', params);
+  return t('update.tooltip', params);
+}
+
+/**
+ * The notice at the bottom right, or null:
+ *   countdown  SynaBun is idle and restarts into the update: the seconds left, and Later
+ *   updated    this copy runs after an update (once: the page acknowledges it)
+ *   failed     a version was on offer and did not download or install: why, and the releases page
+ * `key` changes only when the notice is another one (a countdown that restarts is another one).
+ */
+export function desktopUpdateNotice(state, { t = fillDesktopCopy, now = Date.now() } = {}) {
+  const s = readDesktopUpdateState(state);
+  if (!s.supported) return null;
+  if (s.status === 'downloaded' && s.latest && s.auto?.phase === 'countdown' && s.auto.installAt) {
+    const seconds = secondsUntil(s.auto.installAt, now);
+    return {
+      kind: 'countdown', key: `countdown:${s.latest}:${s.auto.installAt}`, tone: 'up', seconds,
+      title: t('notice.countdownTitle', { version: s.latest }), line: t('notice.countdownLine', { seconds }),
+      actions: [{ id: 'later', label: t('notice.later') }], link: null, ticking: true,
+    };
+  }
+  if (s.updated) {
+    return {
+      kind: 'updated', key: `updated:${s.updated.version}`, tone: 'ok', seconds: null,
+      title: t('notice.updatedTitle'),
+      line: s.updated.previous ? t('notice.updatedLine', { version: s.updated.version, previous: s.updated.previous }) : t('notice.updatedLineShort', { version: s.updated.version }),
+      actions: [{ id: 'dismiss', label: t('notice.close') }], link: null, ticking: false,
+    };
+  }
+  if (s.status === 'error' && s.latest && s.error) {
+    return {
+      kind: 'failed', key: `failed:${s.latest}:${s.error}`, tone: 'err', seconds: null,
+      title: t('notice.failedTitle'), line: s.error,
+      actions: [{ id: 'details', label: t('notice.details') }], link: { href: s.releasesUrl, label: t('update.manualLink') }, ticking: false,
+    };
+  }
+  return null;
+}
+
+/**
+ * What a finished check ends in, for whoever asked for it (the native menu, the
+ * tray, Apps > Check for updates): 'offer' (open the dialog), 'up-to-date',
+ * 'error', or 'none' (an unsupported run, or a check still under way).
+ */
+export function desktopCheckOutcome(state) {
+  const s = readDesktopUpdateState(state);
+  if (!s.supported || s.status === 'checking') return 'none';
+  if (offers(s)) return 'offer';
+  if (s.status === 'error') return 'error';
+  return 'up-to-date';
+}

package/neural-interface/public/shared/editor/editor-panel.js

@@ -2078,7 +2078,7 @@ export function initEditorPanel(host = {}) {
     // listeners run in the order they were added): what was just written follows by itself.
     try {
       const value = kept ? storage.getItem(KEYS.EDITOR_TABS) : null;
-      if (value) navigator.sendBeacon?.('/api/ui-state', new Blob([JSON.stringify({ [KEYS.EDITOR_TABS]: JSON.parse(value) })], { type: 'application/json' }));
+      if (value && storage.persists !== false) navigator.sendBeacon?.('/api/ui-state', new Blob([JSON.stringify({ [KEYS.EDITOR_TABS]: JSON.parse(value) })], { type: 'application/json' }));
     } catch { /* the debounced write is what is left */ }
     _backups?.flush({ leaving: true });
   };

package/neural-interface/public/shared/explorer/fx-main.js

@@ -488,7 +488,7 @@ export function createExplorer(host) {
     if (due) {
       try {
         const value = storage.getItem(treeKey);
-        if (value) navigator.sendBeacon?.('/api/ui-state', new Blob([JSON.stringify({ [treeKey]: JSON.parse(value) })], { type: 'application/json' }));
+        if (value && storage.persists !== false) navigator.sendBeacon?.('/api/ui-state', new Blob([JSON.stringify({ [treeKey]: JSON.parse(value) })], { type: 'application/json' }));
       } catch { /* the debounced write is what is left */ }
     }
     stopWatch();

package/neural-interface/public/shared/git-bash-view.js

@@ -0,0 +1,145 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Git Bash for Claude Code: what Settings says
+// ═══════════════════════════════════════════
+//
+// Settings → AI connections → Executable paths has a row for the Git Bash
+// that every Claude Code started by SynaBun gets on Windows (the server's
+// lib/git-bash/, GET /api/cli/git-bash): the one on the PC, SynaBun's own copy
+// of Git for Windows (installed with the app, or downloaded on an npm
+// install), its download while it runs, why it failed, and the button that
+// tries again. This module reads an answer of the server into what the row
+// shows; ui-git-bash.js draws it.
+//
+// No imports and no DOM: `node --test` loads this file as it is
+// (tests/git-bash-view.test.mjs). GIT_BASH_COPY is the English of every
+// sentence; `gitBash.*` in i18n/en.json must equal it and i18n/pt-BR.json must
+// have the same keys.
+//
+// macOS and Linux have nothing to show (Claude Code runs the system's shell
+// there): the row stays hidden, as it does for a server from before this,
+// which has no such route.
+
+export const GIT_BASH_COPY = Object.freeze({
+  label: 'Git Bash for Claude Code (Windows)',
+  help: 'Claude Code on Windows runs its Bash tool and its hooks in Git Bash. SynaBun uses the Git for Windows of this PC, or its own copy when the PC has none.',
+  badgeSystem: 'On this PC',
+  badgeReady: 'SynaBun\'s copy',
+  badgeMissing: 'Not found',
+  badgeDownloading: 'Downloading',
+  badgeFailed: 'Not installed',
+  badgeOff: 'Off',
+  sourceEnv: 'CLAUDE_CODE_GIT_BASH_PATH names {path}.',
+  sourceSettings: 'Your Claude Code settings name {path}.',
+  sourceSystem: 'Git for Windows on this PC: {path}',
+  sourceSystemPassed: 'Git for Windows on this PC: {path}. Claude Code would not find it by itself, so SynaBun names it.',
+  sourceBundled: 'Git for Windows {version}, installed with SynaBun: {path}',
+  sourceDownloaded: 'Git for Windows {version}, downloaded by SynaBun: {path}',
+  missing: 'No Git Bash on this PC. SynaBun downloads its own copy of Git for Windows {version} ({size} MB) and checks it against its published SHA-256.',
+  stepDownload: 'Downloading Git for Windows {version}: {done} of {total} MB',
+  stepExtract: 'Unpacking Git for Windows {version}: {percent}%',
+  stepVerify: 'Checking every file against the pinned release…',
+  stepPlace: 'Putting it in place…',
+  failed: 'Git for Windows could not be put in place. {reason}',
+  off: 'Turned off: SYNABUN_GIT_BASH=off is set, so SynaBun downloads nothing and names no Git Bash.',
+  unsupported: 'No Git for Windows release is pinned for this processor. Install Git for Windows from git-scm.com.',
+  settingsNamed: 'A claude you start in another terminal uses it too: your Claude Code settings name it.',
+  settingsKept: 'Your Claude Code settings name a Git Bash that is not there ({value}). SynaBun left that value as it is.',
+  settingsError: 'Your Claude Code settings could not be updated: {message}',
+  download: 'Download',
+  retry: 'Try again',
+  recheck: 'Re-check',
+  checking: 'Checking…',
+  errorOffline: 'The download server could not be reached. Check the connection and try again.',
+  errorHttp: 'The download server answered with an error. Try again in a moment.',
+  errorInterrupted: 'The download stopped before it was complete. Nothing was kept.',
+  errorTimeout: 'Nothing arrived from the download server for too long.',
+  errorChecksum: 'What arrived is not the published release, so it was removed and never run.',
+  errorUnpack: 'The download could not be unpacked, so it was removed.',
+  errorDisk: 'The files could not be written. Check free space (about 550 MB) and permissions.',
+  errorCancelled: 'The download was stopped.',
+  errorUnknown: 'The download did not finish.',
+  errorRequest: 'SynaBun did not answer: {message}',
+});
+
+const ERROR_COPY = Object.freeze({
+  offline: 'errorOffline', http: 'errorHttp', interrupted: 'errorInterrupted', timeout: 'errorTimeout',
+  checksum: 'errorChecksum', unpack: 'errorUnpack', disk: 'errorDisk', cancelled: 'errorCancelled',
+});
+
+const STEP_COPY = Object.freeze({ download: 'stepDownload', extract: 'stepExtract', verify: 'stepVerify', place: 'stepPlace' });
+
+/** A GIT_BASH_COPY sentence with its `{params}` filled in: the translator when the page gives none. */
+export function fillGitBashCopy(key, params = {}) {
+  return String(GIT_BASH_COPY[key] ?? key).replace(/\{(\w+)\}/g, (whole, name) => (params[name] != null ? params[name] : whole));
+}
+
+let _translate = null;
+
+/** The page's translator: `(key, params) => t('gitBash.' + key, params)`; an empty answer or the key itself falls back to the English. */
+export function setGitBashTranslator(fn) {
+  _translate = typeof fn === 'function' ? fn : null;
+}
+
+/** A sentence in the page's language. */
+export function gitBashText(key, params = {}) {
+  if (_translate) {
+    try {
+      const text = _translate(key, params);
+      if (typeof text === 'string' && text && text !== key && text !== `gitBash.${key}`) return text;
+    } catch { /* the English below */ }
+  }
+  return fillGitBashCopy(key, params);
+}
+
+/** Whole megabytes (the release file is about a hundred of them). */
+const mb = (bytes) => String(Number(bytes) > 0 ? Math.round(Number(bytes) / 1024 / 1024) : 0);
+
+/** What the user's settings note adds to a row that shows SynaBun's copy in use, or null. */
+function settingsNote(status) {
+  const result = status.settings;
+  if (!result || typeof result !== 'object') return null;
+  if (status.state === 'ready' && (result.state === 'written' || result.state === 'unchanged') && result.value === status.path) return gitBashText('settingsNamed');
+  if (result.state === 'kept-user-value' && result.value) return gitBashText('settingsKept', { value: result.value });
+  if (result.state === 'error') return gitBashText('settingsError', { message: result.message || '' });
+  return null;
+}
+
+/**
+ * The row for one answer of GET /api/cli/git-bash.
+ * @returns {{ visible: boolean, badge: { text: string, tone: 'detected' | 'not-found' | 'custom' | null } | null,
+ *   line: string, note: string | null, action: 'download' | 'retry' | null, busy: boolean, recheck: boolean }}
+ */
+export function gitBashView(status) {
+  const hidden = { visible: false, badge: null, line: '', note: null, action: null, busy: false, recheck: false };
+  if (!status || typeof status !== 'object' || status.supported !== true) return hidden;
+  const version = status.pinned?.version || '';
+  const path = status.path || '';
+  const row = (badge, tone, line, extra = {}) => ({ ...hidden, visible: true, badge: { text: gitBashText(badge), tone }, line, recheck: true, ...extra });
+  switch (status.state) {
+    case 'off':
+      return row('badgeOff', null, gitBashText('off'), { recheck: false });
+    case 'unsupported':
+      return row('badgeMissing', 'not-found', gitBashText('unsupported'));
+    case 'system': {
+      const key = status.source === 'env' ? 'sourceEnv' : status.source === 'settings' ? 'sourceSettings' : status.passToClaude ? 'sourceSystemPassed' : 'sourceSystem';
+      return row('badgeSystem', 'detected', gitBashText(key, { path }), { note: settingsNote(status) });
+    }
+    case 'ready':
+      return row('badgeReady', 'detected', gitBashText(status.source === 'bundled' ? 'sourceBundled' : 'sourceDownloaded', { version, path }), { note: settingsNote(status) });
+    case 'missing':
+      return row('badgeMissing', 'not-found', gitBashText('missing', { version, size: mb(status.pinned?.size) }), { action: 'download' });
+    case 'downloading': {
+      const step = STEP_COPY[status.step] || 'stepDownload';
+      const progress = status.progress || {};
+      const params = { version, done: mb(progress.done), total: mb(progress.total || status.pinned?.size), percent: Number(progress.percent) || 0 };
+      return row('badgeDownloading', 'custom', gitBashText(step, params), { busy: true, recheck: false });
+    }
+    case 'failed': {
+      const code = status.error?.code;
+      const reason = ERROR_COPY[code] ? gitBashText(ERROR_COPY[code]) : (status.error?.message || gitBashText('errorUnknown'));
+      return row('badgeFailed', 'not-found', gitBashText('failed', { reason }), { action: 'retry', note: settingsNote(status) });
+    }
+    default:
+      return hidden;
+  }
+}

package/neural-interface/public/shared/html-shell.js

@@ -470,6 +470,7 @@ ${is3D ? `
 
   <div class="bar-center" id="search-container">
     <div id="search-wrapper">
+      <svg class="search-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>
       <input type="text" id="search-input" placeholder="${t('search.placeholder')}" autocomplete="off" spellcheck="false">
       <span id="search-badge"></span>
       <button id="search-clear">&times;</button>