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

package/src/bridge/vision.d.mts

@@ -0,0 +1,22 @@
+export interface PlatformImageGenerateRequest {
+  prompt: string
+  sourceImages?: Array<{
+    base64: string
+    mimeType: string
+    name?: string
+  }>
+  model?: string
+  size?: 'auto' | '1024x1024' | '1536x1024' | '1024x1536'
+  quality?: 'auto' | 'low' | 'medium' | 'high'
+  outputFormat?: 'png' | 'jpeg' | 'webp'
+}
+
+export interface PlatformImageGenerateResponse {
+  base64: string
+  mimeType: string
+  model: string
+}
+
+export declare function generatePlatformImage(
+  request: PlatformImageGenerateRequest,
+): Promise<PlatformImageGenerateResponse>

package/src/bridge/vision.mjs

@@ -0,0 +1,20 @@
+import { bridge } from './client.mjs'
+import { PLATFORM_BRIDGE_METHODS } from './methods.mjs'
+
+/**
+ * Generate a raster image through the shell's credential-safe vision bridge.
+ * The caller receives raw base64 without a data URL prefix.
+ *
+ * @param {{
+ *   prompt: string,
+ *   sourceImages?: Array<{ base64: string, mimeType: string, name?: string }>,
+ *   model?: string,
+ *   size?: 'auto' | '1024x1024' | '1536x1024' | '1024x1536',
+ *   quality?: 'auto' | 'low' | 'medium' | 'high',
+ *   outputFormat?: 'png' | 'jpeg' | 'webp',
+ * }} request
+ * @returns {Promise<{ base64: string, mimeType: string, model: string }>}
+ */
+export async function generatePlatformImage(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.VISION_GENERATE_IMAGE, [request])
+}

package/src/bridge/watch.d.mts

@@ -1,9 +1,9 @@
-import type { WatchChangeEvent } from './types.js'
-
-export function watchStart(rootPath: string): Promise<void>
-
-export function watchStop(rootPath: string): Promise<void>
-
-export function onWatchChange(
-  listener: (payload: WatchChangeEvent) => void,
-): () => void
+import type { WatchChangeEvent } from './types.js'
+
+export function watchStart(rootPath: string): Promise<void>
+
+export function watchStop(rootPath: string): Promise<void>
+
+export function onWatchChange(
+  listener: (payload: WatchChangeEvent) => void,
+): () => void

package/src/bridge/watch.mjs

@@ -1,34 +1,34 @@
-import { bridge } from './client.mjs'
-import { PLATFORM_BRIDGE_EVENTS } from './events.mjs'
-import { PLATFORM_BRIDGE_METHODS } from './methods.mjs'
-
-/**
- * Start watching a directory for debounced filesystem events.
- * Requires `filesystem` permission.
- *
- * @param {string} rootPath Absolute path to watch
- * @returns {Promise<void>}
- */
-export async function watchStart(rootPath) {
-  return bridge.call(PLATFORM_BRIDGE_METHODS.WATCH_START, [rootPath])
-}
-
-/**
- * Stop watching a directory for this plugin tab.
- *
- * @param {string} rootPath Same absolute path passed to watchStart
- * @returns {Promise<void>}
- */
-export async function watchStop(rootPath) {
-  return bridge.call(PLATFORM_BRIDGE_METHODS.WATCH_STOP, [rootPath])
-}
-
-/**
- * Subscribe to watch.change events for paths this tab is watching.
- *
- * @param {(payload: import('./types.js').WatchChangeEvent) => void} listener
- * @returns {() => void} unsubscribe
- */
-export function onWatchChange(listener) {
-  return bridge.onEvent(PLATFORM_BRIDGE_EVENTS.WATCH_CHANGE, listener)
-}
+import { bridge } from './client.mjs'
+import { PLATFORM_BRIDGE_EVENTS } from './events.mjs'
+import { PLATFORM_BRIDGE_METHODS } from './methods.mjs'
+
+/**
+ * Start watching a directory for debounced filesystem events.
+ * Requires `filesystem` permission.
+ *
+ * @param {string} rootPath Absolute path to watch
+ * @returns {Promise<void>}
+ */
+export async function watchStart(rootPath) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.WATCH_START, [rootPath])
+}
+
+/**
+ * Stop watching a directory for this plugin tab.
+ *
+ * @param {string} rootPath Same absolute path passed to watchStart
+ * @returns {Promise<void>}
+ */
+export async function watchStop(rootPath) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.WATCH_STOP, [rootPath])
+}
+
+/**
+ * Subscribe to watch.change events for paths this tab is watching.
+ *
+ * @param {(payload: import('./types.js').WatchChangeEvent) => void} listener
+ * @returns {() => void} unsubscribe
+ */
+export function onWatchChange(listener) {
+  return bridge.onEvent(PLATFORM_BRIDGE_EVENTS.WATCH_CHANGE, listener)
+}

package/src/bridge/watch.ts

@@ -1 +1 @@
-export { onWatchChange, watchStart, watchStop } from './watch.mjs'
+export { onWatchChange, watchStart, watchStop } from './watch.mjs'

package/src/bridge/window.d.mts

@@ -1,44 +1,44 @@
-export type PlatformScreenCaptureMode = 'content' | 'ui'
-
-export interface PlatformScreenCaptureRect {
-  x: number
-  y: number
-  width: number
-  height: number
-}
-
-export interface PlatformScreenCaptureOptionChoice {
-  value: string
-  label: string
-}
-
-/** A contextual control the overlay renders (e.g. design scope: this/all). */
-export interface PlatformScreenCaptureOption {
-  id: string
-  label: string
-  type: 'toggle' | 'choice'
-  choices?: PlatformScreenCaptureOptionChoice[]
-  default?: string | boolean
-}
-
-export type PlatformScreenCaptureOptionValues = Record<string, string | boolean>
-
-export interface PlatformScreenCaptureResult {
-  /** PNG data URL of the cropped region with the drawn marks composited in. */
-  imageDataUrl: string
-  /** Selection rect — app-local px in content mode, window px in vibe mode. */
-  rect: PlatformScreenCaptureRect
-  note: string
-  mode: PlatformScreenCaptureMode
-  /** True when the user drew pen marks — the agent should focus on them. */
-  hasMarks: boolean
-  /** Selected values for the contextual option controls, keyed by option id. */
-  optionValues: PlatformScreenCaptureOptionValues
-}
-
-export declare function startScreenCapture(options?: {
-  label?: string
-  options?: PlatformScreenCaptureOption[]
-}): Promise<PlatformScreenCaptureResult | null>
-
-export declare function onScreenCaptureShortcut(listener: () => void): () => void
+export type PlatformScreenCaptureMode = 'content' | 'ui'
+
+export interface PlatformScreenCaptureRect {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+export interface PlatformScreenCaptureOptionChoice {
+  value: string
+  label: string
+}
+
+/** A contextual control the overlay renders (e.g. design scope: this/all). */
+export interface PlatformScreenCaptureOption {
+  id: string
+  label: string
+  type: 'toggle' | 'choice'
+  choices?: PlatformScreenCaptureOptionChoice[]
+  default?: string | boolean
+}
+
+export type PlatformScreenCaptureOptionValues = Record<string, string | boolean>
+
+export interface PlatformScreenCaptureResult {
+  /** PNG data URL of the cropped region with the drawn marks composited in. */
+  imageDataUrl: string
+  /** Selection rect — app-local px in content mode, window px in vibe mode. */
+  rect: PlatformScreenCaptureRect
+  note: string
+  mode: PlatformScreenCaptureMode
+  /** True when the user drew pen marks — the agent should focus on them. */
+  hasMarks: boolean
+  /** Selected values for the contextual option controls, keyed by option id. */
+  optionValues: PlatformScreenCaptureOptionValues
+}
+
+export declare function startScreenCapture(options?: {
+  label?: string
+  options?: PlatformScreenCaptureOption[]
+}): Promise<PlatformScreenCaptureResult | null>
+
+export declare function onScreenCaptureShortcut(listener: () => void): () => void

package/src/bridge/window.mjs

@@ -1,33 +1,33 @@
-import { bridge } from './client.mjs'
-import { PLATFORM_BRIDGE_EVENTS } from './events.mjs'
-import { PLATFORM_BRIDGE_METHODS } from './methods.mjs'
-
-/**
- * Start the shell's chromeless screen-capture overlay. The user drags a region,
- * draws marks, and adds a note; resolves with the cropped annotated image plus
- * the selection rect (app-local px in content mode, window px in vibe mode), or
- * null if cancelled. Requires `agents` permission.
- *
- * @param {{ label?: string, options?: import('./window.d.mts').PlatformScreenCaptureOption[] }} [options]
- *   `label` states what the capture transforms (e.g. "book content", "page
- *   design"); `options` are contextual controls rendered in the overlay.
- * @returns {Promise<import('./window.d.mts').PlatformScreenCaptureResult | null>}
- */
-export async function startScreenCapture(options = {}) {
-  return bridge.call(PLATFORM_BRIDGE_METHODS.WINDOW_START_SCREEN_CAPTURE, [
-    { label: options.label, options: options.options },
-  ])
-}
-
-/**
- * Subscribe to the window-wide camera shortcut (Cmd/Ctrl+Shift+X), forwarded to
- * the active app. Apps typically respond by opening their default capture.
- *
- * @param {() => void} listener
- * @returns {() => void} unsubscribe
- */
-export function onScreenCaptureShortcut(listener) {
-  return bridge.onEvent(PLATFORM_BRIDGE_EVENTS.WINDOW_CAMERA_SHORTCUT, () => {
-    listener()
-  })
-}
+import { bridge } from './client.mjs'
+import { PLATFORM_BRIDGE_EVENTS } from './events.mjs'
+import { PLATFORM_BRIDGE_METHODS } from './methods.mjs'
+
+/**
+ * Start the shell's chromeless screen-capture overlay. The user drags a region,
+ * draws marks, and adds a note; resolves with the cropped annotated image plus
+ * the selection rect (app-local px in content mode, window px in vibe mode), or
+ * null if cancelled. Requires `agents` permission.
+ *
+ * @param {{ label?: string, options?: import('./window.d.mts').PlatformScreenCaptureOption[] }} [options]
+ *   `label` states what the capture transforms (e.g. "book content", "page
+ *   design"); `options` are contextual controls rendered in the overlay.
+ * @returns {Promise<import('./window.d.mts').PlatformScreenCaptureResult | null>}
+ */
+export async function startScreenCapture(options = {}) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.WINDOW_START_SCREEN_CAPTURE, [
+    { label: options.label, options: options.options },
+  ])
+}
+
+/**
+ * Subscribe to the window-wide camera shortcut (Cmd/Ctrl+Shift+X), forwarded to
+ * the active app. Apps typically respond by opening their default capture.
+ *
+ * @param {() => void} listener
+ * @returns {() => void} unsubscribe
+ */
+export function onScreenCaptureShortcut(listener) {
+  return bridge.onEvent(PLATFORM_BRIDGE_EVENTS.WINDOW_CAMERA_SHORTCUT, () => {
+    listener()
+  })
+}

package/src/chrome/index.ts

@@ -1 +1 @@
-export * from '../components/chrome/index.js'
+export * from '../components/chrome/index.js'

package/src/commitments/commitments.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it } from 'vitest'
+import {
+  commitmentBuckets,
+  commitmentDueState,
+  commitmentIsGoneQuiet,
+  commitmentsByCounterparty,
+  createCommitment,
+  dismissCommitment,
+  emptyCommitmentStore,
+  filterCommitments,
+  reactivateSnoozedCommitments,
+  resolveCommitment,
+  snoozeCommitment,
+} from './commitments.js'
+
+const NOW = '2026-06-21T12:00:00.000Z'
+
+describe('commitments domain model', () => {
+  it('creates manual commitments without a source quote', () => {
+    const commitment = createCommitment(
+      {
+        direction: 'you_owe',
+        summary: 'Send the launch copy',
+        counterparty: 'Mira',
+      },
+      NOW,
+    )
+
+    expect(commitment.source).toBeUndefined()
+    expect(commitment.sourceQuote).toBeUndefined()
+    expect(commitment.status).toBe('open')
+  })
+
+  it('requires a quote for extracted commitments', () => {
+    expect(() =>
+      createCommitment(
+        {
+          direction: 'waiting_on',
+          summary: 'Review the proposal',
+          counterparty: 'Roger',
+          source: {
+            type: 'mail',
+            id: 'msg_1',
+            label: 'Proposal thread',
+          },
+        },
+        NOW,
+      ),
+    ).toThrow(/source quote/i)
+  })
+
+  it('classifies due-today and overdue commitments', () => {
+    const store = {
+      ...emptyCommitmentStore(),
+      commitments: [
+        createCommitment(
+          {
+            direction: 'you_owe',
+            summary: 'Due today',
+            counterparty: 'Mira',
+            dueAt: '2026-06-21T23:00:00.000Z',
+          },
+          NOW,
+        ),
+        createCommitment(
+          {
+            direction: 'waiting_on',
+            summary: 'Overdue',
+            counterparty: 'Roger',
+            dueAt: '2026-06-19T09:00:00.000Z',
+          },
+          NOW,
+        ),
+      ],
+    }
+
+    expect(commitmentDueState(store.commitments[0], NOW)).toBe('due_today')
+    expect(commitmentDueState(store.commitments[1], NOW)).toBe('overdue')
+    expect(filterCommitments(store, 'due_today', { now: NOW })).toHaveLength(1)
+    expect(filterCommitments(store, 'overdue', { now: NOW })).toHaveLength(1)
+  })
+
+  it('groups open commitments by direction', () => {
+    const store = {
+      ...emptyCommitmentStore(),
+      commitments: [
+        createCommitment(
+          {
+            direction: 'you_owe',
+            summary: 'Send notes',
+            counterparty: 'Nadia',
+          },
+          NOW,
+        ),
+        createCommitment(
+          {
+            direction: 'waiting_on',
+            summary: 'Approval',
+            counterparty: 'Mira',
+          },
+          NOW,
+        ),
+      ],
+    }
+
+    const buckets = commitmentBuckets(store, { now: NOW })
+    expect(buckets.youOwe).toHaveLength(1)
+    expect(buckets.waitingOn).toHaveLength(1)
+  })
+
+  it('preserves resolved and dismissed commitments outside open lists', () => {
+    const open = createCommitment(
+      {
+        direction: 'you_owe',
+        summary: 'Close loop',
+        counterparty: 'Mira',
+      },
+      NOW,
+    )
+    const resolved = resolveCommitment(open, '2026-06-21T13:00:00.000Z')
+    const dismissed = dismissCommitment(
+      createCommitment(
+        {
+          direction: 'waiting_on',
+          summary: 'Old ask',
+          counterparty: 'Roger',
+        },
+        NOW,
+      ),
+      '2026-06-21T13:00:00.000Z',
+    )
+    const store = { ...emptyCommitmentStore(), commitments: [resolved, dismissed] }
+
+    expect(commitmentBuckets(store, { now: NOW }).youOwe).toHaveLength(0)
+    expect(commitmentBuckets(store, { now: NOW, includeClosed: true }).youOwe).toHaveLength(1)
+  })
+
+  it('hides snoozed commitments until their snooze date', () => {
+    const commitment = createCommitment(
+      {
+        direction: 'waiting_on',
+        summary: 'Reply from Sam',
+        counterparty: 'Sam',
+      },
+      NOW,
+    )
+    const snoozed = snoozeCommitment(
+      commitment,
+      '2026-06-22T09:00:00.000Z',
+      NOW,
+    )
+    const store = { ...emptyCommitmentStore(), commitments: [snoozed] }
+
+    expect(commitmentBuckets(store, { now: NOW }).waitingOn).toHaveLength(0)
+    expect(commitmentBuckets(store, { now: NOW }).snoozed).toHaveLength(1)
+
+    const reactivated = reactivateSnoozedCommitments(
+      store,
+      '2026-06-22T10:00:00.000Z',
+    )
+    expect(reactivated.commitments[0].status).toBe('open')
+  })
+
+  it('only marks waiting-on commitments as gone quiet', () => {
+    const waiting = createCommitment(
+      {
+        direction: 'waiting_on',
+        summary: 'Quiet approval',
+        counterparty: 'Roger',
+      },
+      '2026-06-10T12:00:00.000Z',
+    )
+    const owed = createCommitment(
+      {
+        direction: 'you_owe',
+        summary: 'Quiet owed item',
+        counterparty: 'Mira',
+      },
+      '2026-06-10T12:00:00.000Z',
+    )
+
+    expect(commitmentIsGoneQuiet(waiting, { now: NOW })).toBe(true)
+    expect(commitmentIsGoneQuiet(owed, { now: NOW })).toBe(false)
+  })
+
+  it('queries by counterparty and preserves task links', () => {
+    const commitment = createCommitment(
+      {
+        direction: 'you_owe',
+        summary: 'Create task',
+        counterparty: 'Mira',
+        links: [{ type: 'task', id: 'task_1', label: 'Draft launch copy' }],
+      },
+      NOW,
+    )
+    const store = { ...emptyCommitmentStore(), commitments: [commitment] }
+
+    expect(commitmentsByCounterparty(store, 'mira', { now: NOW })).toHaveLength(1)
+    expect(store.commitments[0].links?.[0].type).toBe('task')
+  })
+})