synabun 1.3.0 → 2.0.0

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

@@ -9,9 +9,12 @@ import { storage } from './storage.js';
 import { KEYS } from './constants.js';
 import { getMenuItems } from './registry.js';
 import { openHelp } from './ui-help.js';
+import { initPwaInstall, isStandalone, requestPwaInstall } from './pwa-install.js';
 import { registerAction } from './ui-keybinds.js';
 import { isGuest, hasPermission } from './ui-sync.js';
 import { sendToPanel } from './ui-claude-panel.js';
+import { forceCheckToolUpdates, showUpdateToast, TOOL_LABELS } from './ui-tool-updates.js';
+import { forceCheckSynabunUpdate, openSynabunUpdateModal } from './ui-update.js';
 
 const $ = (id) => document.getElementById(id);
 
@@ -81,7 +84,7 @@ export function initMenubar() {
     const dropdown = document.querySelector('.menubar-item.open .menubar-dropdown');
     if (!dropdown) return;
 
-    const allItems = [...dropdown.querySelectorAll('.menu-item:not(.disabled)')];
+    const allItems = [...dropdown.querySelectorAll('.menu-item:not(.disabled):not([hidden])')];
     if (allItems.length === 0) return;
 
     const focused = dropdown.querySelector('.menu-item.focused');
@@ -126,12 +129,18 @@ export function initMenubar() {
     'menu-open-skills-studio': 'skills',
     'menu-skills-new': 'skills',
     'menu-skills-import': 'skills',
+    'menu-open-styleguide': 'styleGuide',
     'menu-open-automation-studio': 'automations',
+    'menu-automations-schedule-new': 'automations',
+    'menu-automations-quick-timer': 'automations',
+    'menu-automations-schedule-groups': 'automations',
     'menu-automations-new': 'automations',
     'menu-automations-import': 'automations',
+    'menu-terminal-assistant': 'terminal',
     'menu-terminal-claude': 'terminal',
     'menu-terminal-codex': 'terminal',
     'menu-terminal-gemini': 'terminal',
+    'menu-terminal-opencode': 'terminal',
     'menu-terminal-shell': 'terminal',
     'menu-terminal-browser': 'browser',
     'menu-terminal-youtube': 'browser',
@@ -318,6 +327,27 @@ function wireAutomationsMenu() {
       emit('automations:open-schedules');
     });
   }
+  const newScheduleItem = $('menu-automations-schedule-new');
+  if (newScheduleItem) {
+    newScheduleItem.addEventListener('click', () => {
+      closeAll();
+      emit('automations:open-schedules', { action: 'new-schedule' });
+    });
+  }
+  const quickTimerItem = $('menu-automations-quick-timer');
+  if (quickTimerItem) {
+    quickTimerItem.addEventListener('click', () => {
+      closeAll();
+      emit('automations:open-schedules', { action: 'quick-timer' });
+    });
+  }
+  const scheduleGroupsItem = $('menu-automations-schedule-groups');
+  if (scheduleGroupsItem) {
+    scheduleGroupsItem.addEventListener('click', () => {
+      closeAll();
+      emit('automations:open-schedules', { tab: 'groups' });
+    });
+  }
   const newItem = $('menu-automations-new');
   if (newItem) {
     newItem.addEventListener('click', () => {
@@ -340,9 +370,39 @@ function wireAutomationsMenu() {
 
 function wireTerminalMenu() {
   const items = {
+    'menu-terminal-assistant': () => emit('assistant:open'),
     'menu-terminal-claude':  () => emit('terminal:open', { profile: 'claude-code' }),
     'menu-terminal-codex':   () => emit('terminal:open', { profile: 'codex' }),
-    'menu-terminal-gemini':  () => emit('terminal:open', { profile: 'gemini' }),
+    'menu-terminal-gemini':   () => emit('terminal:open', { profile: 'gemini' }),
+    'menu-terminal-opencode': () => emit('terminal:open', { profile: 'opencode' }),
+    'menu-check-cli-updates': async () => {
+      const [tools, syn] = await Promise.all([
+        forceCheckToolUpdates(),
+        forceCheckSynabunUpdate(),
+      ]);
+
+      const updates = [];
+      for (const [key, info] of Object.entries(tools?.tools || {})) {
+        if (info?.updateAvailable) {
+          const label = `${TOOL_LABELS[key] || key} v${info.installed} → v${info.latest}`;
+          updates.push({ label });
+        }
+      }
+      if (syn?.updateAvailable) {
+        const srcLabel = syn.source === 'both' ? 'npm + GitHub' : syn.source === 'github' ? 'GitHub' : 'npm';
+        updates.push({ label: `SynaBun v${syn.current} → v${syn.latest}`, source: srcLabel });
+      }
+
+      const errors = [];
+      if (!tools) errors.push('CLI versions');
+      if (!syn)   errors.push('SynaBun version');
+
+      showUpdateToast({
+        updates,
+        errors,
+        onClick: syn?.updateAvailable ? () => openSynabunUpdateModal() : null,
+      });
+    },
     'menu-terminal-shell':   () => emit('terminal:open', { profile: 'shell' }),
     'menu-terminal-browser': () => emit('browser:open'),
     'menu-terminal-youtube': () => emit('browser:open', { url: 'https://www.youtube.com' }),
@@ -350,19 +410,13 @@ function wireTerminalMenu() {
     'menu-terminal-x':       () => emit('browser:open', { url: 'https://x.com' }),
     'menu-terminal-whatsapp': () => emit('browser:open', { url: 'https://web.whatsapp.com' }),
     'menu-app-leonardo':     () => { emit('browser:open', { url: 'https://app.leonardo.ai' }); emit('leonardo:launch'); },
+    'menu-open-styleguide':  () => emit('styleguide:open'),
     'menu-command-runner':   () => emit('command-runner:open'),
     'menu-terminal-link':    () => emit('link:toggle'),
     'menu-terminal-toggle':  () => emit('terminal:toggle'),
-    'menu-install-app':      async () => {
-      if (window._pwaInstallPrompt) {
-        window._pwaInstallPrompt.prompt();
-        const { outcome } = await window._pwaInstallPrompt.userChoice;
-        if (outcome === 'accepted') {
-          window._pwaInstallPrompt = null;
-          const el = $('menu-install-app');
-          if (el) el.style.display = 'none';
-        }
-      }
+    'menu-install-app': async () => {
+      const result = await requestPwaInstall();
+      if (result === 'instructions') location.assign('/install-app.html');
     },
     'menu-restart-server':   async () => {
       try {
@@ -372,12 +426,37 @@ function wireTerminalMenu() {
           const hd = await h.json();
           if (hd.projectDir) localStorage.setItem('synabun-project-dir', hd.projectDir);
         } catch {}
-        await fetch('/api/server/restart', { method: 'POST' });
-        // Show brief message then attempt reconnect after delay
         document.title = 'Restarting...';
-        setTimeout(() => location.reload(), 2000);
+        await fetch('/api/server/restart', { method: 'POST' });
+
+        // Poll /api/health until the server has gone down AND come back up.
+        // The everDown flag prevents premature reload during the brief window
+        // where the old process is still serving requests during shutdown grace.
+        const deadline = Date.now() + 15000;
+        let everDown = false;
+        while (Date.now() < deadline) {
+          await new Promise(r => setTimeout(r, 250));
+          try {
+            const r = await fetch('/api/health', { cache: 'no-store' });
+            if (!r.ok) { everDown = true; continue; }
+            if (everDown) { location.reload(); return; }
+          } catch { everDown = true; }
+        }
+        // Timeout safety net — reload anyway so the user isn't stranded.
+        location.reload();
       } catch {}
     },
+    'menu-stop-server':      async () => {
+      const previousTitle = document.title;
+      try {
+        document.title = 'Stopping...';
+        const response = await fetch('/api/server/shutdown', { method: 'POST' });
+        if (!response.ok) throw new Error(`Server stop failed (${response.status})`);
+        document.title = 'SynaBun Stopped';
+      } catch {
+        document.title = previousTitle;
+      }
+    },
   };
   Object.entries(items).forEach(([id, handler]) => {
     const el = $(id);
@@ -393,23 +472,13 @@ function wireTerminalMenu() {
   registerAction('toggle-terminal', () => emit('terminal:toggle'));
   registerAction('toggle-terminal-alt', () => emit('terminal:toggle'));
 
-  // PWA install prompt — show "Install as App" when the browser supports it
-  window.addEventListener('beforeinstallprompt', (e) => {
-    e.preventDefault();
-    window._pwaInstallPrompt = e;
-    const el = $('menu-install-app');
-    if (el) el.style.display = '';
-  });
-  window.addEventListener('appinstalled', () => {
-    window._pwaInstallPrompt = null;
+  initPwaInstall({ changed: value => {
     const el = $('menu-install-app');
-    if (el) el.style.display = 'none';
-  });
-  // Hide if already running as installed PWA
-  if (window.matchMedia('(display-mode: standalone)').matches || navigator.standalone) {
-    const el = $('menu-install-app');
-    if (el) el.style.display = 'none';
-  }
+    if (el) el.style.display = value === 'installed' ? 'none' : '';
+  } });
+  const installItem = $('menu-install-app');
+  if (installItem && !isStandalone()) installItem.style.display = '';
+
 }
 
 // ── Variant menu items injection ──

package/neural-interface/public/shared/ui-native-loop-router-state.js

@@ -0,0 +1,94 @@
+export function isNewerRunDescriptor(next, current, terminalStatuses) {
+  if (!current) return true;
+  const nextTerminal = terminalStatuses.has(next.status);
+  const currentTerminal = terminalStatuses.has(current.status);
+  if (currentTerminal !== nextTerminal) return nextTerminal;
+  const nextVersion = Number(next.version) || 0;
+  const currentVersion = Number(current.version) || 0;
+  if (nextVersion !== currentVersion) return nextVersion > currentVersion;
+  const nextTime = new Date(next.updatedAt || next.startedAt || 0).getTime() || 0;
+  const currentTime = new Date(current.updatedAt || current.startedAt || 0).getTime() || 0;
+  if (nextTime !== currentTime) return nextTime > currentTime;
+  return (Number(next.currentIteration) || 0) >= (Number(current.currentIteration) || 0);
+}
+
+export function hasActiveForeignClaim(run, windowId, claimTtlMs, now = Date.now) {
+  if (!run?.claimedBy || run.claimedBy === windowId) return false;
+  const claimedAt = new Date(run.claimedAt || 0).getTime();
+  const claimAge = claimedAt ? now() - claimedAt : Infinity;
+  return claimAge <= claimTtlMs;
+}
+
+/**
+ * Resolve the descriptor to attach after acquiring (or reusing) a claim.
+ *
+ * The claim endpoint broadcasts before its HTTP response is delivered. That
+ * broadcast may replace latestEntry while claim() is in flight; a compatible
+ * self-claim is therefore fresh state, not a reason to release the claim.
+ */
+export async function resolveRouteClaim({
+  entry,
+  alreadyOwned,
+  claim,
+  getLatestEntry,
+  windowId,
+  claimTtlMs,
+  terminalStatuses,
+  now = Date.now,
+}) {
+  let claimedRun = entry?.run || null;
+  if (!alreadyOwned) {
+    claimedRun = await claim(claimedRun);
+    if (!claimedRun) return { ok: false, release: false, reason: 'claim_failed' };
+  }
+
+  const latestEntry = getLatestEntry();
+  if (!latestEntry?.run) {
+    return { ok: false, release: !alreadyOwned, reason: 'route_removed' };
+  }
+  if (hasActiveForeignClaim(latestEntry.run, windowId, claimTtlMs, now)) {
+    return { ok: false, release: false, reason: 'foreign_claim' };
+  }
+
+  const run = isNewerRunDescriptor(latestEntry.run, claimedRun, terminalStatuses)
+    ? latestEntry.run
+    : claimedRun;
+  return {
+    ok: true,
+    run,
+    focus: latestEntry.focus ?? entry?.focus,
+  };
+}
+
+export class LocalReleaseTracker {
+  constructor({ ttlMs = 5_000, now = Date.now } = {}) {
+    this.ttlMs = ttlMs;
+    this.now = now;
+    this.entries = new Map();
+  }
+
+  mark(runId) {
+    this.prune();
+    const token = {};
+    this.entries.set(runId, { token, at: this.now() });
+    return token;
+  }
+
+  consume(runId) {
+    const entry = this.entries.get(runId);
+    if (!entry) return false;
+    this.entries.delete(runId);
+    return this.now() - entry.at <= this.ttlMs;
+  }
+
+  clear(runId, token) {
+    if (this.entries.get(runId)?.token === token) this.entries.delete(runId);
+  }
+
+  prune() {
+    const cutoff = this.now() - this.ttlMs;
+    for (const [runId, entry] of this.entries) {
+      if (entry.at < cutoff) this.entries.delete(runId);
+    }
+  }
+}