nastechai-desktop 18.1.0

package/src/store/translucency.ts

@@ -0,0 +1,38 @@
+/**
+ * Window translucency (see-through window).
+ *
+ * One lever, 0–100. 0 = off (fully opaque, the default). Higher = more of the
+ * desktop shows through the whole window — the main process maps it to the
+ * native window opacity (`setOpacity`), the same effect as the Windows
+ * shift-scroll trick. macOS + Windows only; Linux has no runtime window
+ * opacity, so it's a no-op there.
+ *
+ * The renderer owns the value and mirrors it to the main process over IPC.
+ */
+
+import { atom } from 'nanostores'
+
+import { persistString, storedString } from '@/lib/storage'
+
+const KEY = 'nastech.desktop.translucency.v1'
+
+const clamp = (n: number): number => Math.min(100, Math.max(0, Math.round(n)))
+
+const read = (): number => {
+  const n = Number(storedString(KEY))
+
+  return Number.isFinite(n) ? clamp(n) : 0
+}
+
+export const $translucency = atom<number>(typeof window === 'undefined' ? 0 : read())
+
+export function setTranslucency(intensity: number): void {
+  $translucency.set(clamp(intensity))
+}
+
+if (typeof window !== 'undefined') {
+  $translucency.subscribe(intensity => {
+    persistString(KEY, String(intensity))
+    window.NASTECHDesktop?.setTranslucency?.({ intensity })
+  })
+}

package/src/store/updates.test.ts

@@ -0,0 +1,77 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { DesktopUpdateStatus } from '@/global'
+
+const storage = new Map<string, string>()
+
+vi.mock('@/lib/storage', () => ({
+  persistString: (key: string, value: null | string) => {
+    if (value === null) {
+      storage.delete(key)
+    } else {
+      storage.set(key, value)
+    }
+  },
+  storedString: (key: string) => storage.get(key) ?? null
+}))
+
+const notifySpy = vi.fn()
+const dismissSpy = vi.fn()
+
+vi.mock('@/store/notifications', () => ({
+  notify: (...args: unknown[]) => notifySpy(...args),
+  dismissNotification: (...args: unknown[]) => dismissSpy(...args)
+}))
+
+const { maybeNotifyUpdateAvailable } = await import('./updates')
+
+const status = (over: Partial<DesktopUpdateStatus> = {}): DesktopUpdateStatus => ({
+  supported: true,
+  behind: 3,
+  targetSha: 'sha-a',
+  fetchedAt: 0,
+  ...over
+})
+
+const lastToast = () => notifySpy.mock.calls.at(-1)?.[0] as { onDismiss: () => void }
+
+describe('maybeNotifyUpdateAvailable', () => {
+  beforeEach(() => {
+    storage.clear()
+    notifySpy.mockClear()
+    vi.useRealTimers()
+  })
+
+  it('shows when an update is available and not snoozed', () => {
+    maybeNotifyUpdateAvailable(status())
+    expect(notifySpy).toHaveBeenCalledTimes(1)
+  })
+
+  it('stays quiet for new commits once the toast was closed', () => {
+    maybeNotifyUpdateAvailable(status())
+    lastToast().onDismiss() // user closes it → cooldown starts
+    notifySpy.mockClear()
+
+    // A different commit lands while still within the cooldown window.
+    maybeNotifyUpdateAvailable(status({ targetSha: 'sha-b', behind: 9 }))
+    expect(notifySpy).not.toHaveBeenCalled()
+  })
+
+  it('re-shows once the cooldown elapses', () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(0)
+
+    maybeNotifyUpdateAvailable(status())
+    lastToast().onDismiss()
+    notifySpy.mockClear()
+
+    vi.setSystemTime(25 * 60 * 60 * 1000) // > 24h cooldown
+    maybeNotifyUpdateAvailable(status({ targetSha: 'sha-b' }))
+    expect(notifySpy).toHaveBeenCalledTimes(1)
+  })
+
+  it('does nothing when already up to date', () => {
+    maybeNotifyUpdateAvailable(status({ behind: 0 }))
+    expect(notifySpy).not.toHaveBeenCalled()
+  })
+})

package/src/store/updates.ts

@@ -0,0 +1,315 @@
+/**
+ * Desktop self-update store. Tracks distance from the configured branch,
+ * surfaces it as an ambient pill, and orchestrates the apply flow.
+ */
+
+import { atom } from 'nanostores'
+
+import type {
+  DesktopUpdateApplyOptions,
+  DesktopUpdateApplyResult,
+  DesktopUpdateProgress,
+  DesktopUpdateStage,
+  DesktopUpdateStatus,
+  DesktopVersionInfo
+} from '@/global'
+import { translateNow } from '@/i18n'
+import { persistString, storedString } from '@/lib/storage'
+import { dismissNotification, notify } from '@/store/notifications'
+
+export interface UpdateApplyState {
+  applying: boolean
+  stage: DesktopUpdateStage
+  message: string
+  percent: number | null
+  error: string | null
+  /** When the stage is 'manual': the exact command the user should run
+   *  (CLI install with no staged updater). */
+  command: string | null
+  log: readonly { stage: DesktopUpdateStage; message: string; at: number }[]
+}
+
+const IDLE: UpdateApplyState = {
+  applying: false,
+  stage: 'idle',
+  message: '',
+  percent: null,
+  error: null,
+  command: null,
+  log: []
+}
+
+export const $desktopVersion = atom<DesktopVersionInfo | null>(null)
+export const $updateApply = atom<UpdateApplyState>(IDLE)
+export const $updateChecking = atom<boolean>(false)
+export const $updateOverlayOpen = atom<boolean>(false)
+export const $updateStatus = atom<DesktopUpdateStatus | null>(null)
+
+export const setUpdateOverlayOpen = (open: boolean) => $updateOverlayOpen.set(open)
+export const resetUpdateApplyState = () => $updateApply.set(IDLE)
+
+const UPDATE_TOAST_ID = 'desktop-update-available'
+// Time-based snooze instead of per-sha dismissal: this repo lands ~100 commits
+// a day, so a "don't show this exact sha again" guard re-popped the toast on
+// every new commit. We instead suppress the toast for a cooldown window that
+// (re)starts whenever the user closes it.
+const UPDATE_TOAST_SNOOZE_KEY = 'NASTECH:update-toast-snooze-until'
+const UPDATE_TOAST_COOLDOWN_MS = 24 * 60 * 60 * 1000
+
+function snoozeUpdateToast(): void {
+  persistString(UPDATE_TOAST_SNOOZE_KEY, String(Date.now() + UPDATE_TOAST_COOLDOWN_MS))
+}
+
+function isUpdateToastSnoozed(): boolean {
+  const until = Number(storedString(UPDATE_TOAST_SNOOZE_KEY) || 0)
+
+  return Number.isFinite(until) && Date.now() < until
+}
+
+// Must match tui_gateway's DESKTOP_BACKEND_CONTRACT that this build was written
+// against. The backend reports its own value in session runtime info; a lower
+// value (or none — a pre-GUI checkout) means GUI<->backend skew.
+const REQUIRED_BACKEND_CONTRACT = 1
+const SKEW_TOAST_ID = 'backend-contract-skew'
+
+/**
+ * Guard against a desktop GUI talking to a backend that predates its contract
+ * (e.g. a bb/gui-built app pointed at a `main` checkout). Rather than failing
+ * cryptically downstream, surface a persistent warning with a one-click align
+ * that runs the normal update flow (which self-heals to the right branch).
+ */
+export function reportBackendContract(contract: number | undefined): void {
+  if ((contract ?? 0) >= REQUIRED_BACKEND_CONTRACT) {
+    dismissNotification(SKEW_TOAST_ID)
+
+    return
+  }
+
+  notify({
+    action: { label: translateNow('notifications.updateNasTech'), onClick: () => void applyUpdates() },
+    durationMs: 0,
+    id: SKEW_TOAST_ID,
+    kind: 'warning',
+    message: translateNow('notifications.backendOutOfDateMessage'),
+    title: translateNow('notifications.backendOutOfDateTitle')
+  })
+}
+
+/**
+ * Fire a toast when an update is available, at most once per cooldown window.
+ * Closing the toast — dismissing it or opening the updates window from it —
+ * (re)starts the cooldown, so a busy upstream branch doesn't re-spam the user
+ * on every new commit. The snooze is persisted, so it survives relaunches too.
+ */
+export function maybeNotifyUpdateAvailable(status: DesktopUpdateStatus | null) {
+  if (!status || status.supported === false || status.error || !status.targetSha) {
+    return
+  }
+
+  if ((status.behind ?? 0) <= 0) {
+    return
+  }
+
+  if (isUpdateToastSnoozed()) {
+    return
+  }
+
+  if ($updateApply.get().applying) {
+    return
+  }
+
+  const behind = status.behind ?? 0
+
+  notify({
+    action: {
+      label: translateNow('notifications.seeWhatsNew'),
+      onClick: () => {
+        snoozeUpdateToast()
+        openUpdatesWindow()
+      }
+    },
+    durationMs: 0,
+    id: UPDATE_TOAST_ID,
+    kind: 'info',
+    message: translateNow('notifications.updateReadyMessage', behind),
+    onDismiss: () => snoozeUpdateToast(),
+    title: translateNow('notifications.updateReadyTitle')
+  })
+}
+
+/**
+ * Opens the updates dialog and kicks off a fresh check so the user always
+ * sees current state, even if a stale status is cached from earlier.
+ */
+export function openUpdatesWindow(): void {
+  $updateOverlayOpen.set(true)
+  void checkUpdates()
+}
+
+/** Re-read the running app's version from the Electron main process and
+ *  publish it on `$desktopVersion`. Called when the About panel mounts, the
+ *  update flow finishes, and the window regains focus, so the About text
+ *  stays in sync with the just-installed binary instead of frozen at the
+ *  value captured at first-load. */
+export async function refreshDesktopVersion(): Promise<DesktopVersionInfo | null> {
+  if (typeof window === 'undefined') {
+    return null
+  }
+
+  // Best-effort UI sync: callers (checkUpdates, startUpdatePoller, window
+  // focus handler) all kick this off with `void refreshDesktopVersion()`,
+  // so any rejection from the IPC bridge (e.g. main process shutting down
+  // mid-reload, or the bridge not yet ready on first paint) would surface
+  // as an unhandled promise rejection in the renderer. Swallow it.
+  try {
+    const next = await window.NASTECHDesktop?.getVersion?.()
+
+    if (next) {
+      $desktopVersion.set(next)
+    }
+
+    return next ?? null
+  } catch {
+    return null
+  }
+}
+
+export async function checkUpdates(): Promise<DesktopUpdateStatus | null> {
+  const bridge = window.NASTECHDesktop?.updates
+
+  if (!bridge || $updateChecking.get()) {
+    return $updateStatus.get()
+  }
+
+  $updateChecking.set(true)
+
+  try {
+    const status = await bridge.check()
+    $updateStatus.set(status)
+    maybeNotifyUpdateAvailable(status)
+    // The update check pulls the latest nastech_cli + bundled package metadata
+    // into place. Re-read the running version so About reflects the now-fresh
+    // checkout rather than the one captured at process start.
+    void refreshDesktopVersion()
+
+    return status
+  } catch (error) {
+    const previous = $updateStatus.get()
+
+    const fallback: DesktopUpdateStatus = {
+      supported: previous?.supported ?? true,
+      branch: previous?.branch,
+      error: 'check-failed',
+      message: error instanceof Error ? error.message : String(error),
+      fetchedAt: Date.now()
+    }
+
+    $updateStatus.set(fallback)
+
+    return fallback
+  } finally {
+    $updateChecking.set(false)
+  }
+}
+
+export async function applyUpdates(opts: DesktopUpdateApplyOptions = {}): Promise<DesktopUpdateApplyResult> {
+  const bridge = window.NASTECHDesktop?.updates
+
+  if (!bridge) {
+    return { ok: false, error: 'unavailable', message: 'Desktop bridge unavailable.' }
+  }
+
+  dismissNotification(UPDATE_TOAST_ID)
+  $updateApply.set({ ...IDLE, applying: true, stage: 'prepare', message: 'Starting update…' })
+
+  try {
+    const result = await bridge.apply(opts)
+
+    // CLI install with no staged updater: not an error — the user just runs
+    // `NASTECH update` themselves. Land on a dedicated manual state so the
+    // overlay shows the command + copy button instead of a dead retry loop.
+    if (result?.manual) {
+      $updateApply.set({
+        ...IDLE,
+        applying: false,
+        stage: 'manual',
+        message: result.command ?? 'NASTECH update',
+        command: result.command ?? 'NASTECH update'
+      })
+    }
+
+    return result
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    $updateApply.set({ ...$updateApply.get(), applying: false, stage: 'error', error: 'apply-failed', message })
+
+    return { ok: false, error: 'apply-failed', message }
+  }
+}
+
+function ingestProgress(payload: DesktopUpdateProgress): void {
+  const current = $updateApply.get()
+  const log = [...current.log, { stage: payload.stage, message: payload.message, at: payload.at }].slice(-50)
+  const terminal = payload.stage === 'error' || payload.stage === 'restart' || payload.stage === 'manual'
+
+  $updateApply.set({
+    applying: !terminal,
+    stage: payload.stage,
+    message: payload.message,
+    percent: payload.percent,
+    error: payload.error,
+    // 'manual' carries the command to run in its message field.
+    command: payload.stage === 'manual' ? payload.message : current.command,
+    log
+  })
+}
+
+let pollerStarted = false
+let backgroundTimer: ReturnType<typeof setInterval> | null = null
+let lastFocusAt = 0
+
+/** Wire up background polling + progress streaming. Idempotent. */
+export function startUpdatePoller(): void {
+  if (pollerStarted || typeof window === 'undefined') {
+    return
+  }
+
+  const bridge = window.NASTECHDesktop?.updates
+
+  if (!bridge) {
+    return
+  }
+
+  pollerStarted = true
+  void checkUpdates()
+  void refreshDesktopVersion()
+  bridge.onProgress(ingestProgress)
+
+  window.addEventListener('focus', onFocus)
+  backgroundTimer = setInterval(() => void checkUpdates(), 30 * 60 * 1000)
+}
+
+export function stopUpdatePoller(): void {
+  if (backgroundTimer !== null) {
+    clearInterval(backgroundTimer)
+    backgroundTimer = null
+  }
+
+  window.removeEventListener('focus', onFocus)
+  pollerStarted = false
+}
+
+function onFocus() {
+  const now = Date.now()
+
+  if (now - lastFocusAt < 5 * 60 * 1000) {
+    return
+  }
+
+  lastFocusAt = now
+  void checkUpdates()
+  // Cheap and safe to re-read on every (throttled) focus: the user may have
+  // updated NasTech from another window/CLI between focuses, and About should
+  // catch up without forcing a restart.
+  void refreshDesktopVersion()
+}

package/src/store/voice-playback.ts

@@ -0,0 +1,24 @@
+import { atom } from 'nanostores'
+
+export type VoicePlaybackSource = 'read-aloud' | 'voice-conversation'
+export type VoicePlaybackStatus = 'idle' | 'preparing' | 'speaking'
+
+export interface VoicePlaybackState {
+  audioElement: HTMLAudioElement | null
+  messageId: string | null
+  sequence: number
+  source: VoicePlaybackSource | null
+  status: VoicePlaybackStatus
+}
+
+export const $voicePlayback = atom<VoicePlaybackState>({
+  audioElement: null,
+  messageId: null,
+  sequence: 0,
+  source: null,
+  status: 'idle'
+})
+
+export function setVoicePlaybackState(next: VoicePlaybackState) {
+  $voicePlayback.set(next)
+}

package/src/store/windows.test.ts

@@ -0,0 +1,143 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { canOpenSessionWindow, openNewSessionInNewWindow, openSessionInNewWindow } from './windows'
+
+const desktopWindow = window as unknown as { nastechDesktop?: Window['nastechDesktop'] }
+const initialNasTechDesktop = desktopWindow.nastechDesktop
+
+const notifyError = vi.fn()
+
+vi.mock('./notifications', () => ({
+  notifyError: (...args: unknown[]) => notifyError(...args)
+}))
+
+function installBridge(
+  openSessionWindow?: Window['nastechDesktop']['openSessionWindow'],
+  openNewSessionWindow?: Window['nastechDesktop']['openNewSessionWindow']
+) {
+  desktopWindow.nastechDesktop = {
+    ...(openSessionWindow ? { openSessionWindow } : {}),
+    ...(openNewSessionWindow ? { openNewSessionWindow } : {})
+  } as unknown as Window['nastechDesktop']
+}
+
+beforeEach(() => {
+  notifyError.mockClear()
+})
+
+afterEach(() => {
+  if (initialNasTechDesktop) {
+    desktopWindow.nastechDesktop = initialNasTechDesktop
+  } else {
+    delete desktopWindow.nastechDesktop
+  }
+})
+
+describe('canOpenSessionWindow', () => {
+  it('is false when the desktop bridge is absent', () => {
+    delete desktopWindow.nastechDesktop
+    expect(canOpenSessionWindow()).toBe(false)
+  })
+
+  it('is false when the bridge lacks openSessionWindow', () => {
+    installBridge(undefined)
+    expect(canOpenSessionWindow()).toBe(false)
+  })
+
+  it('is true when the bridge exposes openSessionWindow', () => {
+    installBridge(vi.fn().mockResolvedValue({ ok: true }))
+    expect(canOpenSessionWindow()).toBe(true)
+  })
+})
+
+describe('openSessionInNewWindow', () => {
+  it('no-ops without a session id', async () => {
+    const open = vi.fn().mockResolvedValue({ ok: true })
+    installBridge(open)
+
+    await openSessionInNewWindow('')
+
+    expect(open).not.toHaveBeenCalled()
+    expect(notifyError).not.toHaveBeenCalled()
+  })
+
+  it('no-ops gracefully when the bridge is absent (web fallback)', async () => {
+    delete desktopWindow.nastechDesktop
+
+    await openSessionInNewWindow('s1')
+
+    expect(notifyError).not.toHaveBeenCalled()
+  })
+
+  it('invokes the bridge with the session id', async () => {
+    const open = vi.fn().mockResolvedValue({ ok: true })
+    installBridge(open)
+
+    await openSessionInNewWindow('s1')
+
+    expect(open).toHaveBeenCalledWith('s1', undefined)
+    expect(notifyError).not.toHaveBeenCalled()
+  })
+
+  it('forwards the watch flag for spectator (subagent) windows', async () => {
+    const open = vi.fn().mockResolvedValue({ ok: true })
+    installBridge(open)
+
+    await openSessionInNewWindow('s1', { watch: true })
+
+    expect(open).toHaveBeenCalledWith('s1', { watch: true })
+    expect(notifyError).not.toHaveBeenCalled()
+  })
+
+  it('notifies on an ok:false result', async () => {
+    installBridge(vi.fn().mockResolvedValue({ ok: false, error: 'invalid-session-id' }))
+
+    await openSessionInNewWindow('s1')
+
+    expect(notifyError).toHaveBeenCalledTimes(1)
+  })
+
+  it('notifies when the bridge throws', async () => {
+    installBridge(vi.fn().mockRejectedValue(new Error('boom')))
+
+    await openSessionInNewWindow('s1')
+
+    expect(notifyError).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('openNewSessionInNewWindow', () => {
+  it('no-ops gracefully when the bridge is absent (web fallback)', async () => {
+    delete desktopWindow.nastechDesktop
+
+    await openNewSessionInNewWindow()
+
+    expect(notifyError).not.toHaveBeenCalled()
+  })
+
+  it('no-ops when openNewSessionWindow is missing', async () => {
+    installBridge(vi.fn().mockResolvedValue({ ok: true }))
+
+    await openNewSessionInNewWindow()
+
+    expect(notifyError).not.toHaveBeenCalled()
+  })
+
+  it('invokes the bridge', async () => {
+    const openNew = vi.fn().mockResolvedValue({ ok: true })
+    installBridge(vi.fn().mockResolvedValue({ ok: true }), openNew)
+
+    await openNewSessionInNewWindow()
+
+    expect(openNew).toHaveBeenCalledTimes(1)
+    expect(notifyError).not.toHaveBeenCalled()
+  })
+
+  it('notifies on an ok:false result', async () => {
+    installBridge(vi.fn().mockResolvedValue({ ok: true }), vi.fn().mockResolvedValue({ ok: false, error: 'nope' }))
+
+    await openNewSessionInNewWindow()
+
+    expect(notifyError).toHaveBeenCalledTimes(1)
+  })
+})

package/src/store/windows.ts

@@ -0,0 +1,77 @@
+import { notifyError } from './notifications'
+
+// Window flag set by the Electron main process when it opens a standalone
+// session window (see electron/main.cjs buildSessionWindowUrl). It rides in the
+// query string BEFORE the HashRouter '#', so we read it from location.search,
+// never from the router. A "secondary" window renders a single chat without the
+// global session sidebar or the install / onboarding overlays.
+const SECONDARY_WINDOW_FLAG = 'secondary'
+
+let secondaryWindowCache: boolean | null = null
+
+export function isSecondaryWindow(): boolean {
+  if (secondaryWindowCache !== null) {
+    return secondaryWindowCache
+  }
+
+  let result = false
+
+  try {
+    result = new URLSearchParams(window.location.search).get('win') === SECONDARY_WINDOW_FLAG
+  } catch {
+    result = false
+  }
+
+  secondaryWindowCache = result
+
+  return result
+}
+
+let watchWindowCache: boolean | null = null
+
+// A "watch" window spectates a session that is being driven elsewhere (a
+// running subagent). It resumes lazily — the gateway registers history + a
+// transport for the live mirror without building an agent, so opening it is
+// cheap even while the backend is busy running the delegation.
+export function isWatchWindow(): boolean {
+  if (watchWindowCache !== null) {
+    return watchWindowCache
+  }
+
+  let result = false
+
+  try {
+    result = new URLSearchParams(window.location.search).get('watch') === '1'
+  } catch {
+    result = false
+  }
+
+  watchWindowCache = result
+
+  return result
+}
+
+// True when running inside the Electron desktop shell (the preload bridge is
+// present). The "open in new window" affordance is desktop-only.
+export function canOpenSessionWindow(): boolean {
+  return typeof window !== 'undefined' && typeof window.NASTECHDesktop?.openSessionWindow === 'function'
+}
+
+// Open (or focus) a standalone OS window for a single chat session. No-ops
+// gracefully outside Electron so callers can wire it unconditionally.
+// `watch: true` opens a spectator window (lazy resume, live-mirror stream).
+export async function openSessionInNewWindow(sessionId: string, opts?: { watch?: boolean }): Promise<void> {
+  if (!sessionId || !canOpenSessionWindow()) {
+    return
+  }
+
+  try {
+    const result = await window.NASTECHDesktop.openSessionWindow(sessionId, opts)
+
+    if (!result?.ok) {
+      notifyError(new Error(result?.error || 'unknown error'), 'Could not open chat in a new window')
+    }
+  } catch (err) {
+    notifyError(err, 'Could not open chat in a new window')
+  }
+}