synabun 2.0.0 → 2.0.7

package/neural-interface/public/shared/ui-sidepanel-runtime.js

@@ -11,7 +11,8 @@ export function routeSidepanelEvent(event, data) {
   const host = sidepanelHost();
   if (!host) return false;
   if (hostedSidepanelId) {
-    if (!['open-plan-editor', 'open-changelog-editor', 'browser:reconnect'].includes(event)) return false;
+    // The code editor lives in the main window: what opens it from a detached session goes there.
+    if (!['open-plan-editor', 'open-changelog-editor', 'open-file-editor', 'browser:reconnect'].includes(event)) return false;
     host.emitFromSession(hostedSidepanelId, event, data);
     return true;
   }

package/neural-interface/public/shared/ui-sidepanel-sessions.js

@@ -99,7 +99,9 @@ function show(entry) {
     entry.unregister = registerSidepanel({ owner: entry.id, layoutKey: entry.id, provider: entry.provider,
       element, header, actions, buttonClass: 'sp-session-button', applyVisibility: () => renderPill(entry) });
     if (!storage.getItem(`synabun-sidepanel-layout-${entry.id}`)) detachSidepanel(entry.id);
-    frame.src = `/sidepanel-session.html?provider=${entry.provider}`;
+    // A language the page address forces (?lang=, showcase captures) holds in the session's frame too.
+    const lang = new URLSearchParams(window.location.search).get('lang');
+    frame.src = `/sidepanel-session.html?provider=${entry.provider}${lang ? `&lang=${encodeURIComponent(lang)}` : ''}`;
   }
   setSidepanelVisible(entry.id, true);
 }

package/neural-interface/public/shared/ui-sync.js

@@ -74,6 +74,18 @@ const SYNC_HANDLERS = {
   // Assistant → Models toggles (every provider): the Assistant's model menus,
   // Routes editor and Models manager reload their lists.
   'assistant:hidden-models-changed': (msg) => emit('sync:assistant:hidden-models-changed', msg),
+  // A provider lists other models than before (CLI update, account change, OpenCode
+  // provider connected): the same menus reload.
+  'assistant:catalog-changed': (msg) => emit('sync:assistant:catalog-changed', msg),
+
+  // Settings → Automation behavior switched in another window: an open Settings follows.
+  'assistant:user-context-changed': (msg) => emit('sync:assistant:user-context-changed', msg),
+
+  // Code editor preferences saved in another window (word wrap, font size…): the editor follows.
+  'editor:config-changed': (msg) => emit('sync:editor:config-changed', msg),
+
+  // Settings → Greeting switched in another window: an open Settings follows.
+  'greeting:changed': (msg) => emit('sync:greeting:changed', msg),
 
   // Card sync (relayed from other clients)
   'card:opened':    (msg) => emit('sync:card:opened', msg),
@@ -106,7 +118,13 @@ const SYNC_HANDLERS = {
   'assistant:permission-resolved': (msg) => emit('sync:assistant:permission-resolved', msg),
   'assistant:focus':               (msg) => emit('sync:assistant:focus', msg),
   'assistant:accounts-changed':    (msg) => emit('sync:assistant:accounts-changed', msg),
+  // Claude accounts (lib/claude-accounts.js): any account's state changed — signed in or out, a key saved or removed, its mode, renamed, added, removed
+  'claude:accounts-changed':       (msg) => emit('sync:claude:accounts-changed', msg),
+  // Codex accounts (lib/codex-accounts.js): the same, for every Codex account
+  'codex:accounts-changed':        (msg) => emit('sync:codex:accounts-changed', msg),
   'assistant:mailbox':             (msg) => emit('sync:assistant:mailbox', msg),
+  'assistant:budget':              (msg) => emit('sync:assistant:budget', msg),
+  'assistant:budget-changed':      (msg) => emit('sync:assistant:budget-changed', msg),
   'assistant:cost':                (msg) => emit('sync:assistant:cost', msg),
   'assistant:desktop':             (msg) => emit('sync:assistant:desktop', msg),
   'assistant:desktop-setup':       (msg) => emit('sync:assistant:desktop-setup', msg),
@@ -178,6 +196,10 @@ const SYNC_HANDLERS = {
   // Skin change sync
   'skin:changed': (msg) => emit('sync:skin:changed', msg),
 
+  // The server says it is restarting, before it goes: every window shows the
+  // restart, not only the one that asked for it (ui-loading.js).
+  'server:restarting': (msg) => emit('server:restarting', msg),
+
   // Session indexing progress
   'indexing:started':          (msg) => emit('ws:message', msg),
   'indexing:session-started':  (msg) => emit('ws:message', msg),

package/neural-interface/public/shared/ui-terminal.js

@@ -20,7 +20,7 @@ import { readinessKind, typeWhenReady } from './term-ready.js';
 import { initRendererManager, acquireRenderer, disposeRenderer, hasWebgl, noteFocus, adoptRenderer, rendererState, rendererStats } from './term-renderer.js';
 import { mountAssistant } from './assistant/asst-panel.js';
 import { getAssistantSession } from './assistant/asst-api.js';
-import { brainLabel, normalizeBrain, readStoredBrain } from './assistant/asst-state.js';
+import { brainLabel, normalizeBrain, readStoredBrain, restoredSessionName, sessionNameGivenUp } from './assistant/asst-state.js';
 import { initAssistant, registerAssistantHost, openAssistant, assistantOwnerOf, fetchLiveAssistantSessions, isAssistantSessionLive } from './ui-assistant.js';
 
 const $ = (id) => document.getElementById(id);
@@ -3467,7 +3467,7 @@ function _updateAssistantBrainChip(session) {
   chip.hidden = !label;
 }
 
-/** After a tab/float rename, push the new label into the panel (marks it user-renamed). */
+/** After a tab/float rename, push the new label into the panel (marks it user-renamed; the panel writes it to the session record). */
 function _syncAssistantLabel(session) {
   if (!session?._isAssistant || !session._assistant) return;
   if (session._assistant.getTitle() !== session.label) session._assistant.setTitle(session.label);
@@ -3484,6 +3484,11 @@ function _mountAssistantSession(sessionId, { meta = null, saved = null, brain =
   if (existing) { if (!_restoringLayout) _focusAssistantTab(existing); return existing; }
 
   const resolvedBrain = normalizeBrain(brain || meta?.brain || saved?.brain || readStoredBrain(storage));
+  // A renamed session comes back under its name: the session record's (a rename made in either
+  // host, the one the Sessions menu lists), else the rename saved with this tab. A record whose
+  // name was given up says so: the label and the renamed flag saved with a tab are stale.
+  const named = restoredSessionName(meta, label);
+  const givenUp = sessionNameGivenUp(meta);
   const viewport = document.createElement('div');
   viewport.className = 'term-viewport assistant-viewport';
   viewport.dataset.sessionId = sessionId;
@@ -3495,13 +3500,13 @@ function _mountAssistantSession(sessionId, { meta = null, saved = null, brain =
     id: sessionId,
     profile: 'assistant',
     cwd: resolvedBrain.project || null,
-    label: label || saved?.label || meta?.title || profileDef?.label || 'Assistant',
+    label: named || (givenUp ? '' : saved?.label) || meta?.title || profileDef?.label || 'Assistant',
     term: null, fitAddon: null, searchAddon: null,
     ws: null,               // no PTY socket — the panel owns /ws/assistant/:id
     viewport, ro: null, renderer: null,
     dead: false,
     pinned: saved?.pinned || false,
-    _userRenamed: saved?.userRenamed || !!label,
+    _userRenamed: !givenUp && (saved?.userRenamed || !!named),
     _floatColor: saved?.floatColor || null,
     _isAssistant: true,     // flag for tab-type-specific logic
     _assistant: null,       // controller (set right after mount)
@@ -3525,6 +3530,19 @@ function _mountAssistantSession(sessionId, { meta = null, saved = null, brain =
       if (titleEl && titleEl.contentEditable !== 'true') titleEl.textContent = next;
       saveSessionRegistry();
     },
+    // A rename the panel could not save: the tab and its saved label go back to the record's name.
+    setName(text, renamed) {
+      const s = live();
+      const next = String(text || '').trim();
+      if (!next) return;
+      s.label = next;
+      s._userRenamed = !!renamed;
+      renderTabBar();
+      const titleEl = _detachedTabs.get(sessionId)?.el?.querySelector('.term-float-tab-title');
+      if (titleEl && titleEl.contentEditable !== 'true') titleEl.textContent = next;
+      saveSessionRegistry();
+      saveTerminalLayout();
+    },
     setStatus(status) { setSessionStatusBadge(sessionId, status); },
     setBrain(b) {
       const s = live();
@@ -3539,7 +3557,7 @@ function _mountAssistantSession(sessionId, { meta = null, saved = null, brain =
     requestDetach() { const idx = _sessions.findIndex(s => s.id === sessionId); if (idx >= 0 && !_detachedTabs.has(sessionId)) detachTab(idx); },
   };
   session._assistant = mountAssistant(viewport, { sessionId, brain: resolvedBrain, host, session: meta, label: session.label, reattach });
-  if (session._userRenamed && session.label) session._assistant.setTitle(session.label);
+  if (session._userRenamed && session.label) session._assistant.setTitle(session.label, { restored: true });
 
   renderTabBar();
   if (_restoringLayout) {
@@ -6271,6 +6289,23 @@ export function openTerminalPanel(profile) {
   emit('terminal:open', { profile });
 }
 
+// Attach only: the guarded provider-auth route has already chosen and started
+// the CLI. No command text is accepted from either panel.
+export async function openProviderLoginTerminal(sessionId, label) {
+  if (!/^[a-f0-9]{32}$/.test(sessionId || '')) throw new Error('Invalid sign-in terminal session.');
+  await _whenOpenIdle();
+  let session = _sessions.find(s => s.id === sessionId);
+  if (!session) session = await openSession('shell', null, sessionId, { label });
+  if (!session) throw new Error('Could not attach the sign-in terminal. Try again.');
+  showPanel();
+  const index = _sessions.indexOf(session);
+  if (_detachedTabs.has(sessionId)) {
+    bringTabToFront(sessionId);
+  } else if (index >= 0) switchToSession(index);
+  session.term?.focus();
+  return session;
+}
+
 // ── Diagnostics (no UI) ──
 // window.__synabunTermStats(): keystroke → echo-parsed latency, bytes handed
 // to xterm but not yet parsed, flow-control acks pending, renderer state and

package/neural-interface/public/shared/ui-tool-updates.js

@@ -52,6 +52,11 @@ const SOURCE_LABELS = {
   'winget': 'winget',
   'scoop': 'Scoop',
   'choco': 'Chocolatey',
+  'mise': 'mise',
+  'asdf': 'asdf',
+  'cargo': 'Cargo',
+  'snap': 'Snap',
+  'system': 'your system package manager',
 };
 
 function sourceLabel(src) {

package/neural-interface/public/shared/ui-tunnel.js

@@ -0,0 +1,130 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — the public address: the page side
+// ═══════════════════════════════════════════
+//
+// What the two cards that start the Cloudflare tunnel share (the Share menu's
+// Connection block in ui-invite.js, Settings → Automations → Online access in
+// ui-settings.js): asking the server, starting and stopping, asking again
+// while something is on its way (a download, the wait for an address), and
+// the reading of each answer in the page's language. What an answer means is
+// tunnel-view.js; how it is drawn is each card's own.
+//
+// The requests are sent with fetch as they are: same origin, no body. The
+// server takes a start or a stop from the app's own pages only
+// (lib/http-guards.js ownerRouteGuard), and a refusal is shown in the card
+// like any other failure, not as the app-wide "forbidden" notice.
+
+import { getLocale, t } from './i18n.js';
+import { tunnelView } from './tunnel-view.js';
+
+const POLL_MS = 1000;
+/** How long a card keeps asking by itself. A download or a start that takes longer is shown again on the next look. */
+const POLL_LIMIT_MS = 20 * 60 * 1000;
+
+const translate = (key, params) => t(`tunnel.${key}`, params);
+function number(value, digits) {
+  try { return value.toLocaleString(getLocale(), { minimumFractionDigits: digits, maximumFractionDigits: digits }); } catch { return value.toFixed(digits); }
+}
+
+/** tunnel-view.js tunnelView() in the page's language. */
+export function readTunnel(status) {
+  return tunnelView(status, { t: translate, number });
+}
+
+/** The sentence a card shows where it offers the remote MCP address and no access key exists. */
+export function mcpKeyNeededText() {
+  return translate('mcpKeyNeeded');
+}
+
+async function ask(path, method = 'GET') {
+  const res = await fetch(path, { method });
+  let body = null;
+  try { body = await res.json(); } catch { body = null; }
+  return { status: res.status, ok: res.ok, body };
+}
+
+/**
+ * One card's hold on the tunnel.
+ *
+ * @param {object} [o]
+ * @param {(view: object, status: object | null) => void} [o.onChange] called with every new reading
+ * @param {() => boolean} [o.alive] false once the card is gone: the asking-again stops
+ * @returns {{ view: () => object, status: () => (object | null), show: (status: object) => object,
+ *   refresh: () => Promise<object>, start: () => Promise<object>, stop: () => Promise<object>, dispose: () => void }}
+ */
+export function createTunnelCard({ onChange = () => {}, alive = () => true } = {}) {
+  let status = null;
+  let timer = null;
+  let since = 0;
+  let disposed = false;
+
+  function schedule(view) {
+    clearTimeout(timer);
+    timer = null;
+    if (disposed || !view.poll || !alive()) { since = 0; return; }
+    if (!since) since = Date.now();
+    if (Date.now() - since > POLL_LIMIT_MS) return;
+    timer = setTimeout(refresh, POLL_MS);
+  }
+
+  /** Take an answer as the state of things, tell the card, and ask again later when it will change by itself. */
+  function show(next) {
+    status = next && typeof next === 'object' ? next : null;
+    const view = readTunnel(status);
+    if (!disposed) { try { onChange(view, status); } catch (error) { console.warn('[tunnel] The card could not be drawn:', error); } }
+    schedule(view);
+    return view;
+  }
+
+  async function refresh() {
+    if (disposed) return readTunnel(status);
+    try {
+      const got = await ask('/api/tunnel/status');
+      if (got.ok && got.body) return show(got.body);
+    } catch { /* the server is away for a moment: what is shown stays, and the next look asks again */ }
+    const view = readTunnel(status);
+    schedule(view);
+    return view;
+  }
+
+  /** A start or a stop that the server did not take: shown in the card, with what the card knew before. */
+  function refused(got, error) {
+    // A server from before the tunnel program came with SynaBun answers a start with 400 when no cloudflared is
+    // installed, and its words tell the user to install one. What is missing is a restart: the card says that.
+    if (got?.status === 400 && !status?.cloudflared) return show({ ok: true, available: false, running: false, starting: false, url: null });
+    const failure = got?.status === 403
+      ? { code: 'refused', message: got.body?.error || '' }
+      : { code: 'unknown', message: got?.body?.error || error?.message || '' };
+    return show({ ...(status || {}), ok: true, running: false, starting: false, url: null, state: 'failed', error: failure, cloudflared: status?.cloudflared || { state: 'missing' } });
+  }
+
+  async function send(path) {
+    let got = null;
+    try { got = await ask(path, 'POST'); } catch (error) { return refused(null, error); }
+    if (!got.ok || got.body?.ok === false) return refused(got);
+    return refresh();
+  }
+
+  return {
+    view: () => readTunnel(status),
+    status: () => status,
+    show,
+    refresh,
+    start: () => send('/api/tunnel/start'),
+    stop: () => send('/api/tunnel/stop'),
+    dispose() { disposed = true; clearTimeout(timer); timer = null; },
+  };
+}
+
+/**
+ * Put new markup into a card's block without disturbing the person using it: nothing happens when the markup is
+ * what is there already, and a button that had the keyboard's focus has it again afterwards (by its id).
+ */
+export function drawInto(container, html) {
+  if (!container || container.__tunnelHtml === html) return false;
+  const focused = container.contains(document.activeElement) ? document.activeElement?.id : '';
+  container.innerHTML = html;
+  container.__tunnelHtml = html;
+  if (focused) { try { container.querySelector(`#${CSS.escape(focused)}`)?.focus({ preventScroll: true }); } catch { /* the button is gone with its state */ } }
+  return true;
+}

package/neural-interface/public/shared/ui-tutorial-steps.js

@@ -82,11 +82,15 @@ const ASSISTANT_BUTTON = ['#topright-assistant-panel-btn', 'closed'];
 const ACTIVE_TAB = '#assistant-panel.open .asp-viewport.active';
 const ACTIVE_BAR = '#assistant-panel.open .asp-tab-bar.active';
 
+// With the workspace tools hidden (the toolbar's toggle) their controls are off screen, and the step outlines the
+// toggle that shows them.
+const TOOLS_TOGGLE = ['#topright-tools-btn'];
+
 export const FEATURE_STEPS = [
-  { id: 'explain-memory-explorer', chapter: 'memory', targets: [['#topright-memory-explorer-btn']] },
+  { id: 'explain-memory-explorer', chapter: 'memory', targets: [['#topright-memory-explorer-btn'], TOOLS_TOGGLE] },
   { id: 'explain-graph', chapter: 'memory', copy: { '2d': 'body2d' }, targets: [['[data-menu="graph"] > .menubar-label']] },
   { id: 'explain-focus', chapter: 'workspace', targets: [['#wb-toolbar'], ['#titlebar-viz-toggle', 'graph']] },
-  { id: 'explain-workspaces', chapter: 'workspace', targets: [['#ws-indicator']] },
+  { id: 'explain-workspaces', chapter: 'workspace', targets: [['#ws-indicator'], TOOLS_TOGGLE] },
   { id: 'explain-terminals', chapter: 'tools', menu: 'apps', targets: [['#menu-terminal-claude', 'body', '#menu-terminal-opencode']] },
   { id: 'explain-browser', chapter: 'tools', menu: 'apps', targets: [['#menu-terminal-browser']] },
   { id: 'explain-side-panel', chapter: 'tools', targets: [['#topright-claude-panel-btn', 'body', '#topright-opencode-panel-btn']] },