@puredesktop/puredesktop-ui-bridge 1.0.0-beta.1 → 2.1.0

package/src/bridge/react/usePlatformAgentSessions.tsx

@@ -1,60 +1,60 @@
-import type {
-  PlatformAgentSessionRecord,
-  PlatformAgentSessionSummary,
-  PlatformCreateAgentSessionRequest,
-  PlatformListAgentSessionsRequest,
-  PlatformReadAgentSessionRequest,
-  PlatformUpdateAgentSessionRequest,
-} from '../agentTypes.js'
-import {
-  createAgentSession,
-  deleteAgentSession,
-  listAgentSessions,
-  readAgentSession,
-  updateAgentSession,
-} from '../agents.mjs'
-import { useIpc, type UseIpcOptions, type UseIpcResult } from './useIpc.js'
-
-export function usePlatformAgentSessionList(
-  request: PlatformListAgentSessionsRequest,
-  options: UseIpcOptions = {},
-): UseIpcResult<PlatformAgentSessionSummary[]> {
-  return useIpc(
-    () => listAgentSessions(request),
-    [request.scope, request.appSlug],
-    options,
-  )
-}
-
-export function usePlatformAgentSession(
-  request: PlatformReadAgentSessionRequest | null,
-  options: UseIpcOptions = {},
-): UseIpcResult<PlatformAgentSessionRecord | null> {
-  const enabled = Boolean(request) && (options.enabled ?? true)
-  return useIpc(
-    async () => {
-      if (!request) return null
-      return readAgentSession(request)
-    },
-    [request?.scope, request?.appSlug, request?.sessionId],
-    { ...options, enabled },
-  )
-}
-
-export async function createPlatformAgentSession(
-  request: PlatformCreateAgentSessionRequest,
-): Promise<PlatformAgentSessionRecord> {
-  return createAgentSession(request)
-}
-
-export async function updatePlatformAgentSession(
-  request: PlatformUpdateAgentSessionRequest,
-): Promise<PlatformAgentSessionRecord> {
-  return updateAgentSession(request)
-}
-
-export async function deletePlatformAgentSession(
-  request: PlatformReadAgentSessionRequest,
-): Promise<void> {
-  return deleteAgentSession(request)
-}
+import type {
+  PlatformAgentSessionRecord,
+  PlatformAgentSessionSummary,
+  PlatformCreateAgentSessionRequest,
+  PlatformListAgentSessionsRequest,
+  PlatformReadAgentSessionRequest,
+  PlatformUpdateAgentSessionRequest,
+} from '../agentTypes.js'
+import {
+  createAgentSession,
+  deleteAgentSession,
+  listAgentSessions,
+  readAgentSession,
+  updateAgentSession,
+} from '../agents.mjs'
+import { useIpc, type UseIpcOptions, type UseIpcResult } from './useIpc.js'
+
+export function usePlatformAgentSessionList(
+  request: PlatformListAgentSessionsRequest,
+  options: UseIpcOptions = {},
+): UseIpcResult<PlatformAgentSessionSummary[]> {
+  return useIpc(
+    () => listAgentSessions(request),
+    [request.scope, request.appSlug],
+    options,
+  )
+}
+
+export function usePlatformAgentSession(
+  request: PlatformReadAgentSessionRequest | null,
+  options: UseIpcOptions = {},
+): UseIpcResult<PlatformAgentSessionRecord | null> {
+  const enabled = Boolean(request) && (options.enabled ?? true)
+  return useIpc(
+    async () => {
+      if (!request) return null
+      return readAgentSession(request)
+    },
+    [request?.scope, request?.appSlug, request?.sessionId],
+    { ...options, enabled },
+  )
+}
+
+export async function createPlatformAgentSession(
+  request: PlatformCreateAgentSessionRequest,
+): Promise<PlatformAgentSessionRecord> {
+  return createAgentSession(request)
+}
+
+export async function updatePlatformAgentSession(
+  request: PlatformUpdateAgentSessionRequest,
+): Promise<PlatformAgentSessionRecord> {
+  return updateAgentSession(request)
+}
+
+export async function deletePlatformAgentSession(
+  request: PlatformReadAgentSessionRequest,
+): Promise<void> {
+  return deleteAgentSession(request)
+}

package/src/bridge/react/usePlatformAgentTools.tsx

@@ -1,82 +1,82 @@
-import { useEffect, useRef } from 'react'
-import { onAgentToolInvoke, registerAgentTools } from '../agents.mjs'
-
-export interface AgentToolInvokeContext {
-  toolCallId: string
-  shortName: string
-  arguments: Record<string, unknown>
-}
-
-export interface AgentToolHandlerResult {
-  content: string
-  isError?: boolean
-}
-
-export type AgentToolHandler = (
-  ctx: AgentToolInvokeContext,
-) => Promise<AgentToolHandlerResult>
-
-export interface UsePlatformAgentToolsOptions {
-  ready: boolean
-  tools: readonly string[]
-  handlers: Record<string, AgentToolHandler>
-  logLabel?: string
-  /** When set, instanceof checks map domain errors to message text. */
-  errorType?: new (message: string) => Error
-}
-
-export function usePlatformAgentTools({
-  ready,
-  tools,
-  handlers,
-  logLabel = 'app',
-  errorType,
-}: UsePlatformAgentToolsOptions): void {
-  const handlersRef = useRef(handlers)
-  handlersRef.current = handlers
-
-  useEffect(() => {
-    if (!ready) return
-
-    void registerAgentTools({ tools: [...tools] }).catch(error => {
-      console.error(`[${logLabel}] agents.tools.register failed`, error)
-    })
-
-    return onAgentToolInvoke(async payload => {
-      try {
-        const handler = handlersRef.current[payload.shortName]
-        if (!handler) {
-          return {
-            toolCallId: payload.toolCallId,
-            content: `Unknown tool "${payload.shortName}"`,
-            isError: true,
-          }
-        }
-
-        const result = await handler({
-          toolCallId: payload.toolCallId,
-          shortName: payload.shortName,
-          arguments: payload.arguments,
-        })
-
-        return {
-          toolCallId: payload.toolCallId,
-          content: result.content,
-          isError: result.isError,
-        }
-      } catch (error) {
-        const message =
-          errorType && error instanceof errorType
-            ? error.message
-            : error instanceof Error
-            ? error.message
-            : String(error)
-        return {
-          toolCallId: payload.toolCallId,
-          content: message,
-          isError: true,
-        }
-      }
-    })
-  }, [errorType, logLabel, ready, tools])
-}
+import { useEffect, useRef } from 'react'
+import { onAgentToolInvoke, registerAgentTools } from '../agents.mjs'
+
+export interface AgentToolInvokeContext {
+  toolCallId: string
+  shortName: string
+  arguments: Record<string, unknown>
+}
+
+export interface AgentToolHandlerResult {
+  content: string
+  isError?: boolean
+}
+
+export type AgentToolHandler = (
+  ctx: AgentToolInvokeContext,
+) => Promise<AgentToolHandlerResult>
+
+export interface UsePlatformAgentToolsOptions {
+  ready: boolean
+  tools: readonly string[]
+  handlers: Record<string, AgentToolHandler>
+  logLabel?: string
+  /** When set, instanceof checks map domain errors to message text. */
+  errorType?: new (message: string) => Error
+}
+
+export function usePlatformAgentTools({
+  ready,
+  tools,
+  handlers,
+  logLabel = 'app',
+  errorType,
+}: UsePlatformAgentToolsOptions): void {
+  const handlersRef = useRef(handlers)
+  handlersRef.current = handlers
+
+  useEffect(() => {
+    if (!ready) return
+
+    void registerAgentTools({ tools: [...tools] }).catch(error => {
+      console.error(`[${logLabel}] agents.tools.register failed`, error)
+    })
+
+    return onAgentToolInvoke(async payload => {
+      try {
+        const handler = handlersRef.current[payload.shortName]
+        if (!handler) {
+          return {
+            toolCallId: payload.toolCallId,
+            content: `Unknown tool "${payload.shortName}"`,
+            isError: true,
+          }
+        }
+
+        const result = await handler({
+          toolCallId: payload.toolCallId,
+          shortName: payload.shortName,
+          arguments: payload.arguments,
+        })
+
+        return {
+          toolCallId: payload.toolCallId,
+          content: result.content,
+          isError: result.isError,
+        }
+      } catch (error) {
+        const message =
+          errorType && error instanceof errorType
+            ? error.message
+            : error instanceof Error
+            ? error.message
+            : String(error)
+        return {
+          toolCallId: payload.toolCallId,
+          content: message,
+          isError: true,
+        }
+      }
+    })
+  }, [errorType, logLabel, ready, tools])
+}

package/src/bridge/react/usePlatformAppManifest.tsx

@@ -1,32 +1,32 @@
-import { bridge } from '../client.mjs'
-import { PLATFORM_BRIDGE_METHODS } from '../methods.mjs'
-import type { PlatformAppManifest, PlatformShellManifest } from '../types.js'
-import { useIpc } from './useIpc.js'
-
-export interface UsePlatformAppManifestResult {
-  manifest: PlatformAppManifest | null
-  loading: boolean
-  error: Error | null
-}
-
-/**
- * Fetches the shell catalog manifest and returns the `PlatformAppManifest`
- * for the current app (matched by `appSlug`).
- */
-export function usePlatformAppManifest(
-  appSlug: string | null,
-  ready: boolean,
-): UsePlatformAppManifestResult {
-  const { data, loading, error } = useIpc(
-    () =>
-      bridge.call<PlatformShellManifest>(
-        PLATFORM_BRIDGE_METHODS.CATALOG_MANIFEST,
-      ),
-    [],
-    { enabled: ready && appSlug !== null },
-  )
-
-  const manifest = data?.apps.find(app => app.slug === appSlug) ?? null
-
-  return { manifest, loading, error }
-}
+import { bridge } from '../client.mjs'
+import { PLATFORM_BRIDGE_METHODS } from '../methods.mjs'
+import type { PlatformAppManifest, PlatformShellManifest } from '../types.js'
+import { useIpc } from './useIpc.js'
+
+export interface UsePlatformAppManifestResult {
+  manifest: PlatformAppManifest | null
+  loading: boolean
+  error: Error | null
+}
+
+/**
+ * Fetches the shell catalog manifest and returns the `PlatformAppManifest`
+ * for the current app (matched by `appSlug`).
+ */
+export function usePlatformAppManifest(
+  appSlug: string | null,
+  ready: boolean,
+): UsePlatformAppManifestResult {
+  const { data, loading, error } = useIpc(
+    () =>
+      bridge.call<PlatformShellManifest>(
+        PLATFORM_BRIDGE_METHODS.CATALOG_MANIFEST,
+      ),
+    [],
+    { enabled: ready && appSlug !== null },
+  )
+
+  const manifest = data?.apps.find(app => app.slug === appSlug) ?? null
+
+  return { manifest, loading, error }
+}

package/src/bridge/react/usePlatformBridge.tsx

@@ -1,56 +1,56 @@
-import { useEffect, useState } from 'react'
-import { bridge } from '../client.mjs'
-import { PLATFORM_BRIDGE_METHODS } from '../methods.mjs'
-import type { PlatformBridgeReadyMeta } from '../types.js'
-
-export interface UsePlatformBridgeResult {
-  bridge: typeof bridge
-  meta: PlatformBridgeReadyMeta | null
-  error: Error | null
-  ready: boolean
-}
-
-export function usePlatformBridge(): UsePlatformBridgeResult {
-  const [meta, setMeta] = useState<PlatformBridgeReadyMeta | null>(null)
-  const [error, setError] = useState<Error | null>(null)
-
-  useEffect(() => {
-    let cancelled = false
-    bridge
-      .waitForReady()
-      .then(result => {
-        if (!cancelled) setMeta(result)
-      })
-      .catch((err: unknown) => {
-        if (!cancelled) {
-          setError(err instanceof Error ? err : new Error(String(err)))
-        }
-      })
-    return () => {
-      cancelled = true
-    }
-  }, [])
-
-  // Cmd/Ctrl-K belongs to the shell's universal jump palette, but key
-  // events land in whichever iframe has focus — forward them up.
-  useEffect(() => {
-    if (window.parent === window) return undefined
-    const onKey = (event: KeyboardEvent): void => {
-      if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === 'k') {
-        event.preventDefault()
-        void bridge
-          .call(PLATFORM_BRIDGE_METHODS.WORKSPACE_OPEN_PALETTE, [])
-          .catch(() => undefined)
-      }
-    }
-    window.addEventListener('keydown', onKey)
-    return () => window.removeEventListener('keydown', onKey)
-  }, [])
-
-  return {
-    bridge,
-    meta,
-    error,
-    ready: meta !== null,
-  }
-}
+import { useEffect, useState } from 'react'
+import { bridge } from '../client.mjs'
+import { PLATFORM_BRIDGE_METHODS } from '../methods.mjs'
+import type { PlatformBridgeReadyMeta } from '../types.js'
+
+export interface UsePlatformBridgeResult {
+  bridge: typeof bridge
+  meta: PlatformBridgeReadyMeta | null
+  error: Error | null
+  ready: boolean
+}
+
+export function usePlatformBridge(): UsePlatformBridgeResult {
+  const [meta, setMeta] = useState<PlatformBridgeReadyMeta | null>(null)
+  const [error, setError] = useState<Error | null>(null)
+
+  useEffect(() => {
+    let cancelled = false
+    bridge
+      .waitForReady()
+      .then(result => {
+        if (!cancelled) setMeta(result)
+      })
+      .catch((err: unknown) => {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error(String(err)))
+        }
+      })
+    return () => {
+      cancelled = true
+    }
+  }, [])
+
+  // Cmd/Ctrl-K belongs to the shell's universal jump palette, but key
+  // events land in whichever iframe has focus — forward them up.
+  useEffect(() => {
+    if (window.parent === window) return undefined
+    const onKey = (event: KeyboardEvent): void => {
+      if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === 'k') {
+        event.preventDefault()
+        void bridge
+          .call(PLATFORM_BRIDGE_METHODS.WORKSPACE_OPEN_PALETTE, [])
+          .catch(() => undefined)
+      }
+    }
+    window.addEventListener('keydown', onKey)
+    return () => window.removeEventListener('keydown', onKey)
+  }, [])
+
+  return {
+    bridge,
+    meta,
+    error,
+    ready: meta !== null,
+  }
+}

package/src/bridge/react/usePlatformDeepLink.tsx

@@ -1,57 +1,57 @@
-import { useEffect, useRef } from 'react'
-import { bridge } from '../client.mjs'
-import { PLATFORM_BRIDGE_EVENTS } from '../events.mjs'
-import { PLATFORM_BRIDGE_METHODS } from '../methods.mjs'
-
-/**
- * Consume deep links sent via `workspace.openApp({appSlug, resourceId})`.
- * The shell delivers them as resource events with the pseudo-path
- * `purescience://<appSlug>/<resourceId>`; this hook matches this app's
- * slug and hands the resource id to the callback. Subscribe-on-mount so
- * cold-launch deliveries are not missed.
- */
-export function usePlatformDeepLink(
-  appSlug: string,
-  onOpen: (resourceId: string) => void,
-): void {
-  const onOpenRef = useRef(onOpen)
-  onOpenRef.current = onOpen
-
-  useEffect(() => {
-    const prefix = `purescience://${appSlug}/`
-    const handlePath = (path: string): void => {
-      if (path.startsWith(prefix)) {
-        const resourceId = path.slice(prefix.length)
-        if (resourceId) onOpenRef.current(resourceId)
-      }
-    }
-
-    const unsubscribe = bridge.onEvent(
-      PLATFORM_BRIDGE_EVENTS.RESOURCE_OPEN,
-      payload => {
-        handlePath((payload as { path?: string } | null)?.path ?? '')
-      },
-    )
-
-    // Cold launches: the live event can be posted before this app
-    // subscribed, so the shell keeps the intent pending — collect it.
-    let cancelled = false
-    void bridge
-      .waitForReady()
-      .then(() =>
-        bridge.call<{ resource?: { path?: string } | null }>(
-          PLATFORM_BRIDGE_METHODS.CATALOG_CONSUME_PENDING_OPEN,
-          [],
-        ),
-      )
-      .then(result => {
-        if (!cancelled) handlePath(result?.resource?.path ?? '')
-      })
-      .catch(() => undefined)
-
-    return () => {
-      cancelled = true
-      unsubscribe()
-    }
-  }, [appSlug])
-}
+import { useEffect, useRef } from 'react'
+import { bridge } from '../client.mjs'
+import { PLATFORM_BRIDGE_EVENTS } from '../events.mjs'
+import { PLATFORM_BRIDGE_METHODS } from '../methods.mjs'
+
+/**
+ * Consume deep links sent via `workspace.openApp({appSlug, resourceId})`.
+ * The shell delivers them as resource events with the pseudo-path
+ * `purescience://<appSlug>/<resourceId>`; this hook matches this app's
+ * slug and hands the resource id to the callback. Subscribe-on-mount so
+ * cold-launch deliveries are not missed.
+ */
+export function usePlatformDeepLink(
+  appSlug: string,
+  onOpen: (resourceId: string) => void,
+): void {
+  const onOpenRef = useRef(onOpen)
+  onOpenRef.current = onOpen
+
+  useEffect(() => {
+    const prefix = `purescience://${appSlug}/`
+    const handlePath = (path: string): void => {
+      if (path.startsWith(prefix)) {
+        const resourceId = path.slice(prefix.length)
+        if (resourceId) onOpenRef.current(resourceId)
+      }
+    }
+
+    const unsubscribe = bridge.onEvent(
+      PLATFORM_BRIDGE_EVENTS.RESOURCE_OPEN,
+      payload => {
+        handlePath((payload as { path?: string } | null)?.path ?? '')
+      },
+    )
+
+    // Cold launches: the live event can be posted before this app
+    // subscribed, so the shell keeps the intent pending — collect it.
+    let cancelled = false
+    void bridge
+      .waitForReady()
+      .then(() =>
+        bridge.call<{ resource?: { path?: string } | null }>(
+          PLATFORM_BRIDGE_METHODS.CATALOG_CONSUME_PENDING_OPEN,
+          [],
+        ),
+      )
+      .then(result => {
+        if (!cancelled) handlePath(result?.resource?.path ?? '')
+      })
+      .catch(() => undefined)
+
+    return () => {
+      cancelled = true
+      unsubscribe()
+    }
+  }, [appSlug])
+}