nastechai-desktop 18.1.0

package/src/store/gateway.ts

@@ -0,0 +1,290 @@
+import type { ConnectionState, GatewayEvent } from '@NASTECH/shared'
+import { atom } from 'nanostores'
+
+import { NasTechGateway } from '@/nastech'
+import { resolveGatewayWsUrl } from '@/lib/gateway-ws-url'
+import { setGatewayState } from '@/store/session'
+
+// ── Multi-profile gateway routing ──────────────────────────────────────────
+// Concurrent sessions across profiles need concurrent sockets: the renderer's
+// event handler is already session-keyed, so the only thing stopping two
+// profiles streaming at once was the single swapping socket. We keep that one
+// socket as the PRIMARY (window) backend — owned by use-gateway-boot, with all
+// its boot-progress / sleep-wake machinery — and add one persistent SECONDARY
+// socket per *other* profile that has live work. Every socket feeds the same
+// handleGatewayEvent, so background sessions keep painting. Single-profile users
+// only ever have the primary, so their path is byte-for-byte unchanged.
+
+const normKey = (profile: string | null | undefined): string => (profile ?? '').trim() || 'default'
+
+// Read connection state through a call so TS control-flow analysis doesn't
+// narrow the getter to a constant across guards (it genuinely changes).
+const isOpen = (gateway: NasTechGateway | null): boolean => gateway?.connectionState === 'open'
+
+// The active gateway instance, exposed for inline message-stream components
+// (e.g. inline ClarifyTool, model overlays) that call gateway methods without
+// the instance threaded down through props.
+export const $gateway = atom<NasTechGateway | null>(null)
+
+interface RegistryConfig {
+  onEvent: (event: GatewayEvent) => void
+}
+
+let config: RegistryConfig | null = null
+
+export function configureGatewayRegistry(cfg: RegistryConfig): void {
+  config = cfg
+}
+
+// ── Primary (window) backend ───────────────────────────────────────────────
+let primaryGateway: NasTechGateway | null = null
+let primaryProfile = 'default'
+
+export function setPrimaryGateway(gateway: NasTechGateway | null, profile = 'default'): void {
+  primaryGateway = gateway
+  primaryProfile = normKey(profile)
+}
+
+// ── Secondary (pool) backends ──────────────────────────────────────────────
+interface Secondary {
+  profile: string
+  gateway: NasTechGateway
+  offEvent: () => void
+  offState: () => void
+  reconnectTimer: ReturnType<typeof setTimeout> | null
+  reconnectAttempt: number
+  reconnecting: boolean
+  // While true the entry auto-reconnects on drop; pruning flips it off so a
+  // deliberate close doesn't trigger the backoff loop.
+  wantOpen: boolean
+}
+
+const secondaries = new Map<string, Secondary>()
+
+let activeKey = 'default'
+
+export function isActivePrimary(): boolean {
+  return activeKey === primaryProfile
+}
+
+export function activeGateway(): NasTechGateway | null {
+  if (activeKey === primaryProfile) {
+    return primaryGateway
+  }
+
+  return secondaries.get(activeKey)?.gateway ?? primaryGateway
+}
+
+// Mirror a backend's connection state into the global composer state, but only
+// when that backend is the one the user is currently looking at. Lets the
+// composer reflect the active profile's socket without a background reconnect
+// flipping the foreground enabled/disabled state.
+function reportGatewayState(profile: string, state: ConnectionState): void {
+  if (normKey(profile) === activeKey) {
+    setGatewayState(state)
+  }
+}
+
+export function reportPrimaryGatewayState(state: ConnectionState): void {
+  reportGatewayState(primaryProfile, state)
+}
+
+function setActive(profile: string): void {
+  activeKey = normKey(profile)
+  const gateway = activeGateway()
+  $gateway.set(gateway)
+  setGatewayState(gateway?.connectionState ?? 'closed')
+}
+
+function clearTimer(entry: Secondary): void {
+  if (entry.reconnectTimer !== null) {
+    clearTimeout(entry.reconnectTimer)
+    entry.reconnectTimer = null
+  }
+}
+
+async function openSecondary(entry: Secondary): Promise<void> {
+  const desktop = window.NASTECHDesktop
+
+  if (!desktop) {
+    return
+  }
+
+  const conn = await desktop.getConnection(entry.profile)
+  const wsUrl = await resolveGatewayWsUrl(desktop, conn)
+  await entry.gateway.connect(wsUrl)
+  void desktop.touchBackend?.(entry.profile).catch(() => undefined)
+}
+
+function scheduleReconnect(entry: Secondary): void {
+  if (entry.reconnecting || entry.reconnectTimer !== null || !entry.wantOpen) {
+    return
+  }
+
+  // 1s, 2s, 4s … capped at 15s — same backoff shape as the primary.
+  const delay = Math.min(15_000, 1_000 * 2 ** Math.min(entry.reconnectAttempt, 4))
+  entry.reconnectAttempt += 1
+  entry.reconnectTimer = setTimeout(() => {
+    entry.reconnectTimer = null
+    void reconnectSecondary(entry)
+  }, delay)
+}
+
+async function reconnectSecondary(entry: Secondary): Promise<void> {
+  if (entry.reconnecting || !entry.wantOpen || isOpen(entry.gateway)) {
+    return
+  }
+
+  entry.reconnecting = true
+
+  try {
+    await openSecondary(entry)
+    entry.reconnectAttempt = 0
+  } catch {
+    // Transport failure → fall through to the backoff below.
+  } finally {
+    entry.reconnecting = false
+
+    if (entry.wantOpen && !isOpen(entry.gateway)) {
+      scheduleReconnect(entry)
+    }
+  }
+}
+
+function createSecondary(profile: string): Secondary {
+  const gateway = new NasTechGateway()
+
+  const entry: Secondary = {
+    profile,
+    gateway,
+    offEvent: () => {},
+    offState: () => {},
+    reconnectTimer: null,
+    reconnectAttempt: 0,
+    reconnecting: false,
+    wantOpen: true
+  }
+
+  entry.offEvent = gateway.onEvent(event => config?.onEvent(event))
+  entry.offState = gateway.onState(state => {
+    reportGatewayState(profile, state)
+
+    if (state === 'open') {
+      entry.reconnectAttempt = 0
+      clearTimer(entry)
+    } else if ((state === 'closed' || state === 'error') && entry.wantOpen) {
+      scheduleReconnect(entry)
+    }
+  })
+
+  secondaries.set(profile, entry)
+
+  return entry
+}
+
+// Make `profile` the active gateway, lazily opening its socket if needed. The
+// primary is a no-op fast path. Background sockets are never closed here.
+export async function ensureGatewayForProfile(profile: string): Promise<void> {
+  const key = normKey(profile)
+
+  if (key === primaryProfile) {
+    setActive(key)
+
+    return
+  }
+
+  let entry = secondaries.get(key)
+
+  if (!entry) {
+    entry = createSecondary(key)
+  }
+
+  entry.wantOpen = true
+
+  if (!isOpen(entry.gateway)) {
+    clearTimer(entry)
+    entry.reconnectAttempt = 0
+
+    try {
+      await openSecondary(entry)
+    } catch {
+      scheduleReconnect(entry)
+    }
+  }
+
+  setActive(key)
+}
+
+// Reconnect the active gateway after a transient request failure. Primary
+// reconnects are owned by use-gateway-boot, so we only drive secondaries here.
+export async function ensureActiveGatewayOpen(): Promise<NasTechGateway | null> {
+  if (activeKey === primaryProfile) {
+    return primaryGateway
+  }
+
+  const entry = secondaries.get(activeKey)
+
+  if (!entry) {
+    return null
+  }
+
+  if (!isOpen(entry.gateway)) {
+    await reconnectSecondary(entry)
+  }
+
+  return isOpen(entry.gateway) ? entry.gateway : null
+}
+
+// Wake signal (sleep/network/visibility): nudge every live secondary back open.
+export function reconnectSecondaryGateways(): void {
+  for (const entry of secondaries.values()) {
+    if (!entry.wantOpen || isOpen(entry.gateway)) {
+      continue
+    }
+
+    entry.reconnectAttempt = 0
+    clearTimer(entry)
+    void reconnectSecondary(entry)
+  }
+}
+
+// Keep the idle reaper from killing a backend we still need: ping every live
+// secondary. The active one is pinged separately (touchActiveGatewayBackend).
+export function touchSecondaryGateways(): void {
+  const desktop = window.NASTECHDesktop
+
+  for (const entry of secondaries.values()) {
+    if (entry.wantOpen) {
+      void desktop?.touchBackend?.(entry.profile).catch(() => undefined)
+    }
+  }
+}
+
+// Close + evict secondaries whose profile is neither active nor in `keep`
+// (profiles with a running / needs-input session). Bounds cost to live work.
+export function pruneSecondaryGateways(keep: Set<string>): void {
+  for (const [key, entry] of [...secondaries]) {
+    if (key === activeKey || keep.has(key)) {
+      continue
+    }
+
+    entry.wantOpen = false
+    clearTimer(entry)
+    entry.offEvent()
+    entry.offState()
+    entry.gateway.close()
+    secondaries.delete(key)
+  }
+}
+
+export function closeSecondaryGateways(): void {
+  for (const entry of secondaries.values()) {
+    entry.wantOpen = false
+    clearTimer(entry)
+    entry.offEvent()
+    entry.offState()
+    entry.gateway.close()
+  }
+
+  secondaries.clear()
+}

package/src/store/haptics.ts

@@ -0,0 +1,17 @@
+import { atom } from 'nanostores'
+
+import { persistBoolean, storedBoolean } from '@/lib/storage'
+
+const HAPTICS_MUTED_STORAGE_KEY = 'NASTECH.desktop.hapticsMuted'
+
+export const $hapticsMuted = atom(storedBoolean(HAPTICS_MUTED_STORAGE_KEY, false))
+
+$hapticsMuted.subscribe(muted => persistBoolean(HAPTICS_MUTED_STORAGE_KEY, muted))
+
+export function setHapticsMuted(muted: boolean) {
+  $hapticsMuted.set(muted)
+}
+
+export function toggleHapticsMuted() {
+  $hapticsMuted.set(!$hapticsMuted.get())
+}

package/src/store/keybinds.ts

@@ -0,0 +1,139 @@
+import { atom, computed } from 'nanostores'
+
+import {
+  defaultBindings,
+  KEYBIND_ACTION_IDS,
+  keybindAction,
+  type KeybindBindings
+} from '@/lib/keybinds/actions'
+import { arraysEqual, persistString, storedString } from '@/lib/storage'
+
+const STORAGE_KEY = 'NASTECH.desktop.keybinds'
+
+// Defaults overlaid with the user's stored overrides. Unknown / stale action ids
+// are dropped; actions added in a later release pick up their shipped default.
+function loadBindings(): KeybindBindings {
+  const base = defaultBindings()
+  const raw = storedString(STORAGE_KEY)
+
+  if (!raw) {
+    return base
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as Record<string, unknown>
+
+    for (const id of KEYBIND_ACTION_IDS) {
+      const value = parsed[id]
+
+      if (Array.isArray(value)) {
+        base[id] = value.filter((combo): combo is string => typeof combo === 'string')
+      }
+    }
+  } catch {
+    // Corrupt storage falls back to defaults.
+  }
+
+  return base
+}
+
+// Persist only the actions whose combos differ from their shipped default, so
+// changing a default never gets shadowed by a stored snapshot.
+function persistBindings(bindings: KeybindBindings): void {
+  const defaults = defaultBindings()
+  const diff: KeybindBindings = {}
+
+  for (const id of KEYBIND_ACTION_IDS) {
+    const current = bindings[id] ?? []
+
+    if (!arraysEqual(current, defaults[id] ?? [])) {
+      diff[id] = current
+    }
+  }
+
+  persistString(STORAGE_KEY, JSON.stringify(diff))
+}
+
+export const $bindings = atom<KeybindBindings>(loadBindings())
+
+$bindings.subscribe(persistBindings)
+
+// Reverse lookup combo → actionId for dispatch. First action wins on conflict;
+// the panel/edit overlay surface conflicts so users can resolve them.
+export const $comboIndex = computed($bindings, bindings => {
+  const index = new Map<string, string>()
+
+  for (const id of KEYBIND_ACTION_IDS) {
+    for (const combo of bindings[id] ?? []) {
+      if (!index.has(combo)) {
+        index.set(combo, id)
+      }
+    }
+  }
+
+  return index
+})
+
+export function setBinding(actionId: string, combos: string[]): void {
+  if (!keybindAction(actionId)) {
+    return
+  }
+
+  $bindings.set({ ...$bindings.get(), [actionId]: [...combos] })
+}
+
+export function resetBinding(actionId: string): void {
+  const action = keybindAction(actionId)
+
+  if (!action) {
+    return
+  }
+
+  $bindings.set({ ...$bindings.get(), [actionId]: [...action.defaults] })
+}
+
+export function resetAllBindings(): void {
+  $bindings.set(defaultBindings())
+}
+
+// Other actions that already use `combo` (excluding `actionId` itself).
+export function conflictsFor(actionId: string, combo: string): string[] {
+  const bindings = $bindings.get()
+
+  return KEYBIND_ACTION_IDS.filter(id => id !== actionId && (bindings[id] ?? []).includes(combo))
+}
+
+// ── Capture ─────────────────────────────────────────────────────────────────
+// `$capture` is the action currently listening for its next keypress (a panel
+// row armed for rebinding). Session-only — never persisted.
+
+export const $capture = atom<string | null>(null)
+
+export function beginCapture(actionId: string): void {
+  $capture.set(actionId)
+}
+
+export function endCapture(): void {
+  $capture.set(null)
+}
+
+// ── Panel ───────────────────────────────────────────────────────────────────
+
+export const $keybindPanelOpen = atom(false)
+
+export function openKeybindPanel(): void {
+  $keybindPanelOpen.set(true)
+}
+
+export function closeKeybindPanel(): void {
+  $keybindPanelOpen.set(false)
+  $capture.set(null)
+}
+
+export function toggleKeybindPanel(): void {
+  if ($keybindPanelOpen.get()) {
+    closeKeybindPanel()
+  } else {
+    openKeybindPanel()
+  }
+}

package/src/store/layout.ts

@@ -0,0 +1,176 @@
+import { atom, computed, type ReadableAtom } from 'nanostores'
+
+import {
+  arraysEqual,
+  insertUniqueId,
+  persistBoolean,
+  persistStringArray,
+  storedBoolean,
+  storedStringArray
+} from '@/lib/storage'
+
+import { $paneStates, ensurePaneRegistered, setPaneOpen, setPaneWidthOverride, togglePane } from './panes'
+
+export const SIDEBAR_DEFAULT_WIDTH = 237
+export const SIDEBAR_MAX_WIDTH = 360
+// Open at the same width as the sessions sidebar so the two rails match.
+export const FILE_BROWSER_DEFAULT_WIDTH = `${SIDEBAR_DEFAULT_WIDTH}px`
+export const FILE_BROWSER_MIN_WIDTH = '14rem'
+export const FILE_BROWSER_MAX_WIDTH = '20rem'
+
+export const SIDEBAR_SESSIONS_PAGE_SIZE = 50
+
+const SIDEBAR_PINNED_STORAGE_KEY = 'NASTECH.desktop.pinnedSessions'
+const SIDEBAR_AGENTS_GROUPED_STORAGE_KEY = 'NASTECH.desktop.agentsGroupedByWorkspace'
+const SIDEBAR_CRON_OPEN_STORAGE_KEY = 'NASTECH.desktop.sidebarCronOpen'
+const PANES_FLIPPED_STORAGE_KEY = 'NASTECH.desktop.panesFlipped'
+
+export const CHAT_SIDEBAR_PANE_ID = 'chat-sidebar'
+export const FILE_BROWSER_PANE_ID = 'file-browser'
+export const RIGHT_RAIL_PREVIEW_TAB_ID = 'preview'
+
+export type RightRailTabId = typeof RIGHT_RAIL_PREVIEW_TAB_ID | `file:${string}`
+
+ensurePaneRegistered(CHAT_SIDEBAR_PANE_ID, { open: true })
+ensurePaneRegistered(FILE_BROWSER_PANE_ID, { open: false })
+
+export const $sidebarOpen: ReadableAtom<boolean> = computed(
+  $paneStates,
+  states => states[CHAT_SIDEBAR_PANE_ID]?.open ?? true
+)
+
+export const $fileBrowserOpen: ReadableAtom<boolean> = computed(
+  $paneStates,
+  states => states[FILE_BROWSER_PANE_ID]?.open ?? false
+)
+
+export const $rightRailActiveTabId = atom<RightRailTabId>(RIGHT_RAIL_PREVIEW_TAB_ID)
+
+export const $sidebarWidth: ReadableAtom<number> = computed($paneStates, states => {
+  const override = states[CHAT_SIDEBAR_PANE_ID]?.widthOverride
+
+  return typeof override === 'number' ? override : SIDEBAR_DEFAULT_WIDTH
+})
+
+export const $pinnedSessionIds = atom(storedStringArray(SIDEBAR_PINNED_STORAGE_KEY))
+export const $sidebarPinsOpen = atom(true)
+export const $sidebarRecentsOpen = atom(true)
+// Cron-job sessions live in their own section below recents, collapsed by
+// default (it only renders at all when cron sessions exist) so the
+// scheduler's `[IMPORTANT: …]` first-message previews don't spam recents.
+export const $sidebarCronOpen = atom(storedBoolean(SIDEBAR_CRON_OPEN_STORAGE_KEY, false))
+export const $sidebarAgentsGrouped = atom(storedBoolean(SIDEBAR_AGENTS_GROUPED_STORAGE_KEY, false))
+// When true, the sessions sidebar moves to the right and the file browser +
+// preview rail move to the left — a mirror of the default layout.
+export const $panesFlipped = atom(storedBoolean(PANES_FLIPPED_STORAGE_KEY, false))
+export const $isSidebarResizing = atom(false)
+export const $sessionsLimit = atom(SIDEBAR_SESSIONS_PAGE_SIZE)
+
+$pinnedSessionIds.subscribe(ids => persistStringArray(SIDEBAR_PINNED_STORAGE_KEY, [...ids]))
+$sidebarCronOpen.subscribe(open => persistBoolean(SIDEBAR_CRON_OPEN_STORAGE_KEY, open))
+$sidebarAgentsGrouped.subscribe(grouped => persistBoolean(SIDEBAR_AGENTS_GROUPED_STORAGE_KEY, grouped))
+$panesFlipped.subscribe(flipped => persistBoolean(PANES_FLIPPED_STORAGE_KEY, flipped))
+
+export function setSidebarWidth(width: number) {
+  const bounded = Math.min(SIDEBAR_MAX_WIDTH, Math.max(SIDEBAR_DEFAULT_WIDTH, width))
+  setPaneWidthOverride(CHAT_SIDEBAR_PANE_ID, bounded)
+}
+
+export function setSidebarOpen(open: boolean) {
+  setPaneOpen(CHAT_SIDEBAR_PANE_ID, open)
+}
+
+export function toggleSidebarOpen() {
+  togglePane(CHAT_SIDEBAR_PANE_ID)
+}
+
+export function toggleFileBrowserOpen() {
+  togglePane(FILE_BROWSER_PANE_ID)
+}
+
+export function setFileBrowserOpen(open: boolean) {
+  setPaneOpen(FILE_BROWSER_PANE_ID, open)
+}
+
+// Hotkey → focus the sessions search field. Opens the sidebar first, then lets
+// the field (which only mounts when the sidebar is open) subscribe + focus.
+export const SESSION_SEARCH_FOCUS_EVENT = 'NASTECH:focus-session-search'
+
+export function requestSessionSearchFocus() {
+  setSidebarOpen(true)
+
+  if (typeof window !== 'undefined') {
+    window.setTimeout(() => window.dispatchEvent(new CustomEvent(SESSION_SEARCH_FOCUS_EVENT)), 0)
+  }
+}
+
+export function togglePanesFlipped() {
+  $panesFlipped.set(!$panesFlipped.get())
+}
+
+export function selectRightRailTab(id: RightRailTabId) {
+  $rightRailActiveTabId.set(id)
+}
+
+export function setSidebarPinsOpen(open: boolean) {
+  $sidebarPinsOpen.set(open)
+}
+
+export function setSidebarRecentsOpen(open: boolean) {
+  $sidebarRecentsOpen.set(open)
+}
+
+export function setSidebarCronOpen(open: boolean) {
+  $sidebarCronOpen.set(open)
+}
+
+export function setSidebarAgentsGrouped(grouped: boolean) {
+  $sidebarAgentsGrouped.set(grouped)
+}
+
+export function setSidebarResizing(resizing: boolean) {
+  $isSidebarResizing.set(resizing)
+}
+
+export function pinSession(sessionId: string, index?: number) {
+  const prev = $pinnedSessionIds.get()
+  const next = insertUniqueId(prev, sessionId, index ?? prev.filter(id => id !== sessionId).length)
+
+  if (!arraysEqual(prev, next)) {
+    $pinnedSessionIds.set(next)
+  }
+}
+
+export function unpinSession(sessionId: string) {
+  const prev = $pinnedSessionIds.get()
+  const next = prev.filter(id => id !== sessionId)
+
+  if (!arraysEqual(prev, next)) {
+    $pinnedSessionIds.set(next)
+  }
+}
+
+export function reorderPinnedSession(sessionId: string, targetIndex: number) {
+  const prev = $pinnedSessionIds.get()
+
+  if (!prev.includes(sessionId)) {
+    return
+  }
+
+  const next = insertUniqueId(prev, sessionId, targetIndex)
+
+  if (!arraysEqual(prev, next)) {
+    $pinnedSessionIds.set(next)
+  }
+}
+
+export function bumpSessionsLimit(step: number = SIDEBAR_SESSIONS_PAGE_SIZE) {
+  const safeStep = Math.max(1, Math.floor(step))
+  $sessionsLimit.set($sessionsLimit.get() + safeStep)
+}
+
+export function resetSessionsLimit() {
+  if ($sessionsLimit.get() !== SIDEBAR_SESSIONS_PAGE_SIZE) {
+    $sessionsLimit.set(SIDEBAR_SESSIONS_PAGE_SIZE)
+  }
+}

package/src/store/model-presets.test.ts

@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import { $modelPresets, applyModelPreset, getModelPreset, modelPresetKey, setModelPreset } from './model-presets'
+
+describe('model presets', () => {
+  beforeEach(() => $modelPresets.set({}))
+
+  it('round-trips a preset and merges patches without dropping prior fields', () => {
+    setModelPreset('anthropic', 'claude-opus-4-8', { effort: 'high' })
+    setModelPreset('anthropic', 'claude-opus-4-8', { fast: true })
+
+    expect(getModelPreset('anthropic', 'claude-opus-4-8')).toEqual({ effort: 'high', fast: true })
+  })
+
+  it('returns an empty preset for unknown models', () => {
+    expect(getModelPreset('x', 'y')).toEqual({})
+  })
+
+  it('keys by provider::model', () => {
+    expect(modelPresetKey('openai', 'gpt-5.5')).toBe('openai::gpt-5.5')
+  })
+
+  it('pushes only the provided dimensions to the gateway', async () => {
+    const calls: { method: string; params?: Record<string, unknown> }[] = []
+
+    const request = async <T>(method: string, params?: Record<string, unknown>) => {
+      calls.push({ method, params })
+
+      return {} as T
+    }
+
+    await applyModelPreset({ effort: 'high' }, { failMessage: 'x', request, sessionId: 's1' })
+    await applyModelPreset({}, { failMessage: 'x', request, sessionId: 's1' })
+
+    expect(calls).toEqual([{ method: 'config.set', params: { key: 'reasoning', session_id: 's1', value: 'high' } }])
+  })
+
+  it('no-ops without a session so selecting a model cannot mutate global config', async () => {
+    const calls: { method: string; params?: Record<string, unknown> }[] = []
+
+    const request = async <T>(method: string, params?: Record<string, unknown>) => {
+      calls.push({ method, params })
+
+      return {} as T
+    }
+
+    await applyModelPreset({ effort: 'high', fast: true }, { failMessage: 'x', request, sessionId: null })
+
+    expect(calls).toEqual([])
+  })
+})