nastechai-desktop 18.1.0

package/src/store/model-presets.ts

@@ -0,0 +1,86 @@
+import { atom } from 'nanostores'
+
+import { persistString, storedString } from '@/lib/storage'
+
+import { notifyError } from './notifications'
+import { setCurrentFastMode, setCurrentReasoningEffort } from './session'
+
+const STORAGE_KEY = 'nastech.desktop.model-presets'
+
+/** Per-model reasoning/fast preset, remembered globally across sessions and
+ *  re-applied to the session whenever that model is selected. Unset dimensions
+ *  fall back to the NasTech default (medium effort, no fast). */
+export interface ModelPreset {
+  effort?: string
+  fast?: boolean
+}
+
+type RequestGateway = <T>(method: string, params?: Record<string, unknown>) => Promise<T>
+
+/** Stable `provider::model` key (matches the visibility-store format). */
+export const modelPresetKey = (provider: string, model: string): string => `${provider}::${model}`
+
+function load(): Record<string, ModelPreset> {
+  const raw = storedString(STORAGE_KEY)
+
+  if (!raw) {
+    return {}
+  }
+
+  try {
+    const parsed = JSON.parse(raw)
+
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? (parsed as Record<string, ModelPreset>) : {}
+  } catch {
+    return {}
+  }
+}
+
+export const $modelPresets = atom<Record<string, ModelPreset>>(load())
+
+export function getModelPreset(provider: string, model: string): ModelPreset {
+  return $modelPresets.get()[modelPresetKey(provider, model)] ?? {}
+}
+
+/** Merge a partial preset for one model and persist. */
+export function setModelPreset(provider: string, model: string, patch: ModelPreset): void {
+  const key = modelPresetKey(provider, model)
+  const next = { ...$modelPresets.get(), [key]: { ...$modelPresets.get()[key], ...patch } }
+
+  $modelPresets.set(next)
+  persistString(STORAGE_KEY, JSON.stringify(next))
+}
+
+/** Push a model's preset onto the active session (optimistic + gateway).
+ *  `undefined` skips that dimension; values are capability-gated upstream.
+ *  No-ops without a session — the gateway's `config.set` reasoning/fast fall
+ *  back to persistent (global/profile) config when none matches, so selecting
+ *  a model must not reach it (else it rewrites `agent.*`, defaults included). */
+export async function applyModelPreset(
+  { effort, fast }: ModelPreset,
+  ctx: { failMessage: string; request: RequestGateway; sessionId: null | string }
+): Promise<void> {
+  if (!ctx.sessionId) {
+    return
+  }
+
+  if (effort !== undefined) {
+    setCurrentReasoningEffort(effort)
+  }
+
+  if (fast !== undefined) {
+    setCurrentFastMode(fast)
+  }
+
+  try {
+    if (effort !== undefined) {
+      await ctx.request('config.set', { key: 'reasoning', session_id: ctx.sessionId, value: effort })
+    }
+
+    if (fast !== undefined) {
+      await ctx.request('config.set', { key: 'fast', session_id: ctx.sessionId, value: fast ? 'fast' : 'normal' })
+    }
+  } catch (err) {
+    notifyError(err, ctx.failMessage)
+  }
+}

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

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+
+import type { ModelOptionProvider } from '@/types/nastech'
+
+import { effectiveVisibleKeys, modelVisibilityKey } from './model-visibility'
+
+const provider = (slug: string, models: string[]): ModelOptionProvider => ({
+  models,
+  name: slug,
+  slug
+})
+
+describe('model visibility', () => {
+  it('keeps newly configured providers visible when stored choices are stale', () => {
+    const stored = new Set([modelVisibilityKey('copilot', 'claude-sonnet-4.6')])
+
+    const visible = effectiveVisibleKeys(stored, [
+      provider('copilot', ['claude-sonnet-4.6']),
+      provider('local-ollama', ['qwen3:latest', 'llama3.2:latest'])
+    ])
+
+    expect(visible.has(modelVisibilityKey('copilot', 'claude-sonnet-4.6'))).toBe(true)
+    expect(visible.has(modelVisibilityKey('local-ollama', 'qwen3:latest'))).toBe(true)
+    expect(visible.has(modelVisibilityKey('local-ollama', 'llama3.2:latest'))).toBe(true)
+  })
+
+  it('does not re-add models from a provider that already has stored choices', () => {
+    const stored = new Set([modelVisibilityKey('local-ollama', 'qwen3:latest')])
+
+    const visible = effectiveVisibleKeys(stored, [
+      provider('local-ollama', ['qwen3:latest', 'llama3.2:latest'])
+    ])
+
+    expect(visible.has(modelVisibilityKey('local-ollama', 'qwen3:latest'))).toBe(true)
+    expect(visible.has(modelVisibilityKey('local-ollama', 'llama3.2:latest'))).toBe(false)
+  })
+})

package/src/store/model-visibility.ts

@@ -0,0 +1,108 @@
+import { atom } from 'nanostores'
+
+import { persistString, storedString } from '@/lib/storage'
+import type { ModelOptionProvider } from '@/types/nastech'
+
+const STORAGE_KEY = 'NASTECH.desktop.visible-models'
+
+/** Models shown per provider in the status-bar dropdown before the user has
+ *  customized the list. Backend `models` are already relevance-ordered. */
+export const DEFAULT_VISIBLE_PER_PROVIDER = 50
+
+/** Stable key for a provider/model pair (`::` avoids colliding with model ids
+ *  that contain a single colon, e.g. `model:tag`). */
+export const modelVisibilityKey = (provider: string, model: string): string => `${provider}::${model}`
+
+/** A model and its optional `…-fast` sibling, collapsed into one logical row.
+ *  `id` is the canonical (base) model; `fastId` is the fast variant if present. */
+export interface ModelFamily {
+  fastId: string | null
+  id: string
+}
+
+/** Collapse a provider's model list so a base model and its `…-fast` variant
+ *  become a single family (one row, one toggle). Order is preserved by the
+ *  base model's position. A `…-fast` model with no base stands on its own. */
+export function collapseModelFamilies(models: readonly string[]): ModelFamily[] {
+  const present = new Set(models)
+  const families: ModelFamily[] = []
+  const consumed = new Set<string>()
+
+  for (const model of models) {
+    if (consumed.has(model)) {
+      continue
+    }
+
+    if (/-fast$/i.test(model) && present.has(model.replace(/-fast$/i, ''))) {
+      // Represented by its base entry — the base attaches it as `fastId`.
+      continue
+    }
+
+    const fastId = `${model}-fast`
+    const hasFast = present.has(fastId)
+    families.push({ fastId: hasFast ? fastId : null, id: model })
+    consumed.add(model)
+
+    if (hasFast) {
+      consumed.add(fastId)
+    }
+  }
+
+  return families
+}
+
+function loadVisible(): Set<string> | null {
+  const raw = storedString(STORAGE_KEY)
+
+  if (!raw) {
+    return null
+  }
+
+  try {
+    const parsed = JSON.parse(raw)
+
+    return Array.isArray(parsed) ? new Set(parsed.filter((x): x is string => typeof x === 'string')) : null
+  } catch {
+    return null
+  }
+}
+
+/** Explicit set of visible `provider::model` keys, or null when the user
+ *  hasn't customized — in which case the curated default applies. */
+export const $visibleModels = atom<Set<string> | null>(loadVisible())
+
+export const $modelVisibilityOpen = atom(false)
+
+export function setVisibleModels(keys: Set<string>): void {
+  $visibleModels.set(new Set(keys))
+  persistString(STORAGE_KEY, JSON.stringify([...keys]))
+}
+
+export function setModelVisibilityOpen(open: boolean): void {
+  $modelVisibilityOpen.set(open)
+}
+
+/** The default-visible key set: the curated top-N per provider. Used both as
+ *  the dropdown fallback and to seed the Edit Models dialog. */
+export function defaultVisibleKeys(providers: readonly ModelOptionProvider[]): Set<string> {
+  const keys = new Set<string>()
+
+  for (const provider of providers) {
+    const families = collapseModelFamilies(provider.models ?? [])
+
+    for (const family of families.slice(0, DEFAULT_VISIBLE_PER_PROVIDER)) {
+      keys.add(modelVisibilityKey(provider.slug, family.id))
+    }
+  }
+
+  return keys
+}
+
+/** Resolve which keys are currently visible: the user's explicit set when
+ *  configured, otherwise the curated default for the given providers. */
+export function effectiveVisibleKeys(
+  stored: Set<string> | null,
+  providers: readonly ModelOptionProvider[]
+): Set<string> {
+  return stored ?? defaultVisibleKeys(providers)
+}

package/src/store/native-notifications.test.ts

@@ -0,0 +1,192 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { $gateway } from './gateway'
+import {
+  dispatchNativeNotification,
+  NATIVE_NOTIFICATION_KINDS,
+  respondToApprovalAction,
+  sendTestNativeNotification,
+  setNativeNotifyEnabled,
+  setNativeNotifyKind
+} from './native-notifications'
+import { $approvalRequest, setApprovalRequest } from './prompts'
+import { $activeSessionId, setActiveSessionId } from './session'
+
+const desktopWindow = window as unknown as { nastechDesktop?: Window['nastechDesktop'] }
+const initialNasTechDesktop = desktopWindow.nastechDesktop
+
+const notify = vi.fn().mockResolvedValue(true)
+
+function setWindowState({ focused = true, hidden = false }: { focused?: boolean; hidden?: boolean }) {
+  Object.defineProperty(document, 'hidden', { configurable: true, value: hidden })
+  Object.defineProperty(document, 'hasFocus', { configurable: true, value: () => focused })
+}
+
+let counter = 0
+
+// Unique session id per call dodges the per-(kind,session) throttle so each
+// assertion starts clean.
+function freshSession(): string {
+  counter += 1
+
+  return `session-${counter}`
+}
+
+beforeEach(() => {
+  notify.mockClear()
+  desktopWindow.nastechDesktop = { notify } as unknown as Window['nastechDesktop']
+  setNativeNotifyEnabled(true)
+
+  for (const kind of NATIVE_NOTIFICATION_KINDS) {
+    setNativeNotifyKind(kind, true)
+  }
+
+  setActiveSessionId(null)
+  setWindowState({ focused: false, hidden: true })
+})
+
+afterEach(() => {
+  if (initialNasTechDesktop) {
+    desktopWindow.nastechDesktop = initialNasTechDesktop
+  } else {
+    delete desktopWindow.nastechDesktop
+  }
+})
+
+describe('dispatchNativeNotification focus gating', () => {
+  it('fires a completion notification for the active session when the window is hidden', () => {
+    const sessionId = freshSession()
+    setActiveSessionId(sessionId)
+    dispatchNativeNotification({ kind: 'turnDone', sessionId, title: 'done' })
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+
+  it('fires a completion notification when the window is visible but unfocused (alt-tab)', () => {
+    const sessionId = freshSession()
+    setActiveSessionId(sessionId)
+    setWindowState({ focused: false, hidden: false })
+    dispatchNativeNotification({ kind: 'turnDone', sessionId, title: 'done' })
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+
+  it('suppresses a completion notification when the window is focused', () => {
+    const sessionId = freshSession()
+    setActiveSessionId(sessionId)
+    setWindowState({ focused: true, hidden: false })
+    dispatchNativeNotification({ kind: 'turnDone', sessionId, title: 'done' })
+    expect(notify).not.toHaveBeenCalled()
+  })
+
+  it('suppresses a completion notification for a non-active background session (no gateway spam)', () => {
+    setActiveSessionId('on-screen')
+    dispatchNativeNotification({ kind: 'turnDone', sessionId: 'busy-bot-session', title: 'done' })
+    expect(notify).not.toHaveBeenCalled()
+  })
+
+  it('fires an attention notification for an off-screen session even when focused', () => {
+    setWindowState({ focused: true, hidden: false })
+    setActiveSessionId('on-screen')
+    dispatchNativeNotification({ kind: 'approval', sessionId: 'background', title: 'approve' })
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+
+  it('suppresses an attention notification for the active session when focused', () => {
+    setWindowState({ focused: true, hidden: false })
+    setActiveSessionId('on-screen')
+    dispatchNativeNotification({ kind: 'approval', sessionId: 'on-screen', title: 'approve' })
+    expect(notify).not.toHaveBeenCalled()
+  })
+})
+
+describe('dispatchNativeNotification preferences', () => {
+  it('suppresses everything when the master switch is off', () => {
+    setNativeNotifyEnabled(false)
+    dispatchNativeNotification({ kind: 'approval', sessionId: freshSession(), title: 'approve' })
+    dispatchNativeNotification({ kind: 'turnDone', sessionId: freshSession(), title: 'done' })
+    expect(notify).not.toHaveBeenCalled()
+  })
+
+  it('suppresses only the disabled kind', () => {
+    const sessionId = freshSession()
+    setActiveSessionId(sessionId)
+    setNativeNotifyKind('turnDone', false)
+    dispatchNativeNotification({ kind: 'turnDone', sessionId, title: 'done' })
+    expect(notify).not.toHaveBeenCalled()
+
+    dispatchNativeNotification({ kind: 'turnError', sessionId, title: 'boom' })
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+
+  it('forwards kind and sessionId to the bridge', () => {
+    setActiveSessionId('abc')
+    dispatchNativeNotification({ body: 'hi', kind: 'turnError', sessionId: 'abc', title: 'boom' })
+    expect(notify).toHaveBeenCalledWith(
+      expect.objectContaining({ body: 'hi', kind: 'turnError', sessionId: 'abc', title: 'boom' })
+    )
+  })
+})
+
+describe('dispatchNativeNotification throttle', () => {
+  it('collapses duplicate kind+session within the throttle window', () => {
+    const sessionId = freshSession()
+    setActiveSessionId(sessionId)
+    dispatchNativeNotification({ kind: 'turnDone', sessionId, title: 'done' })
+    dispatchNativeNotification({ kind: 'turnDone', sessionId, title: 'done again' })
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('sendTestNativeNotification', () => {
+  it('fires regardless of focus or active session', () => {
+    setWindowState({ focused: true, hidden: false })
+    setActiveSessionId('on-screen')
+    sendTestNativeNotification('NasTech', 'works')
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('$activeSessionId wiring', () => {
+  it('reflects the setter used for gating', () => {
+    setActiveSessionId('xyz')
+    expect($activeSessionId.get()).toBe('xyz')
+  })
+})
+
+describe('respondToApprovalAction', () => {
+  const request = vi.fn().mockResolvedValue({ resolved: true })
+
+  beforeEach(() => {
+    request.mockClear()
+    $gateway.set({ request } as unknown as ReturnType<typeof $gateway.get>)
+  })
+
+  afterEach(() => {
+    $gateway.set(null)
+  })
+
+  it('approves via approval.respond {choice: "once"} and clears the prompt', async () => {
+    setActiveSessionId('bg')
+    setApprovalRequest({ command: 'rm -rf /', description: 'dangerous', sessionId: 'bg' })
+
+    await respondToApprovalAction('bg', 'approve')
+
+    expect(request).toHaveBeenCalledWith('approval.respond', { choice: 'once', session_id: 'bg' })
+    expect($approvalRequest.get()).toBeNull()
+  })
+
+  it('rejects via approval.respond {choice: "deny"}', async () => {
+    await respondToApprovalAction('bg', 'reject')
+    expect(request).toHaveBeenCalledWith('approval.respond', { choice: 'deny', session_id: 'bg' })
+  })
+
+  it('ignores unknown action ids', async () => {
+    await respondToApprovalAction('bg', 'snooze')
+    expect(request).not.toHaveBeenCalled()
+  })
+
+  it('no-ops without a gateway', async () => {
+    $gateway.set(null)
+    await respondToApprovalAction('bg', 'approve')
+    expect(request).not.toHaveBeenCalled()
+  })
+})

package/src/store/native-notifications.ts

@@ -0,0 +1,203 @@
+import { atom } from 'nanostores'
+
+import { persistString, storedString } from '@/lib/storage'
+
+import { $gateway } from './gateway'
+import { clearApprovalRequest } from './prompts'
+import { $activeSessionId } from './session'
+
+// Native OS notifications (Electron `Notification`), separate from the in-app
+// toast feed in `notifications.ts`. Each kind toggles independently.
+export type NativeNotificationKind = 'approval' | 'backgroundDone' | 'input' | 'turnDone' | 'turnError'
+
+export const NATIVE_NOTIFICATION_KINDS: readonly NativeNotificationKind[] = [
+  'approval',
+  'input',
+  'turnDone',
+  'turnError',
+  'backgroundDone'
+]
+
+// Blocking prompts — surface even while focused if they're for another session.
+const ATTENTION_KINDS = new Set<NativeNotificationKind>(['approval', 'input'])
+
+export interface NativeNotificationPrefs {
+  enabled: boolean
+  kinds: Record<NativeNotificationKind, boolean>
+}
+
+const STORAGE_KEY = 'nastech:native-notifications'
+
+const DEFAULT_PREFS: NativeNotificationPrefs = {
+  enabled: true,
+  kinds: { approval: true, backgroundDone: true, input: true, turnDone: true, turnError: true }
+}
+
+function readPrefs(): NativeNotificationPrefs {
+  const raw = storedString(STORAGE_KEY)
+
+  if (!raw) {
+    return DEFAULT_PREFS
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as Partial<NativeNotificationPrefs>
+    const kinds = { ...DEFAULT_PREFS.kinds }
+
+    for (const kind of NATIVE_NOTIFICATION_KINDS) {
+      const value = parsed.kinds?.[kind]
+
+      if (typeof value === 'boolean') {
+        kinds[kind] = value
+      }
+    }
+
+    return {
+      enabled: typeof parsed.enabled === 'boolean' ? parsed.enabled : DEFAULT_PREFS.enabled,
+      kinds
+    }
+  } catch {
+    return DEFAULT_PREFS
+  }
+}
+
+export const $nativeNotifyPrefs = atom<NativeNotificationPrefs>(readPrefs())
+
+function writePrefs(next: NativeNotificationPrefs) {
+  $nativeNotifyPrefs.set(next)
+  persistString(STORAGE_KEY, JSON.stringify(next))
+}
+
+export function setNativeNotifyEnabled(enabled: boolean) {
+  writePrefs({ ...$nativeNotifyPrefs.get(), enabled })
+}
+
+export function setNativeNotifyKind(kind: NativeNotificationKind, on: boolean) {
+  const prev = $nativeNotifyPrefs.get()
+  writePrefs({ ...prev, kinds: { ...prev.kinds, [kind]: on } })
+}
+
+// De-dupe replayed events for the same kind+session. Self-evicting: entries
+// older than the window are pruned on every dispatch, so the map can't grow.
+const THROTTLE_MS = 1000
+const lastFiredAt = new Map<string, number>()
+
+function throttled(key: string, now: number): boolean {
+  for (const [k, at] of lastFiredAt) {
+    if (now - at >= THROTTLE_MS) {
+      lastFiredAt.delete(k)
+    }
+  }
+
+  if (lastFiredAt.has(key)) {
+    return true
+  }
+
+  lastFiredAt.set(key, now)
+
+  return false
+}
+
+// "Backgrounded" = the user isn't on NasTech. `document.hidden` only flips when
+// minimized/occluded; an alt-tabbed window is visible-but-unfocused, so we also
+// check `document.hasFocus()`.
+function isBackgrounded(): boolean {
+  if (typeof document === 'undefined') {
+    return false
+  }
+
+  if (document.hidden) {
+    return true
+  }
+
+  return typeof document.hasFocus === 'function' && !document.hasFocus()
+}
+
+function shouldFire(kind: NativeNotificationKind, sessionId?: null | string): boolean {
+  // Attention kinds break through for an off-screen session even while focused.
+  if (ATTENTION_KINDS.has(kind)) {
+    return isBackgrounded() || (Boolean(sessionId) && sessionId !== $activeSessionId.get())
+  }
+
+  // Completion kinds: only the active session, only while away — so a busy
+  // gateway (messaging, kanban, cron) can't spam a toast per background session.
+  return isBackgrounded() && Boolean(sessionId) && sessionId === $activeSessionId.get()
+}
+
+export interface NativeNotificationAction {
+  id: string
+  text: string
+}
+
+export interface NativeNotificationInput {
+  kind: NativeNotificationKind
+  title: string
+  body?: string
+  sessionId?: null | string
+  silent?: boolean
+  actions?: NativeNotificationAction[]
+}
+
+export function dispatchNativeNotification(input: NativeNotificationInput): void {
+  const prefs = $nativeNotifyPrefs.get()
+
+  if (!prefs.enabled || !prefs.kinds[input.kind]) {
+    return
+  }
+
+  if (!shouldFire(input.kind, input.sessionId)) {
+    return
+  }
+
+  if (throttled(`${input.kind}:${input.sessionId ?? ''}`, Date.now())) {
+    return
+  }
+
+  void window.NASTECHDesktop?.notify({
+    actions: input.actions,
+    body: input.body,
+    kind: input.kind,
+    sessionId: input.sessionId ?? undefined,
+    silent: input.silent,
+    title: input.title
+  })
+}
+
+// Resolve a pending approval from a notification button, mirroring the in-app
+// Run/Reject bar. Keyed by session id — a background approval has no local guard.
+export async function respondToApprovalAction(sessionId: null | string, actionId: string): Promise<void> {
+  const choice = actionId === 'approve' ? 'once' : actionId === 'reject' ? 'deny' : null
+
+  if (!choice) {
+    return
+  }
+
+  const gateway = $gateway.get()
+
+  if (!gateway) {
+    return
+  }
+
+  try {
+    await gateway.request('approval.respond', { choice, session_id: sessionId ?? undefined })
+    clearApprovalRequest(sessionId)
+  } catch {
+    // Leave the prompt parked so the user can still resolve it in-app.
+  }
+}
+
+// Settings "send test" — bypasses gating. Returns whether the OS accepted it so
+// the panel can flag a silent permission failure instead of looking dead.
+export async function sendTestNativeNotification(title: string, body: string): Promise<boolean> {
+  const bridge = window.NASTECHDesktop
+
+  if (!bridge?.notify) {
+    return false
+  }
+
+  try {
+    return await bridge.notify({ body, kind: 'turnDone', title })
+  } catch {
+    return false
+  }
+}