@clawpump/claw-agent 0.1.4 → 0.1.6

package/agent/apps/desktop/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 = 'hermes: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 Hermes. `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.hermesDesktop?.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.hermesDesktop
+
+  if (!bridge?.notify) {
+    return false
+  }
+
+  try {
+    return await bridge.notify({ body, kind: 'turnDone', title })
+  } catch {
+    return false
+  }
+}

package/agent/apps/desktop/src/store/notifications.ts

@@ -1,5 +1,7 @@
 import { atom } from 'nanostores'
 
+import { translateNow } from '@/i18n'
+
 export type NotificationKind = 'error' | 'warning' | 'info' | 'success'
 
 export interface NotificationAction {
@@ -52,28 +54,29 @@ const ERROR_SUMMARIES: { test: (msg: string) => boolean; summarize: (msg: string
     summarize: msg => {
       const status = msg.match(/(?:error code|status(?:Code)?)[^\d]*(\d{3})/i)?.[1]
 
-      return `OpenAI rejected the API key${status ? ` (${status} invalid_api_key)` : ''}.`
+      return status
+        ? translateNow('notifications.errors.openaiRejectedApiKeyWithStatus', status)
+        : translateNow('notifications.errors.openaiRejectedApiKey')
     }
   },
   {
     test: msg => /neither voice_tools_openai_key nor openai_api_key is set/i.test(msg),
-    summarize: () => 'OpenAI TTS needs VOICE_TOOLS_OPENAI_KEY or OPENAI_API_KEY.'
+    summarize: () => translateNow('notifications.errors.openaiTtsNeedsKey')
   },
   {
     test: msg => /ELEVENLABS_API_KEY not set/i.test(msg) || /ElevenLabs STT API error \(HTTP 401\)/i.test(msg),
     summarize: msg =>
       /ELEVENLABS_API_KEY not set/i.test(msg)
-        ? 'ElevenLabs STT needs ELEVENLABS_API_KEY.'
-        : 'ElevenLabs rejected the API key (401).'
+        ? translateNow('notifications.errors.elevenLabsNeedsKey')
+        : translateNow('notifications.errors.elevenLabsRejectedKey')
   },
   {
     test: msg => /method not allowed/i.test(msg),
-    summarize: () =>
-      'The desktop backend rejected that request (405 Method Not Allowed). Try restarting Hermes Desktop.'
+    summarize: () => translateNow('notifications.errors.methodNotAllowed')
   },
   {
     test: msg => /microphone permission/i.test(msg),
-    summarize: () => 'Microphone permission was denied.'
+    summarize: () => translateNow('notifications.errors.microphonePermission')
   }
 ]
 

package/agent/apps/desktop/src/store/onboarding.test.ts

@@ -7,7 +7,9 @@ import {
   type DesktopOnboardingState,
   type OnboardingContext,
   refreshOnboarding,
-  requestDesktopOnboarding
+  requestDesktopOnboarding,
+  saveOnboardingLocalEndpoint,
+  submitOnboardingCode
 } from './onboarding'
 
 function provider(id: string, name = id): OAuthProvider {
@@ -29,7 +31,9 @@ function baseState(overrides: Partial<DesktopOnboardingState> = {}): DesktopOnbo
     providers: null,
     reason: null,
     requested: false,
+    firstRunSkipped: false,
     manual: false,
+    localEndpoint: false,
     ...overrides
   }
 }
@@ -143,3 +147,269 @@ describe('refreshOnboarding', () => {
     expect($desktopOnboarding.get().providers?.map(p => p.id)).toEqual(['shared'])
   })
 })
+
+describe('OAuth onboarding', () => {
+  beforeEach(() => {
+    window.localStorage.clear()
+    $desktopOnboarding.set(baseState())
+  })
+
+  afterEach(() => {
+    window.localStorage.clear()
+    $desktopOnboarding.set(baseState())
+    vi.restoreAllMocks()
+  })
+
+  it('clears stale readiness errors after OAuth succeeds and model confirmation is shown', async () => {
+    const model = 'anthropic/claude-opus-4.8'
+    const calls: { body?: unknown; path: string }[] = []
+
+    installApiMock(async ({ body, path }: { body?: unknown; path: string }) => {
+      calls.push({ body, path })
+
+      if (path === '/api/providers/oauth/nous/submit') {
+        return { ok: true, status: 'approved' }
+      }
+
+      if (path === '/api/model/options') {
+        return {
+          providers: [
+            {
+              name: 'Nous Portal',
+              slug: 'nous',
+              models: [model]
+            }
+          ]
+        }
+      }
+
+      if (path.startsWith('/api/model/recommended-default?')) {
+        return { provider: 'nous', model, free_tier: false }
+      }
+
+      if (path === '/api/model/set') {
+        return { ok: true, provider: 'nous', model, gateway_tools: [] }
+      }
+
+      throw new Error(`unexpected api path: ${path}`)
+    })
+
+    const requestGateway: OnboardingContext['requestGateway'] = async method => {
+      if (method === 'reload.env') {
+        return {} as never
+      }
+
+      if (method === 'setup.status') {
+        return { provider_configured: true } as never
+      }
+
+      if (method === 'setup.runtime_check') {
+        return { ok: true } as never
+      }
+
+      throw new Error(`unexpected gateway method: ${method}`)
+    }
+
+    $desktopOnboarding.set(
+      baseState({
+        flow: {
+          status: 'awaiting_user',
+          provider: provider('nous', 'Nous Portal'),
+          start: {
+            auth_url: 'https://portal.example/auth',
+            expires_in: 600,
+            flow: 'pkce',
+            session_id: 'portal-session'
+          },
+          code: 'fresh-code'
+        },
+        reason:
+          'No access token found for Nous Portal login. setup.status reports configured credentials, but runtime resolution still failed.',
+        requested: true
+      })
+    )
+
+    await submitOnboardingCode(onboardingContext(requestGateway))
+
+    const state = $desktopOnboarding.get()
+    expect(state.reason).toBeNull()
+    expect(state.flow.status).toBe('confirming_model')
+
+    if (state.flow.status === 'confirming_model') {
+      expect(state.flow.label).toBe('Nous Portal')
+      expect(state.flow.currentModel).toBe(model)
+    }
+
+    expect(calls.some(c => c.path === '/api/model/set')).toBe(true)
+  })
+})
+
+describe('saveOnboardingLocalEndpoint', () => {
+  beforeEach(() => {
+    window.localStorage.clear()
+    $desktopOnboarding.set(baseState())
+  })
+
+  afterEach(() => {
+    window.localStorage.clear()
+    $desktopOnboarding.set(baseState())
+    vi.restoreAllMocks()
+  })
+
+  function readyGateway(): OnboardingContext['requestGateway'] {
+    return async method => {
+      if (method === 'reload.env') {
+        return {} as never
+      }
+
+      if (method === 'setup.status') {
+        return { provider_configured: true } as never
+      }
+
+      if (method === 'setup.runtime_check') {
+        return { ok: true } as never
+      }
+
+      throw new Error(`unexpected gateway method: ${method}`)
+    }
+  }
+
+  it('errors when the endpoint advertises no models (nothing to route to)', async () => {
+    const calls: string[] = []
+    installApiMock(async ({ path }: { path: string }) => {
+      calls.push(path)
+
+      if (path === '/api/providers/validate') {
+        return { ok: true, reachable: true, message: '', models: [] }
+      }
+
+      throw new Error(`unexpected api path: ${path}`)
+    })
+
+    const result = await saveOnboardingLocalEndpoint('http://127.0.0.1:8000/v1', '', {
+      requestGateway: readyGateway()
+    })
+
+    expect(result.ok).toBe(false)
+    expect(result.message).toContain('no models')
+    // Must not attempt to persist an assignment without a model.
+    expect(calls).not.toContain('/api/model/set')
+  })
+
+  it('auto-discovers the model and persists provider=custom + base_url, then finishes', async () => {
+    const calls: { body?: unknown; path: string }[] = []
+
+    const api = vi.fn(async ({ body, path }: { body?: unknown; path: string }) => {
+      calls.push({ body, path })
+
+      if (path === '/api/providers/validate') {
+        return { ok: true, reachable: true, message: '', models: ['llama-3.1-8b', 'qwen2.5-7b'] }
+      }
+
+      if (path === '/api/model/set') {
+        return { ok: true, provider: 'custom', model: 'llama-3.1-8b', base_url: 'http://127.0.0.1:8000/v1' }
+      }
+
+      throw new Error(`unexpected api path: ${path}`)
+    })
+
+    installApiMock(api)
+    const onCompleted = vi.fn()
+
+    const result = await saveOnboardingLocalEndpoint('http://127.0.0.1:8000/v1', '', {
+      onCompleted,
+      requestGateway: readyGateway()
+    })
+
+    expect(result.ok).toBe(true)
+
+    const assign = calls.find(c => c.path === '/api/model/set')
+    expect(assign?.body).toMatchObject({
+      scope: 'main',
+      provider: 'custom',
+      model: 'llama-3.1-8b',
+      base_url: 'http://127.0.0.1:8000/v1'
+    })
+
+    expect(onCompleted).toHaveBeenCalledTimes(1)
+    expect($desktopOnboarding.get().configured).toBe(true)
+  })
+
+  it('forwards the API key to the probe and persists it for auth-gated endpoints', async () => {
+    const calls: { body?: unknown; path: string }[] = []
+
+    const api = vi.fn(async ({ body, path }: { body?: unknown; path: string }) => {
+      calls.push({ body, path })
+
+      if (path === '/api/providers/validate') {
+        return { ok: true, reachable: true, message: '', models: ['gpt-oss-120b'] }
+      }
+
+      if (path === '/api/model/set') {
+        return { ok: true, provider: 'custom', model: 'gpt-oss-120b', base_url: 'https://text.example.com/v1' }
+      }
+
+      throw new Error(`unexpected api path: ${path}`)
+    })
+
+    installApiMock(api)
+
+    const result = await saveOnboardingLocalEndpoint('https://text.example.com/v1', 'sk-secret', {
+      requestGateway: readyGateway()
+    })
+
+    expect(result.ok).toBe(true)
+
+    // The probe must receive the key so an auth-gated /v1/models enumerates.
+    const probe = calls.find(c => c.path === '/api/providers/validate')
+    expect(probe?.body).toMatchObject({ key: 'OPENAI_BASE_URL', value: 'https://text.example.com/v1', api_key: 'sk-secret' })
+
+    // And the key must be persisted alongside the endpoint for runtime auth.
+    const assign = calls.find(c => c.path === '/api/model/set')
+    expect(assign?.body).toMatchObject({
+      scope: 'main',
+      provider: 'custom',
+      model: 'gpt-oss-120b',
+      base_url: 'https://text.example.com/v1',
+      api_key: 'sk-secret'
+    })
+  })
+
+  it('reports the runtime reason when resolution still fails after saving', async () => {
+    installApiMock(async ({ path }: { path: string }) => {
+      if (path === '/api/providers/validate') {
+        return { ok: true, reachable: true, message: '', models: ['llama-3.1-8b'] }
+      }
+
+      if (path === '/api/model/set') {
+        return { ok: true }
+      }
+
+      throw new Error(`unexpected api path: ${path}`)
+    })
+
+    const failingGateway: OnboardingContext['requestGateway'] = async method => {
+      if (method === 'reload.env') {
+        return {} as never
+      }
+
+      if (method === 'setup.status') {
+        return { provider_configured: false } as never
+      }
+
+      if (method === 'setup.runtime_check') {
+        return { ok: false, error: 'No provider can serve the selected model.' } as never
+      }
+
+      throw new Error(`unexpected gateway method: ${method}`)
+    }
+
+    const result = await saveOnboardingLocalEndpoint('http://127.0.0.1:8000/v1', '', {
+      requestGateway: failingGateway
+    })
+
+    expect(result.ok).toBe(false)
+    expect(result.message).toContain('No provider can serve the selected model.')
+    expect($desktopOnboarding.get().configured).not.toBe(true)
+  })
+})