@puredesktop/puredesktop-ui-bridge 2.1.8 → 2.1.9

package/src/bridge/react/usePlatformAgentSessionDrive.tsx

@@ -31,10 +31,7 @@ import {
   isAgentAutoModelId,
   DEFAULT_AGENT_HIGH_LEVEL_MODEL_ID,
 } from '../agentModelTiers.js'
-import {
-  getPlatformPreferences,
-  patchPlatformPreferences,
-} from '../preferences.mjs'
+import { patchAgentSessionScopeDefaults } from '../agentScopeDefaults.js'
 import {
   advanceAgentSessionPending,
   approveAgentSessionTools,
@@ -95,10 +92,6 @@ export interface UsePlatformAgentSessionDrive {
   /** Send the composer value, or an explicit message (programmatic). Returns the final snapshot. */
   sendMessage: (message?: string) => Promise<PlatformAgentRunSnapshot | null>
   approveTools: (toolCallIds?: readonly string[]) => Promise<void>
-  approveToolAlwaysForSession: (
-    qualifiedName: string,
-    toolCallId: string,
-  ) => Promise<void>
   rejectTools: (toolCallIds?: readonly string[]) => Promise<void>
   selectSession: (sessionId: string) => Promise<void>
   createNewSession: () => Promise<void>
@@ -121,9 +114,9 @@ interface DriveResult {
 }
 
 /** Display snapshot from a persisted session record (before any live run this turn). */
-function recordSnapshot(
-  record: PlatformAgentSessionRecord | null,
-): PlatformAgentRunSnapshot | null {
+function recordSnapshot(
+  record: PlatformAgentSessionRecord | null,
+): PlatformAgentRunSnapshot | null {
   if (!record) return null
   return {
     runId: record.runId ?? '',
@@ -132,28 +125,10 @@ function recordSnapshot(
     messages: record.snapshot.messages,
     error: record.snapshot.error,
     interruptedReason: record.snapshot.interruptedReason,
-  }
-}
-
-function mergeScopeDefaultPatch(
-  base: PlatformAgentSessionConfigPatch | undefined,
-  patch: PlatformAgentSessionConfigPatch,
-): PlatformAgentSessionConfigPatch {
-  const toolPolicy =
-    patch.toolPolicy || base?.toolPolicy
-      ? {
-          ...base?.toolPolicy,
-          ...patch.toolPolicy,
-          approvalOverrides: {
-            ...base?.toolPolicy?.approvalOverrides,
-            ...patch.toolPolicy?.approvalOverrides,
-          },
-        }
-      : undefined
-  return { ...base, ...patch, ...(toolPolicy ? { toolPolicy } : {}) }
-}
-
-export function usePlatformAgentSessionDrive({
+  }
+}
+
+export function usePlatformAgentSessionDrive({
   appSlug,
   scope: initialScope = 'app',
   enabled = true,
@@ -404,7 +379,7 @@ export function usePlatformAgentSessionDrive({
       : 'This model is not available. Check API keys or local runtime in Settings.'
   }, [modelOptions, selectedModelId])
 
-  const toolPolicy = policy ?? sessionRecord?.config?.toolPolicy ?? undefined
+  const toolPolicy = policy
   const acceptedPendingToolCallIds = useMemo(
     () =>
       sessionRecord?.runId && sessionRecord.runId === threadSnapshot?.runId
@@ -607,28 +582,7 @@ export function usePlatformAgentSessionDrive({
   const persistScopeDefault = useCallback(
     async (patch: PlatformAgentSessionConfigPatch) => {
       try {
-        const prefs = (await getPlatformPreferences()) as {
-          agentSessionDefaults?: {
-            global?: PlatformAgentSessionConfigPatch
-            apps?: Record<string, PlatformAgentSessionConfigPatch>
-          }
-        }
-        const stored = prefs.agentSessionDefaults ?? {}
-        if (scope === 'global') {
-          await patchPlatformPreferences({
-            agentSessionDefaults: {
-              ...stored,
-              global: mergeScopeDefaultPatch(stored.global, patch),
-            },
-          })
-          return
-        }
-        if (!scopeAppSlug) return
-        const apps = { ...(stored.apps ?? {}) }
-        apps[scopeAppSlug] = mergeScopeDefaultPatch(apps[scopeAppSlug], patch)
-        await patchPlatformPreferences({
-          agentSessionDefaults: { ...stored, apps },
-        })
+        await patchAgentSessionScopeDefaults(scope, scopeAppSlug, patch)
       } catch {
         /* scope defaults are best-effort */
       }
@@ -696,30 +650,6 @@ export function usePlatformAgentSessionDrive({
     [persistScopeDefault, sessionQuery, sessionRecord],
   )
 
-  const approveToolAlwaysForSession = useCallback(
-    async (qualifiedName: string, toolCallId: string) => {
-      if (!sessionRecord) return
-      await drive(async () => {
-        const overrides = {
-          ...sessionRecord.config.toolPolicy?.approvalOverrides,
-          [qualifiedName]: false,
-        }
-        const updated = await updateAgentSession({
-          query: sessionQuery(sessionRecord.sessionId),
-          patch: { config: { toolPolicy: { approvalOverrides: overrides } } },
-        })
-        await persistScopeDefault({
-          toolPolicy: { approvalOverrides: overrides },
-        })
-        return approveAgentSessionTools({
-          session: sessionQuery(updated.sessionId),
-          toolCallIds: [toolCallId],
-        })
-      })
-    },
-    [drive, persistScopeDefault, sessionQuery, sessionRecord],
-  )
-
   return {
     scope,
     setScope,
@@ -744,7 +674,6 @@ export function usePlatformAgentSessionDrive({
     sendMessage,
     interruptRun,
     approveTools,
-    approveToolAlwaysForSession,
     rejectTools,
     selectSession,
     createNewSession,

package/src/bridge/react/usePlatformAppSettings.test.tsx

@@ -1,105 +1,105 @@
-// @vitest-environment happy-dom
-import { act } from 'react'
-import { createRoot, type Root } from 'react-dom/client'
-import {
-  afterEach,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-} from 'vitest'
-import { usePlatformAppSettings } from './usePlatformAppSettings.js'
-
-type ReactActGlobal = typeof globalThis & {
-  IS_REACT_ACT_ENVIRONMENT?: boolean
-}
-
-type Settings = Record<string, unknown> & {
-  view: 'list' | 'board'
-}
-
-const appSettingsMock = vi.hoisted(() => ({
-  getPlatformAppSettings: vi.fn(),
-  updatePlatformAppSettings: vi.fn(),
-}))
-
-vi.mock('../appSettings.mjs', () => appSettingsMock)
-
-let latest:
-  | ReturnType<typeof usePlatformAppSettings<Settings>>
-  | null = null
-
-function parseSettings(raw: Record<string, unknown>): Settings {
-  return {
-    view: raw.view === 'board' ? 'board' : 'list',
-  }
-}
-
-function Probe(): React.ReactElement {
-  latest = usePlatformAppSettings<Settings>({
-    appSlug: 'tasks',
-    parse: parseSettings,
-    initialSettings: { view: 'list' },
-  })
-  return <div />
-}
-
-async function flushEffects(): Promise<void> {
-  await act(async () => {
-    await Promise.resolve()
-    await Promise.resolve()
-  })
-}
-
-describe('usePlatformAppSettings', () => {
-  let host: HTMLDivElement
-  let root: Root
-
-  beforeAll(() => {
-    ;(globalThis as ReactActGlobal).IS_REACT_ACT_ENVIRONMENT = true
-  })
-
-  beforeEach(() => {
-    latest = null
-    host = document.createElement('div')
-    document.body.appendChild(host)
-    root = createRoot(host)
-    appSettingsMock.getPlatformAppSettings.mockResolvedValue({ view: 'board' })
-    appSettingsMock.updatePlatformAppSettings.mockResolvedValue({ view: 'list' })
-  })
-
-  afterEach(() => {
-    act(() => root.unmount())
-    host.remove()
-    vi.clearAllMocks()
-  })
-
-  it('loads and normalizes app settings for one app slug', async () => {
-    act(() => {
-      root.render(<Probe />)
-    })
-    await flushEffects()
-
-    expect(appSettingsMock.getPlatformAppSettings).toHaveBeenCalledWith('tasks')
-    expect(latest?.settings).toEqual({ view: 'board' })
-  })
-
-  it('patches app settings through settings.app.update', async () => {
-    act(() => {
-      root.render(<Probe />)
-    })
-    await flushEffects()
-
-    await act(async () => {
-      await latest?.patchSettings({ view: 'list' })
-    })
-
-    expect(appSettingsMock.updatePlatformAppSettings).toHaveBeenCalledWith({
-      appSlug: 'tasks',
-      patch: { view: 'list' },
-    })
-    expect(latest?.settings).toEqual({ view: 'list' })
-  })
-})
+// @vitest-environment happy-dom
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import {
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+} from 'vitest'
+import { usePlatformAppSettings } from './usePlatformAppSettings.js'
+
+type ReactActGlobal = typeof globalThis & {
+  IS_REACT_ACT_ENVIRONMENT?: boolean
+}
+
+type Settings = Record<string, unknown> & {
+  view: 'list' | 'board'
+}
+
+const appSettingsMock = vi.hoisted(() => ({
+  getPlatformAppSettings: vi.fn(),
+  updatePlatformAppSettings: vi.fn(),
+}))
+
+vi.mock('../appSettings.mjs', () => appSettingsMock)
+
+let latest:
+  | ReturnType<typeof usePlatformAppSettings<Settings>>
+  | null = null
+
+function parseSettings(raw: Record<string, unknown>): Settings {
+  return {
+    view: raw.view === 'board' ? 'board' : 'list',
+  }
+}
+
+function Probe(): React.ReactElement {
+  latest = usePlatformAppSettings<Settings>({
+    appSlug: 'tasks',
+    parse: parseSettings,
+    initialSettings: { view: 'list' },
+  })
+  return <div />
+}
+
+async function flushEffects(): Promise<void> {
+  await act(async () => {
+    await Promise.resolve()
+    await Promise.resolve()
+  })
+}
+
+describe('usePlatformAppSettings', () => {
+  let host: HTMLDivElement
+  let root: Root
+
+  beforeAll(() => {
+    ;(globalThis as ReactActGlobal).IS_REACT_ACT_ENVIRONMENT = true
+  })
+
+  beforeEach(() => {
+    latest = null
+    host = document.createElement('div')
+    document.body.appendChild(host)
+    root = createRoot(host)
+    appSettingsMock.getPlatformAppSettings.mockResolvedValue({ view: 'board' })
+    appSettingsMock.updatePlatformAppSettings.mockResolvedValue({ view: 'list' })
+  })
+
+  afterEach(() => {
+    act(() => root.unmount())
+    host.remove()
+    vi.clearAllMocks()
+  })
+
+  it('loads and normalizes app settings for one app slug', async () => {
+    act(() => {
+      root.render(<Probe />)
+    })
+    await flushEffects()
+
+    expect(appSettingsMock.getPlatformAppSettings).toHaveBeenCalledWith('tasks')
+    expect(latest?.settings).toEqual({ view: 'board' })
+  })
+
+  it('patches app settings through settings.app.update', async () => {
+    act(() => {
+      root.render(<Probe />)
+    })
+    await flushEffects()
+
+    await act(async () => {
+      await latest?.patchSettings({ view: 'list' })
+    })
+
+    expect(appSettingsMock.updatePlatformAppSettings).toHaveBeenCalledWith({
+      appSlug: 'tasks',
+      patch: { view: 'list' },
+    })
+    expect(latest?.settings).toEqual({ view: 'list' })
+  })
+})

package/src/bridge/react/usePlatformAppSettings.tsx

@@ -1,104 +1,104 @@
-import { useCallback, useEffect, useState } from 'react'
-import {
-  getPlatformAppSettings,
-  updatePlatformAppSettings,
-} from '../appSettings.mjs'
-
-export interface UsePlatformAppSettingsOptions<
-  TSettings extends Record<string, unknown> = Record<string, unknown>,
-> {
-  appSlug: string | null
-  /** Wait for bridge ready before loading (default: true when appSlug exists). */
-  enabled?: boolean
-  /** Normalize stored settings into the app-owned settings shape. */
-  parse?: (value: Record<string, unknown>) => TSettings
-  initialSettings?: TSettings
-}
-
-export interface UsePlatformAppSettingsResult<
-  TSettings extends Record<string, unknown> = Record<string, unknown>,
-> {
-  settings: TSettings
-  loading: boolean
-  error: Error | null
-  /** Shallow-merge a patch through shell `settings.app.update`. */
-  patchSettings: (patch: Record<string, unknown>) => Promise<TSettings>
-  reload: () => void
-}
-
-function defaultParse<TSettings extends Record<string, unknown>>(
-  value: Record<string, unknown>,
-): TSettings {
-  return value as TSettings
-}
-
-/**
- * Load and update the current app's settings through `settings.app.*`.
- * App settings are small per-app preferences, not user-visible documents.
- */
-export function usePlatformAppSettings<
-  TSettings extends Record<string, unknown> = Record<string, unknown>,
->({
-  appSlug,
-  enabled = Boolean(appSlug),
-  parse = defaultParse<TSettings>,
-  initialSettings = {} as TSettings,
-}: UsePlatformAppSettingsOptions<TSettings>): UsePlatformAppSettingsResult<TSettings> {
-  const [settings, setSettings] = useState<TSettings>(initialSettings)
-  const [loading, setLoading] = useState(false)
-  const [error, setError] = useState<Error | null>(null)
-  const [reloadToken, setReloadToken] = useState(0)
-
-  const reload = useCallback(() => {
-    setReloadToken(token => token + 1)
-  }, [])
-
-  useEffect(() => {
-    if (!enabled || !appSlug) return
-
-    let cancelled = false
-    setLoading(true)
-    setError(null)
-
-    void getPlatformAppSettings(appSlug)
-      .then(raw => {
-        if (!cancelled) setSettings(parse(raw))
-      })
-      .catch((cause: unknown) => {
-        if (!cancelled) {
-          setError(cause instanceof Error ? cause : new Error(String(cause)))
-        }
-      })
-      .finally(() => {
-        if (!cancelled) setLoading(false)
-      })
-
-    return () => {
-      cancelled = true
-    }
-  }, [appSlug, enabled, parse, reloadToken])
-
-  const patchSettings = useCallback(
-    async (patch: Record<string, unknown>): Promise<TSettings> => {
-      if (!appSlug) throw new Error('appSlug is required to update app settings')
-      try {
-        const next = parse(
-          await updatePlatformAppSettings({
-            appSlug,
-            patch,
-          }),
-        )
-        setSettings(next)
-        setError(null)
-        return next
-      } catch (cause) {
-        const error = cause instanceof Error ? cause : new Error(String(cause))
-        setError(error)
-        throw error
-      }
-    },
-    [appSlug, parse],
-  )
-
-  return { settings, loading, error, patchSettings, reload }
-}
+import { useCallback, useEffect, useState } from 'react'
+import {
+  getPlatformAppSettings,
+  updatePlatformAppSettings,
+} from '../appSettings.mjs'
+
+export interface UsePlatformAppSettingsOptions<
+  TSettings extends Record<string, unknown> = Record<string, unknown>,
+> {
+  appSlug: string | null
+  /** Wait for bridge ready before loading (default: true when appSlug exists). */
+  enabled?: boolean
+  /** Normalize stored settings into the app-owned settings shape. */
+  parse?: (value: Record<string, unknown>) => TSettings
+  initialSettings?: TSettings
+}
+
+export interface UsePlatformAppSettingsResult<
+  TSettings extends Record<string, unknown> = Record<string, unknown>,
+> {
+  settings: TSettings
+  loading: boolean
+  error: Error | null
+  /** Shallow-merge a patch through shell `settings.app.update`. */
+  patchSettings: (patch: Record<string, unknown>) => Promise<TSettings>
+  reload: () => void
+}
+
+function defaultParse<TSettings extends Record<string, unknown>>(
+  value: Record<string, unknown>,
+): TSettings {
+  return value as TSettings
+}
+
+/**
+ * Load and update the current app's settings through `settings.app.*`.
+ * App settings are small per-app preferences, not user-visible documents.
+ */
+export function usePlatformAppSettings<
+  TSettings extends Record<string, unknown> = Record<string, unknown>,
+>({
+  appSlug,
+  enabled = Boolean(appSlug),
+  parse = defaultParse<TSettings>,
+  initialSettings = {} as TSettings,
+}: UsePlatformAppSettingsOptions<TSettings>): UsePlatformAppSettingsResult<TSettings> {
+  const [settings, setSettings] = useState<TSettings>(initialSettings)
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<Error | null>(null)
+  const [reloadToken, setReloadToken] = useState(0)
+
+  const reload = useCallback(() => {
+    setReloadToken(token => token + 1)
+  }, [])
+
+  useEffect(() => {
+    if (!enabled || !appSlug) return
+
+    let cancelled = false
+    setLoading(true)
+    setError(null)
+
+    void getPlatformAppSettings(appSlug)
+      .then(raw => {
+        if (!cancelled) setSettings(parse(raw))
+      })
+      .catch((cause: unknown) => {
+        if (!cancelled) {
+          setError(cause instanceof Error ? cause : new Error(String(cause)))
+        }
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false)
+      })
+
+    return () => {
+      cancelled = true
+    }
+  }, [appSlug, enabled, parse, reloadToken])
+
+  const patchSettings = useCallback(
+    async (patch: Record<string, unknown>): Promise<TSettings> => {
+      if (!appSlug) throw new Error('appSlug is required to update app settings')
+      try {
+        const next = parse(
+          await updatePlatformAppSettings({
+            appSlug,
+            patch,
+          }),
+        )
+        setSettings(next)
+        setError(null)
+        return next
+      } catch (cause) {
+        const error = cause instanceof Error ? cause : new Error(String(cause))
+        setError(error)
+        throw error
+      }
+    },
+    [appSlug, parse],
+  )
+
+  return { settings, loading, error, patchSettings, reload }
+}