nastechai-desktop 18.1.0

package/src/store/panes.test.ts

@@ -0,0 +1,146 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import {
+  $paneOpen,
+  $paneStates,
+  $paneWidthOverride,
+  clearPaneWidthOverride,
+  ensurePaneRegistered,
+  getPaneStateSnapshot,
+  setPaneOpen,
+  setPaneWidthOverride,
+  togglePane
+} from './panes'
+
+const STORAGE_KEY = 'NASTECH.desktop.paneStates.v1'
+
+describe('panes store', () => {
+  beforeEach(() => {
+    $paneStates.set({})
+    window.localStorage.clear()
+  })
+
+  afterEach(() => {
+    $paneStates.set({})
+    window.localStorage.clear()
+  })
+
+  describe('ensurePaneRegistered', () => {
+    it('adds a pane with defaults when missing', () => {
+      ensurePaneRegistered('files', { open: true })
+
+      expect(getPaneStateSnapshot('files')).toEqual({ open: true, widthOverride: undefined })
+    })
+
+    it('is a no-op when the pane already exists', () => {
+      ensurePaneRegistered('files', { open: false })
+      ensurePaneRegistered('files', { open: true })
+
+      expect(getPaneStateSnapshot('files')?.open).toBe(false)
+    })
+
+    it('preserves an existing widthOverride when re-registering', () => {
+      ensurePaneRegistered('files', { open: true })
+      setPaneWidthOverride('files', 360)
+      ensurePaneRegistered('files', { open: false })
+
+      expect(getPaneStateSnapshot('files')?.widthOverride).toBe(360)
+    })
+  })
+
+  describe('setPaneOpen / togglePane', () => {
+    it('updates the pane open flag', () => {
+      ensurePaneRegistered('files', { open: false })
+      setPaneOpen('files', true)
+
+      expect(getPaneStateSnapshot('files')?.open).toBe(true)
+    })
+
+    it('togglePane flips the current value', () => {
+      ensurePaneRegistered('files', { open: false })
+      togglePane('files')
+      togglePane('files')
+      togglePane('files')
+
+      expect(getPaneStateSnapshot('files')?.open).toBe(true)
+    })
+
+    it('togglePane on an unregistered id starts from false', () => {
+      togglePane('ephemeral')
+
+      expect(getPaneStateSnapshot('ephemeral')?.open).toBe(true)
+    })
+
+    it('preserves widthOverride across open/close changes', () => {
+      ensurePaneRegistered('files', { open: true })
+      setPaneWidthOverride('files', 280)
+      setPaneOpen('files', false)
+      setPaneOpen('files', true)
+
+      expect(getPaneStateSnapshot('files')?.widthOverride).toBe(280)
+    })
+  })
+
+  describe('width overrides', () => {
+    it('setPaneWidthOverride stores the px value', () => {
+      ensurePaneRegistered('files', { open: true })
+      setPaneWidthOverride('files', 300)
+
+      expect(getPaneStateSnapshot('files')?.widthOverride).toBe(300)
+    })
+
+    it('clearPaneWidthOverride removes the override', () => {
+      ensurePaneRegistered('files', { open: true })
+      setPaneWidthOverride('files', 300)
+      clearPaneWidthOverride('files')
+
+      expect(getPaneStateSnapshot('files')?.widthOverride).toBeUndefined()
+    })
+
+    it('width override is in-memory only — not persisted across reloads', () => {
+      ensurePaneRegistered('files', { open: true })
+      setPaneWidthOverride('files', 300)
+
+      const persisted = window.localStorage.getItem(STORAGE_KEY)
+
+      expect(persisted).not.toBeNull()
+      expect(JSON.parse(persisted ?? '{}')).toEqual({ files: { open: true } })
+    })
+
+    it('open flag is persisted across changes', () => {
+      ensurePaneRegistered('files', { open: false })
+      setPaneOpen('files', true)
+
+      const persisted = window.localStorage.getItem(STORAGE_KEY)
+
+      expect(persisted).not.toBeNull()
+      expect(JSON.parse(persisted ?? '{}')).toEqual({ files: { open: true } })
+    })
+  })
+
+  describe('derived atoms', () => {
+    it('$paneOpen reflects the pane state', () => {
+      const open$ = $paneOpen('files')
+      expect(open$.get()).toBe(false)
+
+      ensurePaneRegistered('files', { open: true })
+      expect(open$.get()).toBe(true)
+
+      setPaneOpen('files', false)
+      expect(open$.get()).toBe(false)
+    })
+
+    it('$paneWidthOverride reflects the width', () => {
+      const width$ = $paneWidthOverride('files')
+      expect(width$.get()).toBeUndefined()
+
+      ensurePaneRegistered('files', { open: true })
+      setPaneWidthOverride('files', 240)
+      expect(width$.get()).toBe(240)
+    })
+
+    it('$paneOpen returns the same atom instance for repeated calls', () => {
+      expect($paneOpen('files')).toBe($paneOpen('files'))
+    })
+  })
+})

package/src/store/panes.ts

@@ -0,0 +1,145 @@
+import { atom, computed, type ReadableAtom } from 'nanostores'
+
+export interface PaneStateSnapshot {
+  open: boolean
+  widthOverride?: number
+}
+
+export interface PaneRegisterDefaults {
+  open: boolean
+  widthOverride?: number
+}
+
+const STORAGE_KEY = 'NASTECH.desktop.paneStates.v1'
+
+function isSnapshot(value: unknown): value is PaneStateSnapshot {
+  if (!value || typeof value !== 'object') {
+    return false
+  }
+
+  const r = value as Record<string, unknown>
+
+  if (typeof r.open !== 'boolean') {
+    return false
+  }
+
+  return r.widthOverride === undefined || (typeof r.widthOverride === 'number' && Number.isFinite(r.widthOverride))
+}
+
+function load(): Record<string, PaneStateSnapshot> {
+  if (typeof window === 'undefined') {
+    return {}
+  }
+
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY)
+
+    if (raw) {
+      const parsed = JSON.parse(raw) as unknown
+
+      if (parsed && typeof parsed === 'object') {
+        const out: Record<string, PaneStateSnapshot> = {}
+
+        for (const [id, value] of Object.entries(parsed as Record<string, unknown>)) {
+          if (isSnapshot(value)) {
+            out[id] = { open: value.open, widthOverride: value.widthOverride }
+          }
+        }
+
+        return out
+      }
+    }
+  } catch {
+    // Treat unparseable persisted state as missing.
+  }
+
+  return {}
+}
+
+// widthOverride is in-memory only — phase 2 can add per-pane persistWidth opt-in.
+function persist(states: Record<string, PaneStateSnapshot>) {
+  if (typeof window === 'undefined') {
+    return
+  }
+
+  const minimal: Record<string, { open: boolean }> = {}
+
+  for (const [id, s] of Object.entries(states)) {
+    minimal[id] = { open: s.open }
+  }
+
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(minimal))
+  } catch {
+    // Storage failures are nonfatal.
+  }
+}
+
+export const $paneStates = atom<Record<string, PaneStateSnapshot>>(load())
+
+$paneStates.subscribe(persist)
+
+// Cached per-pane derived atoms keep useStore subscriptions referentially stable.
+function memoized<T>(
+  cache: Map<string, ReadableAtom<T>>,
+  id: string,
+  selector: (s: PaneStateSnapshot | undefined) => T
+) {
+  let cached = cache.get(id)
+
+  if (!cached) {
+    cached = computed($paneStates, states => selector(states[id]))
+    cache.set(id, cached)
+  }
+
+  return cached
+}
+
+const openCache = new Map<string, ReadableAtom<boolean>>()
+const stateCache = new Map<string, ReadableAtom<PaneStateSnapshot | undefined>>()
+const widthCache = new Map<string, ReadableAtom<number | undefined>>()
+
+export const $paneOpen = (id: string) => memoized(openCache, id, s => s?.open ?? false)
+export const $paneState = (id: string) => memoized(stateCache, id, s => s)
+export const $paneWidthOverride = (id: string) => memoized(widthCache, id, s => s?.widthOverride)
+
+export function ensurePaneRegistered(id: string, defaults: PaneRegisterDefaults) {
+  const current = $paneStates.get()
+
+  if (current[id] !== undefined) {
+    return
+  }
+
+  $paneStates.set({ ...current, [id]: { open: defaults.open, widthOverride: defaults.widthOverride } })
+}
+
+export function setPaneOpen(id: string, open: boolean) {
+  const current = $paneStates.get()
+  const existing = current[id]
+
+  if (existing?.open === open) {
+    return
+  }
+
+  $paneStates.set({ ...current, [id]: { open, widthOverride: existing?.widthOverride } })
+}
+
+export function togglePane(id: string) {
+  const current = $paneStates.get()
+  const existing = current[id]
+  $paneStates.set({ ...current, [id]: { open: !(existing?.open ?? false), widthOverride: existing?.widthOverride } })
+}
+
+export function setPaneWidthOverride(id: string, width: number | undefined) {
+  const current = $paneStates.get()
+  const existing = current[id] ?? { open: false }
+
+  if (existing.widthOverride === width) {
+    return
+  }
+
+  $paneStates.set({ ...current, [id]: { open: existing.open, widthOverride: width } })
+}
+
+export const clearPaneWidthOverride = (id: string) => setPaneWidthOverride(id, undefined)
+export const getPaneStateSnapshot = (id: string) => $paneStates.get()[id]

package/src/store/preview.test.ts

@@ -0,0 +1,135 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import { $rightRailActiveTabId, RIGHT_RAIL_PREVIEW_TAB_ID } from './layout'
+import {
+  $filePreviewTabs,
+  $filePreviewTarget,
+  $previewServerRestart,
+  $previewServerRestartStatus,
+  $previewTarget,
+  $sessionPreviewRegistry,
+  beginPreviewServerRestart,
+  clearSessionPreviewRegistry,
+  closeActiveRightRailTab,
+  dismissPreviewTarget,
+  getSessionPreviewRecord,
+  type PreviewTarget,
+  progressPreviewServerRestart,
+  setCurrentSessionPreviewTarget
+} from './preview'
+import { $activeSessionId, $selectedStoredSessionId } from './session'
+
+function previewTarget(source: string): PreviewTarget {
+  return {
+    kind: 'file',
+    label: source,
+    path: source,
+    previewKind: 'html',
+    source,
+    url: `file://${source}`
+  }
+}
+
+function withRenderMode(target: PreviewTarget, renderMode: PreviewTarget['renderMode']): PreviewTarget {
+  return { ...target, renderMode }
+}
+
+describe('preview store', () => {
+  beforeEach(() => {
+    $previewServerRestart.set(null)
+    $activeSessionId.set('session-1')
+    $selectedStoredSessionId.set(null)
+    window.localStorage.clear()
+    clearSessionPreviewRegistry()
+  })
+
+  afterEach(() => {
+    $previewServerRestart.set(null)
+    $activeSessionId.set(null)
+    $selectedStoredSessionId.set(null)
+    window.localStorage.clear()
+    clearSessionPreviewRegistry()
+  })
+
+  it('does not notify status subscribers for restart progress text', () => {
+    const statuses: string[] = []
+    const unsubscribe = $previewServerRestartStatus.subscribe(status => statuses.push(status))
+
+    beginPreviewServerRestart('task-1', 'http://localhost:5174')
+    progressPreviewServerRestart('task-1', 'first line')
+    progressPreviewServerRestart('task-1', 'second line')
+    unsubscribe()
+
+    expect(statuses).toEqual(['idle', 'running'])
+  })
+
+  it('persists registered previews and dismissal per session', () => {
+    const target = previewTarget('/work/demo.html')
+
+    setCurrentSessionPreviewTarget(target, 'tool-result')
+
+    expect($previewTarget.get()).toEqual(withRenderMode(target, 'preview'))
+    expect(getSessionPreviewRecord('session-1')?.normalized).toEqual(withRenderMode(target, 'preview'))
+    expect(window.localStorage.getItem('NASTECH.desktop.sessionPreviews.v1')).toContain('/work/demo.html')
+
+    dismissPreviewTarget()
+
+    expect($previewTarget.get()).toBeNull()
+    expect(getSessionPreviewRecord('session-1')).toBeNull()
+    expect($sessionPreviewRegistry.get()['session-1']?.[0]?.dismissedAt).toEqual(expect.any(Number))
+
+    setCurrentSessionPreviewTarget(target, 'tool-result')
+
+    expect(getSessionPreviewRecord('session-1')?.dismissedAt).toBeUndefined()
+  })
+
+  it('replaces the session preview instead of keeping a back stack', () => {
+    const first = previewTarget('/work/first.html')
+    const second = previewTarget('/work/second.html')
+
+    setCurrentSessionPreviewTarget(first, 'tool-result')
+    setCurrentSessionPreviewTarget(second, 'tool-result')
+
+    expect($sessionPreviewRegistry.get()['session-1']).toHaveLength(1)
+    expect(getSessionPreviewRecord('session-1')?.normalized).toEqual(withRenderMode(second, 'preview'))
+
+    dismissPreviewTarget()
+
+    expect($previewTarget.get()).toBeNull()
+    expect(getSessionPreviewRecord('session-1')).toBeNull()
+    expect($sessionPreviewRegistry.get()['session-1']?.map(record => record.normalized.url)).toEqual([
+      'file:///work/second.html'
+    ])
+  })
+
+  it('keeps file inspection separate from live preview', () => {
+    const target = previewTarget('/work/demo.html')
+    const preview = previewTarget('/work/live.html')
+
+    setCurrentSessionPreviewTarget(preview, 'tool-result')
+
+    setCurrentSessionPreviewTarget(target, 'manual')
+
+    expect($filePreviewTarget.get()).toEqual(withRenderMode(target, 'source'))
+    expect($previewTarget.get()).toEqual(withRenderMode(preview, 'preview'))
+    expect(getSessionPreviewRecord('session-1')?.normalized).toEqual(withRenderMode(preview, 'preview'))
+
+    closeActiveRightRailTab()
+
+    expect($filePreviewTarget.get()).toBeNull()
+    expect($previewTarget.get()).toEqual(withRenderMode(preview, 'preview'))
+  })
+
+  it('keeps file tabs when a live preview opens', () => {
+    const file = previewTarget('/work/file.html')
+    const live = previewTarget('/work/live.html')
+
+    setCurrentSessionPreviewTarget(file, 'manual')
+    setCurrentSessionPreviewTarget(live, 'tool-result')
+
+    expect($filePreviewTabs.get().map(tab => tab.target)).toEqual([withRenderMode(file, 'source')])
+    expect($filePreviewTarget.get()).toBeNull()
+    expect($rightRailActiveTabId.get()).toBe(RIGHT_RAIL_PREVIEW_TAB_ID)
+    expect($previewTarget.get()).toEqual(withRenderMode(live, 'preview'))
+  })
+})