nastechai-desktop 18.1.0

package/src/app/session/hooks/use-model-controls.test.tsx

@@ -0,0 +1,198 @@
+import { QueryClient } from '@tanstack/react-query'
+import { cleanup, render, renderHook } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { getGlobalModelInfo } from '@/nastech'
+import {
+  $activeSessionId,
+  $currentModel,
+  $currentProvider,
+  setCurrentModel,
+  setCurrentProvider
+} from '@/store/session'
+
+import { useModelControls } from './use-model-controls'
+
+const setGlobalModel = vi.fn()
+const notifyError = vi.fn()
+
+vi.mock('@/nastech', () => ({
+  getGlobalModelInfo: vi.fn(),
+  setGlobalModel: (...args: Parameters<typeof setGlobalModel>) => setGlobalModel(...args)
+}))
+
+vi.mock('@/i18n', () => ({
+  useI18n: () => ({
+    t: {
+      desktop: {
+        modelSwitchFailed: 'Model switch failed'
+      }
+    }
+  })
+}))
+
+vi.mock('@/store/notifications', () => ({
+  notifyError: (...args: Parameters<typeof notifyError>) => notifyError(...args)
+}))
+
+type Controls = ReturnType<typeof useModelControls>
+
+function Harness({
+  activeSessionId,
+  onReady,
+  requestGateway
+}: {
+  activeSessionId: string | null
+  onReady: (controls: Controls) => void
+  requestGateway: <T = unknown>(method: string, params?: Record<string, unknown>) => Promise<T>
+}) {
+  const controls = useModelControls({
+    activeSessionId,
+    queryClient: new QueryClient(),
+    requestGateway
+  })
+
+  onReady(controls)
+
+  return null
+}
+
+describe('useModelControls', () => {
+  beforeEach(() => {
+    $activeSessionId.set(null)
+    setCurrentModel('')
+    setCurrentProvider('')
+  })
+
+  afterEach(() => {
+    cleanup()
+    vi.restoreAllMocks()
+    $activeSessionId.set(null)
+    setCurrentModel('')
+    setCurrentProvider('')
+  })
+
+  it('applies the global model when there is no active runtime session', async () => {
+    vi.mocked(getGlobalModelInfo).mockResolvedValue({
+      model: 'openai/gpt-5.5',
+      provider: 'openai-codex'
+    })
+
+    const { result } = renderHook(() =>
+      useModelControls({
+        activeSessionId: null,
+        queryClient: new QueryClient(),
+        requestGateway: vi.fn()
+      })
+    )
+
+    await result.current.refreshCurrentModel()
+
+    expect($currentModel.get()).toBe('openai/gpt-5.5')
+    expect($currentProvider.get()).toBe('openai-codex')
+  })
+
+  it('does not clobber the active session footer state with global model info', async () => {
+    setCurrentModel('deepseek/deepseek-v4-pro')
+    setCurrentProvider('deepseek')
+    $activeSessionId.set('runtime-1')
+    vi.mocked(getGlobalModelInfo).mockResolvedValue({
+      model: 'openai/gpt-5.5',
+      provider: 'openai-codex'
+    })
+
+    const { result } = renderHook(() =>
+      useModelControls({
+        activeSessionId: 'runtime-1',
+        queryClient: new QueryClient(),
+        requestGateway: vi.fn()
+      })
+    )
+
+    await result.current.refreshCurrentModel()
+
+    expect($currentModel.get()).toBe('deepseek/deepseek-v4-pro')
+    expect($currentProvider.get()).toBe('deepseek')
+  })
+
+  it('routes active-session picker changes through config.set with an explicit provider', async () => {
+    const requestGateway = vi.fn(async () => ({ key: 'model', value: 'claude-sonnet-4.6' }) as never)
+    let controls!: Controls
+
+    render(
+      <Harness
+        activeSessionId="session-1"
+        onReady={value => (controls = value)}
+        requestGateway={requestGateway}
+      />
+    )
+
+    await expect(
+      controls.selectModel({
+        model: 'claude-sonnet-4.6',
+        provider: 'anthropic'
+      })
+    ).resolves.toBe(true)
+
+    expect(requestGateway).toHaveBeenCalledWith('config.set', {
+      session_id: 'session-1',
+      key: 'model',
+      value: 'claude-sonnet-4.6 --provider anthropic'
+    })
+    expect(requestGateway).not.toHaveBeenCalledWith('slash.exec', expect.anything())
+  })
+
+  it('stores a no-session pick as UI state with no gateway or global write', async () => {
+    const requestGateway = vi.fn()
+    let controls!: Controls
+
+    render(
+      <Harness
+        activeSessionId={null}
+        onReady={value => (controls = value)}
+        requestGateway={requestGateway}
+      />
+    )
+
+    await expect(
+      controls.selectModel({
+        model: 'claude-sonnet-4.6',
+        provider: 'anthropic'
+      })
+    ).resolves.toBe(true)
+
+    // The pick is plain UI state; session.create ships it later. Nothing touches
+    // the gateway or the profile default here.
+    expect($currentModel.get()).toBe('claude-sonnet-4.6')
+    expect($currentProvider.get()).toBe('anthropic')
+    expect(requestGateway).not.toHaveBeenCalled()
+    expect(setGlobalModel).not.toHaveBeenCalled()
+  })
+
+  it('seeds an empty composer model from global but never clobbers a pick', async () => {
+    vi.mocked(getGlobalModelInfo).mockResolvedValue({ model: 'openai/gpt-5.5', provider: 'openai-codex' })
+
+    const { result } = renderHook(() =>
+      useModelControls({
+        activeSessionId: null,
+        queryClient: new QueryClient(),
+        requestGateway: vi.fn()
+      })
+    )
+
+    // Empty → seeds the default.
+    await result.current.refreshCurrentModel()
+    expect($currentModel.get()).toBe('openai/gpt-5.5')
+
+    // A user pick must survive the lifecycle refreshes that fire on boot / fresh
+    // draft / session events.
+    setCurrentModel('anthropic/claude-sonnet-4.6')
+    setCurrentProvider('anthropic')
+    await result.current.refreshCurrentModel()
+    expect($currentModel.get()).toBe('anthropic/claude-sonnet-4.6')
+
+    // A profile swap forces a reseed to the new profile's default.
+    await result.current.refreshCurrentModel(true)
+    expect($currentModel.get()).toBe('openai/gpt-5.5')
+  })
+})

package/src/app/session/hooks/use-model-controls.ts

@@ -0,0 +1,106 @@
+import { type QueryClient } from '@tanstack/react-query'
+import { useCallback } from 'react'
+
+import { getGlobalModelInfo, setGlobalModel } from '@/nastech'
+import { useI18n } from '@/i18n'
+import { notifyError } from '@/store/notifications'
+import { $currentModel, $currentProvider, setCurrentModel, setCurrentProvider } from '@/store/session'
+import type { ModelOptionsResponse } from '@/types/nastech'
+
+interface ModelSelection {
+  model: string
+  persistGlobal: boolean
+  provider: string
+}
+
+interface ModelControlsOptions {
+  activeSessionId: string | null
+  queryClient: QueryClient
+  requestGateway: <T = unknown>(method: string, params?: Record<string, unknown>) => Promise<T>
+}
+
+export function useModelControls({ activeSessionId, queryClient, requestGateway }: ModelControlsOptions) {
+  const { t } = useI18n()
+  const copy = t.desktop
+  const updateModelOptionsCache = useCallback(
+    (provider: string, model: string, includeGlobal: boolean) => {
+      const patch = (prev: ModelOptionsResponse | undefined) => ({ ...(prev ?? {}), provider, model })
+
+      queryClient.setQueryData<ModelOptionsResponse>(['model-options', activeSessionId || 'global'], patch)
+
+      if (includeGlobal) {
+        queryClient.setQueryData<ModelOptionsResponse>(['model-options', 'global'], patch)
+      }
+    },
+    [activeSessionId, queryClient]
+  )
+
+  const refreshCurrentModel = useCallback(async () => {
+    try {
+      const result = await getGlobalModelInfo()
+
+      if (typeof result.model === 'string') {
+        setCurrentModel(result.model)
+      }
+
+      if (typeof result.provider === 'string') {
+        setCurrentProvider(result.provider)
+      }
+    } catch {
+      // The delayed session.info event still updates this once the agent is ready.
+    }
+  }, [])
+
+  // Returns whether the switch succeeded so callers can await it before
+  // applying follow-up changes (e.g. editing a model's reasoning/fast must land
+  // on the right active model — bail rather than write to the previous one).
+  const selectModel = useCallback(
+    async (selection: ModelSelection): Promise<boolean> => {
+      const includeGlobal = selection.persistGlobal || !activeSessionId
+      // Snapshot for rollback: the switch is applied optimistically, so a
+      // failure must restore the prior model/provider (store + query cache)
+      // rather than leave the UI showing a model the backend never selected.
+      const prevModel = $currentModel.get()
+      const prevProvider = $currentProvider.get()
+
+      setCurrentModel(selection.model)
+      setCurrentProvider(selection.provider)
+      updateModelOptionsCache(selection.provider, selection.model, includeGlobal)
+
+      try {
+        if (activeSessionId) {
+          await requestGateway('slash.exec', {
+            session_id: activeSessionId,
+            command: `/model ${selection.model} --provider ${selection.provider}${selection.persistGlobal ? ' --global' : ''}`
+          })
+
+          if (selection.persistGlobal) {
+            void refreshCurrentModel()
+          }
+
+          void queryClient.invalidateQueries({
+            queryKey: selection.persistGlobal ? ['model-options'] : ['model-options', activeSessionId]
+          })
+
+          return true
+        }
+
+        await setGlobalModel(selection.provider, selection.model)
+        void refreshCurrentModel()
+        void queryClient.invalidateQueries({ queryKey: ['model-options'] })
+
+        return true
+      } catch (err) {
+        setCurrentModel(prevModel)
+        setCurrentProvider(prevProvider)
+        updateModelOptionsCache(prevProvider, prevModel, includeGlobal)
+        notifyError(err, copy.modelSwitchFailed)
+
+        return false
+      }
+    },
+    [activeSessionId, copy.modelSwitchFailed, queryClient, refreshCurrentModel, requestGateway, updateModelOptionsCache]
+  )
+
+  return { refreshCurrentModel, selectModel, updateModelOptionsCache }
+}

package/src/app/session/hooks/use-nastech-config.ts

@@ -0,0 +1,74 @@
+import { type MutableRefObject, useCallback, useState } from 'react'
+
+import { getNasTechConfig, getNasTechConfigDefaults } from '@/nastech'
+import { BUILTIN_PERSONALITIES, normalizePersonalityValue, personalityNamesFromConfig } from '@/lib/chat-runtime'
+import {
+  $currentCwd,
+  setAvailablePersonalities,
+  setCurrentCwd,
+  setCurrentFastMode,
+  setCurrentPersonality,
+  setCurrentReasoningEffort,
+  setCurrentServiceTier,
+  setIntroPersonality
+} from '@/store/session'
+
+const DEFAULT_VOICE_SECONDS = 120
+const FAST_TIERS = new Set(['fast', 'priority', 'on'])
+
+function recordingLimit(value: unknown) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : DEFAULT_VOICE_SECONDS
+}
+
+interface NasTechConfigOptions {
+  activeSessionIdRef: MutableRefObject<string | null>
+  refreshProjectBranch: (cwd: string) => Promise<void>
+}
+
+export function useNasTechConfig({ activeSessionIdRef, refreshProjectBranch }: NasTechConfigOptions) {
+  const [voiceMaxRecordingSeconds, setVoiceMaxRecordingSeconds] = useState(DEFAULT_VOICE_SECONDS)
+  const [sttEnabled, setSttEnabled] = useState(true)
+
+  const refreshNasTechConfig = useCallback(async () => {
+    try {
+      const [config, defaults] = await Promise.all([getNasTechConfig(), getNasTechConfigDefaults().catch(() => ({}))])
+
+      const personality = normalizePersonalityValue(
+        typeof config.display?.personality === 'string' ? config.display.personality : ''
+      )
+
+      setIntroPersonality(personality)
+      // Active sessions keep their per-session value; standalone falls back to config.
+      setCurrentPersonality(prev => (activeSessionIdRef.current ? prev || personality : personality))
+      setAvailablePersonalities([
+        ...new Set([
+          'none',
+          ...BUILTIN_PERSONALITIES,
+          ...personalityNamesFromConfig(defaults),
+          ...personalityNamesFromConfig(config)
+        ])
+      ])
+
+      const cwd = (config.terminal?.cwd ?? '').trim()
+
+      if (cwd && cwd !== '.') {
+        setCurrentCwd(prev => prev || cwd)
+        void refreshProjectBranch($currentCwd.get() || cwd)
+      }
+
+      const reasoning = (config.agent?.reasoning_effort ?? '').trim()
+      const tier = (config.agent?.service_tier ?? '').trim()
+
+      setCurrentReasoningEffort(prev => (activeSessionIdRef.current ? prev : reasoning))
+      setCurrentServiceTier(prev => (activeSessionIdRef.current ? prev : tier))
+      setCurrentFastMode(prev => (activeSessionIdRef.current ? prev : FAST_TIERS.has(tier.toLowerCase())))
+
+      setVoiceMaxRecordingSeconds(recordingLimit(config.voice?.max_recording_seconds))
+      setSttEnabled(config.stt?.enabled !== false)
+    } catch {
+      // Config is nice-to-have; chat still works without it.
+    }
+  }, [activeSessionIdRef, refreshProjectBranch])
+
+  return { refreshNasTechConfig, sttEnabled, voiceMaxRecordingSeconds }
+}

package/src/app/session/hooks/use-preview-routing.test.tsx

@@ -0,0 +1,168 @@
+import { act, cleanup, render, waitFor } from '@testing-library/react'
+import { useEffect, useRef } from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { assistantTextPart, type ChatMessage } from '@/lib/chat-messages'
+import {
+  $previewTarget,
+  clearSessionPreviewRegistry,
+  type PreviewTarget,
+  registerSessionPreview
+} from '@/store/preview'
+import { $currentCwd, $messages } from '@/store/session'
+import type { RpcEvent } from '@/types/nastech'
+
+import { usePreviewRouting } from './use-preview-routing'
+
+function assistantMessage(id: string, text: string): ChatMessage {
+  return {
+    id,
+    parts: [assistantTextPart(text)],
+    role: 'assistant'
+  }
+}
+
+function previewTarget(source: string): PreviewTarget {
+  const isUrl = /^https?:\/\//i.test(source)
+
+  return {
+    kind: isUrl ? 'url' : 'file',
+    label: source,
+    path: isUrl ? undefined : source,
+    previewKind: isUrl ? undefined : 'html',
+    source,
+    url: isUrl ? source : `file://${source}`
+  }
+}
+
+let handleEvent: (event: RpcEvent) => void = () => undefined
+
+function PreviewRoutingHarness({ onEvent }: { onEvent: (handler: (event: RpcEvent) => void) => void }) {
+  const activeSessionIdRef = useRef<string | null>('session-1')
+
+  const routing = usePreviewRouting({
+    activeSessionIdRef,
+    baseHandleGatewayEvent: vi.fn(),
+    currentCwd: '/work',
+    currentView: 'chat',
+    requestGateway: vi.fn(),
+    routedSessionId: 'session-1',
+    selectedStoredSessionId: null
+  })
+
+  useEffect(() => {
+    onEvent(routing.handleDesktopGatewayEvent)
+  }, [onEvent, routing.handleDesktopGatewayEvent])
+
+  return null
+}
+
+describe('usePreviewRouting', () => {
+  beforeEach(() => {
+    $currentCwd.set('/work')
+    $messages.set([])
+    $previewTarget.set(null)
+    window.localStorage.clear()
+    clearSessionPreviewRegistry()
+    handleEvent = () => undefined
+
+    Object.defineProperty(window, 'NASTECHDesktop', {
+      configurable: true,
+      value: {
+        normalizePreviewTarget: vi.fn(async (target: string) => previewTarget(target))
+      }
+    })
+  })
+
+  afterEach(() => {
+    cleanup()
+    $messages.set([])
+    $previewTarget.set(null)
+    window.localStorage.clear()
+    clearSessionPreviewRegistry()
+    vi.restoreAllMocks()
+  })
+
+  it('opens the active session preview from the registry', async () => {
+    const target = previewTarget('/work/demo.html')
+
+    registerSessionPreview('session-1', target, 'tool-result')
+    render(
+      <PreviewRoutingHarness
+        onEvent={handler => {
+          handleEvent = handler
+        }}
+      />
+    )
+
+    await waitFor(() => {
+      expect($previewTarget.get()).toEqual({ ...target, renderMode: 'preview' })
+    })
+  })
+
+  it('does not infer previews from assistant prose', async () => {
+    render(
+      <PreviewRoutingHarness
+        onEvent={handler => {
+          handleEvent = handler
+        }}
+      />
+    )
+
+    act(() => {
+      $messages.set([
+        assistantMessage('a1', 'Preview: http://localhost:5173/'),
+        assistantMessage('a2', 'Open /work/demo.html')
+      ])
+    })
+
+    expect($previewTarget.get()).toBeNull()
+    expect(window.NASTECHDesktop.normalizePreviewTarget).not.toHaveBeenCalled()
+  })
+
+  it('registers structured tool-result preview targets', async () => {
+    render(
+      <PreviewRoutingHarness
+        onEvent={handler => {
+          handleEvent = handler
+        }}
+      />
+    )
+
+    act(() =>
+      handleEvent({
+        payload: { path: './dist/index.html' },
+        session_id: 'session-1',
+        type: 'tool.complete'
+      })
+    )
+
+    await waitFor(() => {
+      expect($previewTarget.get()?.source).toBe('./dist/index.html')
+    })
+
+    expect(window.localStorage.getItem('NASTECH.desktop.sessionPreviews.v1')).toContain('./dist/index.html')
+  })
+
+  it('registers html previews from edit inline diffs', async () => {
+    render(
+      <PreviewRoutingHarness
+        onEvent={handler => {
+          handleEvent = handler
+        }}
+      />
+    )
+
+    act(() =>
+      handleEvent({
+        payload: { inline_diff: '\u001b[38;2;218;165;32ma/preview-demo.html -> b/preview-demo.html\u001b[0m\n' },
+        session_id: 'session-1',
+        type: 'tool.complete'
+      })
+    )
+
+    await waitFor(() => {
+      expect($previewTarget.get()?.source).toBe('preview-demo.html')
+    })
+  })
+})