nastechai-desktop 18.1.0

package/src/store/activity.ts

@@ -0,0 +1,100 @@
+import { atom } from 'nanostores'
+
+import { sessionTitle } from '@/lib/chat-runtime'
+import type { PreviewServerRestart } from '@/store/preview'
+import type { ActionStatusResponse, SessionInfo } from '@/types/nastech'
+
+const HISTORY_LIMIT = 8
+const COMPLETED_TTL_MS = 5 * 60 * 1000
+
+export type RailTaskStatus = 'error' | 'running' | 'success'
+
+export interface RailTask {
+  id: string
+  label: string
+  detail: string
+  status: RailTaskStatus
+  updatedAt: number
+}
+
+export interface DesktopActionTask {
+  status: ActionStatusResponse
+  updatedAt: number
+}
+
+export const $desktopActionTasks = atom<Record<string, DesktopActionTask>>({})
+
+export function upsertDesktopActionTask(status: ActionStatusResponse): void {
+  $desktopActionTasks.set(prune({ ...$desktopActionTasks.get(), [status.name]: { status, updatedAt: Date.now() } }))
+}
+
+export function buildRailTasks(
+  workingSessionIds: readonly string[],
+  sessions: readonly SessionInfo[],
+  previewRestart: PreviewServerRestart | null,
+  actionTasks: Record<string, DesktopActionTask>
+): RailTask[] {
+  const sessionsById = new Map(sessions.map(session => [session.id, session]))
+
+  const sessionTasks: RailTask[] = workingSessionIds.map((id, index) => {
+    const session = sessionsById.get(id)
+
+    return {
+      id: `session:${id}`,
+      label: session ? sessionTitle(session) : 'Session task',
+      detail: 'Agent task running',
+      status: 'running',
+      updatedAt: session?.last_active || Date.now() - index
+    }
+  })
+
+  const previewTasks: RailTask[] = previewRestart
+    ? [
+        {
+          id: `preview:${previewRestart.taskId}`,
+          label: 'Preview restart',
+          detail: previewRestart.message || previewRestart.url,
+          status:
+            previewRestart.status === 'error' ? 'error' : previewRestart.status === 'running' ? 'running' : 'success',
+          updatedAt: Date.now()
+        }
+      ]
+    : []
+
+  const actions: RailTask[] = Object.values(actionTasks).map(({ status, updatedAt }) => ({
+    id: `action:${status.name}`,
+    label: status.name,
+    detail: actionDetail(status),
+    status: actionStatus(status),
+    updatedAt
+  }))
+
+  return [...sessionTasks, ...previewTasks, ...actions].sort((left, right) => right.updatedAt - left.updatedAt)
+}
+
+function actionStatus(status: ActionStatusResponse): RailTaskStatus {
+  if (status.running) {
+    return 'running'
+  }
+
+  return status.exit_code === 0 ? 'success' : 'error'
+}
+
+function actionDetail(status: ActionStatusResponse): string {
+  if (status.running) {
+    return 'Running'
+  }
+
+  return status.exit_code === 0 ? 'Completed' : `Failed (${status.exit_code ?? 'unknown'})`
+}
+
+function prune(tasks: Record<string, DesktopActionTask>): Record<string, DesktopActionTask> {
+  const now = Date.now()
+
+  return Object.fromEntries(
+    Object.entries(tasks)
+      .filter(([, task]) => task.status.running || now - task.updatedAt <= COMPLETED_TTL_MS)
+      .sort(([, left], [, right]) => right.updatedAt - left.updatedAt)
+      .slice(0, HISTORY_LIMIT)
+  )
+}

package/src/store/boot.ts

@@ -0,0 +1,91 @@
+import { atom } from 'nanostores'
+
+import type { DesktopBootProgress } from '@/global'
+import { translateNow } from '@/i18n'
+
+export interface DesktopBootState extends DesktopBootProgress {
+  visible: boolean
+}
+
+const INITIAL_BOOT_STATE: DesktopBootState = {
+  error: null,
+  fakeMode: false,
+  message: translateNow('boot.steps.startingNasTechDesktop'),
+  phase: 'renderer.init',
+  progress: 2,
+  running: true,
+  timestamp: Date.now(),
+  visible: true
+}
+
+export const $desktopBoot = atom<DesktopBootState>(INITIAL_BOOT_STATE)
+
+function clampProgress(value: number) {
+  if (!Number.isFinite(value)) {
+    return 0
+  }
+
+  return Math.max(0, Math.min(100, Math.round(value)))
+}
+
+export function applyDesktopBootProgress(progress: DesktopBootProgress) {
+  const current = $desktopBoot.get()
+  const nextProgress = clampProgress(progress.progress)
+  const mergedProgress = progress.running ? Math.max(current.progress, nextProgress) : nextProgress
+
+  $desktopBoot.set({
+    ...current,
+    ...progress,
+    error: progress.error ?? null,
+    progress: mergedProgress,
+    visible: progress.running || mergedProgress < 100 || Boolean(progress.error)
+  })
+}
+
+export function setDesktopBootStep(step: {
+  phase: string
+  message: string
+  progress: number
+  running?: boolean
+  fakeMode?: boolean
+  error?: string | null
+}) {
+  const current = $desktopBoot.get()
+  applyDesktopBootProgress({
+    error: step.error ?? null,
+    fakeMode: step.fakeMode ?? current.fakeMode,
+    message: step.message,
+    phase: step.phase,
+    progress: step.progress,
+    running: step.running ?? true,
+    timestamp: Date.now()
+  })
+}
+
+export function completeDesktopBoot(message = translateNow('boot.ready')) {
+  const current = $desktopBoot.get()
+  $desktopBoot.set({
+    ...current,
+    error: null,
+    message,
+    phase: 'renderer.ready',
+    progress: 100,
+    running: false,
+    timestamp: Date.now(),
+    visible: false
+  })
+}
+
+export function failDesktopBoot(message: string) {
+  const current = $desktopBoot.get()
+  $desktopBoot.set({
+    ...current,
+    error: message,
+    message: translateNow('boot.desktopBootFailedWithMessage', message),
+    phase: 'renderer.error',
+    progress: clampProgress(current.progress),
+    running: false,
+    timestamp: Date.now(),
+    visible: true
+  })
+}

package/src/store/clarify.test.ts

@@ -0,0 +1,81 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import {
+  $clarifyRequest,
+  $clarifyRequests,
+  type ClarifyRequest,
+  clearClarifyRequest,
+  setClarifyRequest
+} from './clarify'
+import { $activeSessionId } from './session'
+
+function clarify(sessionId: string | null, requestId: string): ClarifyRequest {
+  return {
+    requestId,
+    question: `question-${requestId}`,
+    choices: null,
+    sessionId
+  }
+}
+
+describe('clarify store', () => {
+  beforeEach(() => {
+    $clarifyRequests.set({})
+    $activeSessionId.set(null)
+  })
+
+  afterEach(() => {
+    $clarifyRequests.set({})
+    $activeSessionId.set(null)
+  })
+
+  it('keeps clarify requests from concurrent sessions independent', () => {
+    setClarifyRequest(clarify('session-a', 'req-a'))
+    setClarifyRequest(clarify('session-b', 'req-b'))
+
+    expect($clarifyRequests.get()['session-a']?.requestId).toBe('req-a')
+    expect($clarifyRequests.get()['session-b']?.requestId).toBe('req-b')
+  })
+
+  it('exposes only the active session via the focus-scoped view', () => {
+    setClarifyRequest(clarify('session-a', 'req-a'))
+    setClarifyRequest(clarify('session-b', 'req-b'))
+
+    $activeSessionId.set('session-a')
+    expect($clarifyRequest.get()?.requestId).toBe('req-a')
+
+    $activeSessionId.set('session-b')
+    expect($clarifyRequest.get()?.requestId).toBe('req-b')
+
+    $activeSessionId.set('session-c')
+    expect($clarifyRequest.get()).toBeNull()
+  })
+
+  it('clears only the targeted session, leaving the other pending', () => {
+    setClarifyRequest(clarify('session-a', 'req-a'))
+    setClarifyRequest(clarify('session-b', 'req-b'))
+
+    clearClarifyRequest('req-a', 'session-a')
+
+    expect($clarifyRequests.get()['session-a']).toBeUndefined()
+    expect($clarifyRequests.get()['session-b']?.requestId).toBe('req-b')
+  })
+
+  it('ignores a stale clear whose request id no longer matches', () => {
+    setClarifyRequest(clarify('session-a', 'req-a2'))
+
+    clearClarifyRequest('req-a1', 'session-a')
+
+    expect($clarifyRequests.get()['session-a']?.requestId).toBe('req-a2')
+  })
+
+  it('clears by request id across sessions when no session hint is given', () => {
+    setClarifyRequest(clarify('session-a', 'shared'))
+    setClarifyRequest(clarify('session-b', 'other'))
+
+    clearClarifyRequest('shared')
+
+    expect($clarifyRequests.get()['session-a']).toBeUndefined()
+    expect($clarifyRequests.get()['session-b']?.requestId).toBe('other')
+  })
+})

package/src/store/clarify.ts

@@ -0,0 +1,69 @@
+import { atom, computed } from 'nanostores'
+
+import { $activeSessionId } from './session'
+
+export interface ClarifyRequest {
+  requestId: string
+  question: string
+  choices: string[] | null
+  sessionId: string | null
+}
+
+// Pending clarify requests keyed by the runtime session id that raised them.
+// Storing per-session (instead of one shared slot) lets a *background* session
+// park its clarify request while the user is looking at a different chat, then
+// resolve it once they switch over — without a second concurrent clarify
+// clobbering the first. A request with no session id lands under the empty key.
+const keyFor = (sessionId: string | null | undefined): string => sessionId ?? ''
+
+export const $clarifyRequests = atom<Record<string, ClarifyRequest>>({})
+
+// The clarify request for the currently-viewed session. The inline ClarifyTool
+// only ever mounts inside the active session's transcript, so it reads this
+// focus-scoped view rather than reaching into the whole map.
+export const $clarifyRequest = computed(
+  [$clarifyRequests, $activeSessionId],
+  (requests, activeId) => requests[keyFor(activeId)] ?? null
+)
+
+export function setClarifyRequest(request: ClarifyRequest): void {
+  $clarifyRequests.set({ ...$clarifyRequests.get(), [keyFor(request.sessionId)]: request })
+}
+
+export function clearClarifyRequest(requestId?: string, sessionId?: string | null): void {
+  const requests = $clarifyRequests.get()
+
+  // Targeted clear when the caller knows the session (the common path from the
+  // inline ClarifyTool answering its own request).
+  if (sessionId !== undefined) {
+    const key = keyFor(sessionId)
+    const current = requests[key]
+
+    if (!current || (requestId && current.requestId !== requestId)) {
+      return
+    }
+
+    const next = { ...requests }
+    delete next[key]
+    $clarifyRequests.set(next)
+
+    return
+  }
+
+  // Fallback with no session hint: drop every entry matching the request id
+  // (or clear all when none is given).
+  const next: Record<string, ClarifyRequest> = {}
+  let changed = false
+
+  for (const [key, value] of Object.entries(requests)) {
+    if (requestId && value.requestId !== requestId) {
+      next[key] = value
+    } else {
+      changed = true
+    }
+  }
+
+  if (changed) {
+    $clarifyRequests.set(next)
+  }
+}

package/src/store/command-palette.ts

@@ -0,0 +1,20 @@
+import { atom } from 'nanostores'
+
+/** Whether the global command palette (Cmd/Ctrl+K) is currently open. */
+export const $commandPaletteOpen = atom(false)
+
+export function openCommandPalette(): void {
+  $commandPaletteOpen.set(true)
+}
+
+export function closeCommandPalette(): void {
+  $commandPaletteOpen.set(false)
+}
+
+export function setCommandPaletteOpen(open: boolean): void {
+  $commandPaletteOpen.set(open)
+}
+
+export function toggleCommandPalette(): void {
+  $commandPaletteOpen.set(!$commandPaletteOpen.get())
+}

package/src/store/compaction.test.ts

@@ -0,0 +1,53 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import { $compactingSessions, $compactionActive, setSessionCompacting } from './compaction'
+import { $activeSessionId } from './session'
+
+describe('compaction store', () => {
+  beforeEach(() => {
+    $compactingSessions.set({})
+    $activeSessionId.set(null)
+  })
+
+  afterEach(() => {
+    $compactingSessions.set({})
+    $activeSessionId.set(null)
+  })
+
+  it('tracks compaction per session independently', () => {
+    setSessionCompacting('session-a', true)
+    setSessionCompacting('session-b', true)
+
+    expect($compactingSessions.get()).toEqual({ 'session-a': true, 'session-b': true })
+  })
+
+  it('exposes only the active session via the focus-scoped view', () => {
+    setSessionCompacting('session-a', true)
+
+    expect($compactionActive.get()).toBe(false)
+
+    $activeSessionId.set('session-a')
+    expect($compactionActive.get()).toBe(true)
+
+    $activeSessionId.set('session-b')
+    expect($compactionActive.get()).toBe(false)
+  })
+
+  it('clears a session without disturbing the others', () => {
+    setSessionCompacting('session-a', true)
+    setSessionCompacting('session-b', true)
+
+    setSessionCompacting('session-a', false)
+
+    expect($compactingSessions.get()).toEqual({ 'session-b': true })
+  })
+
+  it('is a no-op when clearing an unknown session', () => {
+    setSessionCompacting('session-a', true)
+    const before = $compactingSessions.get()
+
+    setSessionCompacting('session-missing', false)
+
+    expect($compactingSessions.get()).toBe(before)
+  })
+})

package/src/store/compaction.ts

@@ -0,0 +1,38 @@
+import { atom, computed } from 'nanostores'
+
+import { $activeSessionId } from './session'
+
+// Per-session flag while auto-compaction runs mid-turn. Without it the
+// transcript looks like it reset; per-session so a background chat can't
+// clobber the foreground view.
+const keyFor = (sessionId: string | null | undefined): string => sessionId ?? ''
+
+export const $compactingSessions = atom<Record<string, true>>({})
+
+export const $compactionActive = computed(
+  [$compactingSessions, $activeSessionId],
+  (sessions, activeId) => keyFor(activeId) in sessions
+)
+
+export function setSessionCompacting(sessionId: string | null | undefined, active: boolean): void {
+  const key = keyFor(sessionId)
+  const sessions = $compactingSessions.get()
+
+  if (active) {
+    if (key in sessions) {
+      return
+    }
+
+    $compactingSessions.set({ ...sessions, [key]: true })
+
+    return
+  }
+
+  if (!(key in sessions)) {
+    return
+  }
+
+  const next = { ...sessions }
+  delete next[key]
+  $compactingSessions.set(next)
+}

package/src/store/completion-sound.ts

@@ -0,0 +1,32 @@
+import { atom } from 'nanostores'
+
+import { persistString, storedString } from '@/lib/storage'
+
+const STORAGE_KEY = 'nastech.desktop.completionSoundVariantId'
+
+export const DEFAULT_COMPLETION_SOUND_VARIANT_ID = 1
+
+// Range mirrors COMPLETION_SOUND_VARIANTS in lib/completion-sound.ts. Validating
+// by range (not membership) keeps this store free of a dependency on the lib,
+// which imports the atom back — a membership check would close that cycle.
+const VARIANT_COUNT = 14
+
+export function resolveCompletionSoundVariantId(variantId: number): number {
+  return Number.isInteger(variantId) && variantId >= 1 && variantId <= VARIANT_COUNT
+    ? variantId
+    : DEFAULT_COMPLETION_SOUND_VARIANT_ID
+}
+
+function load(): number {
+  const stored = storedString(STORAGE_KEY)
+
+  return stored ? resolveCompletionSoundVariantId(Number.parseInt(stored, 10)) : DEFAULT_COMPLETION_SOUND_VARIANT_ID
+}
+
+export const $completionSoundVariantId = atom(load())
+
+$completionSoundVariantId.subscribe(id => persistString(STORAGE_KEY, String(id)))
+
+export function setCompletionSoundVariantId(variantId: number) {
+  $completionSoundVariantId.set(resolveCompletionSoundVariantId(variantId))
+}

package/src/store/composer-input-history.test.ts

@@ -0,0 +1,147 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import {
+  $perSessionBrowse,
+  browseBackward,
+  browseForward,
+  deriveUserHistory,
+  isBrowsingHistory,
+  resetBrowseState
+} from './composer-input-history'
+
+const SESSION_A = 'session-a'
+const SESSION_B = 'session-b'
+
+// Newest-first user text ring, what the caller passes to browse*.
+const HISTORY = ['third', 'second', 'first']
+
+const MSG = (role: string, text: string) => ({ id: '', role, text })
+
+beforeEach(() => {
+  $perSessionBrowse.set({})
+})
+
+describe('deriveUserHistory', () => {
+  it('returns user messages newest-first with empty/whitespace skipped', () => {
+    const messages = [
+      MSG('user', '   '),
+      MSG('assistant', 'hi'),
+      MSG('user', 'first'),
+      MSG('user', 'second')
+    ]
+
+    expect(deriveUserHistory(messages, m => m.text)).toEqual(['second', 'first'])
+  })
+})
+
+describe('browseBackward', () => {
+  it('returns null when history is empty', () => {
+    expect(browseBackward(SESSION_A, '', [])).toBeNull()
+  })
+
+  it('returns the most recent entry on first press and saves the draft', () => {
+    const result = browseBackward(SESSION_A, 'unsent draft', HISTORY)
+
+    expect(result).toBe('third')
+    expect($perSessionBrowse.get()[SESSION_A]!.draftSnapshot).toBe('unsent draft')
+  })
+
+  it('moves to older entries on subsequent presses and stops at the oldest', () => {
+    expect(browseBackward(SESSION_A, '', HISTORY)).toBe('third')
+    expect(browseBackward(SESSION_A, '', HISTORY)).toBe('second')
+    expect(browseBackward(SESSION_A, '', HISTORY)).toBe('first')
+    expect(browseBackward(SESSION_A, '', HISTORY)).toBeNull()
+  })
+
+  it('uses caller-provided history, not a mirrored ring', () => {
+    // The store never owns the ring — the caller passes it every press.
+    // If the ring changes between presses (e.g. a new message was sent),
+    // the next press sees the updated ring and the cursor continues
+    // from where it was within it.
+    expect(browseBackward(SESSION_A, '', ['youngest', 'older'])).toBe('youngest')
+
+    // Caller added a new message; ring is now [brand-new, youngest, older].
+    // Cursor was at 0, next press advances to 1 -> "youngest".
+    expect(
+      browseBackward(SESSION_A, '', ['brand-new', 'youngest', 'older'])
+    ).toBe('youngest')
+
+    // One more press -> "older".
+    expect(
+      browseBackward(SESSION_A, '', ['brand-new', 'youngest', 'older'])
+    ).toBe('older')
+  })
+})
+
+describe('browseForward', () => {
+  it('returns null when not browsing', () => {
+    expect(browseForward(SESSION_A, HISTORY)).toBeNull()
+  })
+
+  it('moves toward the present', () => {
+    browseBackward(SESSION_A, 'draft', HISTORY) // cursor 0 -> 'third'
+    browseBackward(SESSION_A, '', HISTORY) // cursor 1 -> 'second'
+
+    expect(browseForward(SESSION_A, HISTORY)).toEqual({
+      text: 'third',
+      returnedToPresent: false
+    })
+  })
+
+  it('restores the saved draft and resets when reaching the present', () => {
+    browseBackward(SESSION_A, 'my original draft', HISTORY)
+
+    const result = browseForward(SESSION_A, HISTORY)
+
+    expect(result).toEqual({ text: 'my original draft', returnedToPresent: true })
+    expect(isBrowsingHistory(SESSION_A)).toBe(false)
+  })
+})
+
+describe('per-session isolation', () => {
+  it('tracks cursor and draft independently per session', () => {
+    browseBackward(SESSION_A, 'draft-a', HISTORY)
+    browseBackward(SESSION_A, '', HISTORY) // older
+
+    browseBackward(SESSION_B, 'draft-b', HISTORY)
+
+    const a = $perSessionBrowse.get()[SESSION_A]!
+    const b = $perSessionBrowse.get()[SESSION_B]!
+
+    expect(a.cursor).toBe(1)
+    expect(a.draftSnapshot).toBe('draft-a')
+    expect(b.cursor).toBe(0)
+    expect(b.draftSnapshot).toBe('draft-b')
+  })
+})
+
+describe('resetBrowseState', () => {
+  it('clears cursor and draft snapshot', () => {
+    browseBackward(SESSION_A, 'draft', HISTORY)
+    resetBrowseState(SESSION_A)
+
+    const s = $perSessionBrowse.get()[SESSION_A]!
+
+    expect(s.cursor).toBe(-1)
+    expect(s.draftSnapshot).toBe('')
+  })
+})
+
+describe('session switch behavior', () => {
+  it('resets the previous session cursor and lets the new session derive its own ring', () => {
+    // Session A: user browsed into the past
+    browseBackward(SESSION_A, '', HISTORY)
+    expect(isBrowsingHistory(SESSION_A)).toBe(true)
+
+    // Caller switches to session B; resets A's browse state
+    resetBrowseState(SESSION_A)
+
+    // Session B's ring is derived from B's messages, not A's
+    const sessionBMessages = [MSG('user', 'hello-b'), MSG('user', 'world-b')]
+    const sessionBHistory = deriveUserHistory(sessionBMessages, m => m.text)
+
+    expect(browseBackward(SESSION_B, '', sessionBHistory)).toBe('world-b')
+    expect(browseBackward(SESSION_B, '', sessionBHistory)).toBe('hello-b')
+    expect(isBrowsingHistory(SESSION_A)).toBe(false)
+  })
+})