@puredesktop/puredesktop-ui-bridge 2.1.7 → 2.1.9

package/src/ics/generateIcs.ts

@@ -0,0 +1,197 @@
+/**
+ * Minimal iCalendar (RFC 5545) writer for the mail↔calendar invite loop:
+ * `REQUEST` (send/update an invite), `REPLY` (RSVP), `CANCEL`.
+ *
+ * All date-times are emitted in UTC (`...Z`) so no VTIMEZONE component is
+ * needed; all-day events use DATE values. Output round-trips through the
+ * ICAL.js parser used by PureMail's invite reader.
+ */
+
+export type IcsMethod = 'REQUEST' | 'REPLY' | 'CANCEL'
+
+export type IcsPartstat =
+  | 'ACCEPTED'
+  | 'DECLINED'
+  | 'TENTATIVE'
+  | 'NEEDS-ACTION'
+
+export interface IcsPerson {
+  email: string
+  name?: string
+  partstat?: IcsPartstat
+  /** RSVP requested from this attendee (REQUEST invites). */
+  rsvp?: boolean
+}
+
+export interface IcsEventInput {
+  uid: string
+  /**
+   * iTIP method. Omit for a plain (non-iTIP) VCALENDAR — e.g. "Download .ics"
+   * of an event to share. When undefined, no `METHOD:` line is emitted.
+   */
+  method?: IcsMethod
+  /** Bumped by the organizer on every update; echoed in replies. */
+  sequence?: number
+  /** ISO timestamp for DTSTAMP — pass explicitly so output is deterministic. */
+  timestamp: string
+  title: string
+  description?: string
+  location?: string
+  /** ISO date-time (or YYYY-MM-DD when allDay). */
+  startsAt: string
+  endsAt: string
+  allDay?: boolean
+  organizer?: IcsPerson
+  attendees?: IcsPerson[]
+  status?: 'CONFIRMED' | 'CANCELLED' | 'TENTATIVE'
+  /** Full RRULE value, e.g. `FREQ=WEEKLY;INTERVAL=1` (no `RRULE:` prefix). */
+  rrule?: string
+}
+
+/** RFC 5545 §3.3.11 TEXT escaping. */
+export function escapeIcsText(value: string): string {
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/;/g, '\\;')
+    .replace(/,/g, '\\,')
+    .replace(/\r?\n/g, '\\n')
+}
+
+/** RFC 5545 §3.1 line folding at 75 octets (approximated per char). */
+export function foldIcsLine(line: string): string {
+  if (line.length <= 75) return line
+  const parts: string[] = []
+  let rest = line
+  parts.push(rest.slice(0, 75))
+  rest = rest.slice(75)
+  while (rest.length > 74) {
+    parts.push(` ${rest.slice(0, 74)}`)
+    rest = rest.slice(74)
+  }
+  if (rest) parts.push(` ${rest}`)
+  return parts.join('\r\n')
+}
+
+function utcBasic(iso: string): string {
+  const date = new Date(iso)
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid ICS date-time: ${iso}`)
+  }
+  return date
+    .toISOString()
+    .replace(/[-:]/g, '')
+    .replace(/\.\d{3}Z$/, 'Z')
+}
+
+function dateBasic(iso: string): string {
+  const day = iso.slice(0, 10)
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) {
+    throw new Error(`Invalid ICS date: ${iso}`)
+  }
+  return day.replace(/-/g, '')
+}
+
+function personProperty(
+  property: 'ORGANIZER' | 'ATTENDEE',
+  person: IcsPerson,
+): string {
+  const params: string[] = []
+  if (person.name) params.push(`CN=${escapeIcsText(person.name)}`)
+  if (property === 'ATTENDEE') {
+    if (person.partstat) params.push(`PARTSTAT=${person.partstat}`)
+    if (person.rsvp) params.push('RSVP=TRUE')
+  }
+  const paramText = params.length ? `;${params.join(';')}` : ''
+  return `${property}${paramText}:mailto:${person.email}`
+}
+
+export function generateIcsCalendar(input: IcsEventInput): string {
+  const lines: string[] = [
+    'BEGIN:VCALENDAR',
+    'PRODID:-//PureScience//PureDesktop//EN',
+    'VERSION:2.0',
+    ...(input.method ? [`METHOD:${input.method}`] : []),
+    'BEGIN:VEVENT',
+    `UID:${escapeIcsText(input.uid)}`,
+    `DTSTAMP:${utcBasic(input.timestamp)}`,
+    `SEQUENCE:${input.sequence ?? 0}`,
+    input.allDay
+      ? `DTSTART;VALUE=DATE:${dateBasic(input.startsAt)}`
+      : `DTSTART:${utcBasic(input.startsAt)}`,
+    input.allDay
+      ? `DTEND;VALUE=DATE:${dateBasic(input.endsAt)}`
+      : `DTEND:${utcBasic(input.endsAt)}`,
+    `SUMMARY:${escapeIcsText(input.title)}`,
+  ]
+  if (input.description) {
+    lines.push(`DESCRIPTION:${escapeIcsText(input.description)}`)
+  }
+  if (input.location) {
+    lines.push(`LOCATION:${escapeIcsText(input.location)}`)
+  }
+  if (input.status ?? input.method === 'CANCEL') {
+    lines.push(`STATUS:${input.status ?? 'CANCELLED'}`)
+  }
+  if (input.rrule) lines.push(`RRULE:${input.rrule}`)
+  if (input.organizer) {
+    lines.push(personProperty('ORGANIZER', input.organizer))
+  }
+  for (const attendee of input.attendees ?? []) {
+    lines.push(personProperty('ATTENDEE', attendee))
+  }
+  lines.push('END:VEVENT', 'END:VCALENDAR')
+  return `${lines.map(foldIcsLine).join('\r\n')}\r\n`
+}
+
+/**
+ * Plain event export: a VCALENDAR with no iTIP METHOD, for "Download .ics"
+ * of an event to share.
+ */
+export function generateIcsEventExport(
+  input: Omit<IcsEventInput, 'method'>,
+): string {
+  return generateIcsCalendar(input)
+}
+
+export interface IcsReplyInput {
+  /** UID of the invite being answered — must match the original. */
+  uid: string
+  /** SEQUENCE of the invite being answered — echoed back. */
+  sequence?: number
+  timestamp: string
+  title: string
+  startsAt: string
+  endsAt: string
+  allDay?: boolean
+  organizer: IcsPerson
+  /** The account answering the invite. */
+  attendee: IcsPerson
+  response: 'accepted' | 'declined' | 'tentative'
+}
+
+const PARTSTAT_BY_RESPONSE: Record<IcsReplyInput['response'], IcsPartstat> = {
+  accepted: 'ACCEPTED',
+  declined: 'DECLINED',
+  tentative: 'TENTATIVE',
+}
+
+/** iMIP RSVP: a `METHOD:REPLY` VCALENDAR mailed back to the organizer. */
+export function generateIcsReply(input: IcsReplyInput): string {
+  return generateIcsCalendar({
+    uid: input.uid,
+    method: 'REPLY',
+    ...(input.sequence !== undefined ? { sequence: input.sequence } : {}),
+    timestamp: input.timestamp,
+    title: input.title,
+    startsAt: input.startsAt,
+    endsAt: input.endsAt,
+    ...(input.allDay ? { allDay: true } : {}),
+    organizer: input.organizer,
+    attendees: [
+      {
+        ...input.attendee,
+        partstat: PARTSTAT_BY_RESPONSE[input.response],
+      },
+    ],
+  })
+}

package/src/index.ts

@@ -140,11 +140,14 @@ export {
   ConnectionSetupGrid,
   ConnectionSetupPage,
   ConnectionStepList,
+  ProviderConnection,
   type ConnectionOptionCardProps,
   type ConnectionOptionTone,
   type ConnectionSavedCardProps,
   type ConnectionSetupPageProps,
   type ConnectionStep,
+  type ProviderConnectionClient,
+  type ProviderConnectionProps,
 } from './components/common/connections/index.js'
 export {
   OpenReviewCard,

package/src/net/httpRetry.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+  retryAfterMs,
+  withHttpRetry,
+  type HttpRetryOptions,
+} from './httpRetry.js'
+
+function response(status: number, headers?: Record<string, string>) {
+  return { status, ok: status >= 200 && status < 300, headers }
+}
+
+function options(overrides: HttpRetryOptions = {}): HttpRetryOptions {
+  return {
+    sleep: vi.fn(async () => undefined),
+    random: () => 1,
+    now: () => 1_800_000_000_000,
+    ...overrides,
+  }
+}
+
+describe('withHttpRetry', () => {
+  it('returns a success immediately', async () => {
+    const attempt = vi.fn(async () => response(200))
+    const result = await withHttpRetry(attempt, options())
+    expect(result.status).toBe(200)
+    expect(attempt).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not retry non-retryable client errors', async () => {
+    const attempt = vi.fn(async () => response(403))
+    const result = await withHttpRetry(attempt, options())
+    expect(result.status).toBe(403)
+    expect(attempt).toHaveBeenCalledTimes(1)
+  })
+
+  it('retries 429 and 5xx with exponential backoff until success', async () => {
+    const sleep = vi.fn(async (_ms: number) => undefined)
+    const responses = [response(429), response(500), response(200)]
+    const attempt = vi.fn(async () => responses.shift() ?? response(200))
+    const result = await withHttpRetry(
+      attempt,
+      options({ sleep, maxAttempts: 3 }),
+    )
+    expect(result.status).toBe(200)
+    expect(attempt).toHaveBeenCalledTimes(3)
+    expect(sleep).toHaveBeenCalledTimes(2)
+    // Full-jitter with random()=1 → the raw step: 500ms then 1000ms.
+    expect(sleep.mock.calls.map(call => call[0])).toEqual([500, 1000])
+  })
+
+  it('returns the last failure when the budget is exhausted', async () => {
+    const attempt = vi.fn(async () => response(503))
+    const result = await withHttpRetry(attempt, options({ maxAttempts: 2 }))
+    expect(result.status).toBe(503)
+    expect(attempt).toHaveBeenCalledTimes(2)
+  })
+
+  it('honors Retry-After seconds over computed backoff', async () => {
+    const sleep = vi.fn(async (_ms: number) => undefined)
+    const responses = [response(429, { 'retry-after': '2' }), response(200)]
+    const attempt = vi.fn(async () => responses.shift() ?? response(200))
+    await withHttpRetry(attempt, options({ sleep }))
+    expect(sleep).toHaveBeenCalledWith(2000)
+  })
+
+  it('retries a 401 exactly once', async () => {
+    const responses = [response(401), response(401)]
+    const attempt = vi.fn(async () => responses.shift() ?? response(200))
+    const result = await withHttpRetry(attempt, options())
+    // Second 401 is returned, not retried again.
+    expect(result.status).toBe(401)
+    expect(attempt).toHaveBeenCalledTimes(2)
+  })
+
+  it('recovers when the 401 retry succeeds', async () => {
+    const responses = [response(401), response(200)]
+    const attempt = vi.fn(async () => responses.shift() ?? response(200))
+    const result = await withHttpRetry(attempt, options())
+    expect(result.status).toBe(200)
+  })
+
+  it('retries thrown network errors and rethrows the last one', async () => {
+    const attempt = vi.fn(async () => {
+      throw new Error('socket hang up')
+    })
+    await expect(
+      withHttpRetry(attempt, options({ maxAttempts: 3 })),
+    ).rejects.toThrow('socket hang up')
+    expect(attempt).toHaveBeenCalledTimes(3)
+  })
+
+  it('recovers from a transient network error', async () => {
+    let first = true
+    const attempt = vi.fn(async () => {
+      if (first) {
+        first = false
+        throw new Error('reset')
+      }
+      return response(200)
+    })
+    const result = await withHttpRetry(attempt, options())
+    expect(result.status).toBe(200)
+  })
+})
+
+describe('retryAfterMs', () => {
+  const NOW = Date.parse('2026-07-04T10:00:00.000Z')
+
+  it('parses seconds and http-dates and rejects garbage', () => {
+    expect(retryAfterMs({ 'retry-after': '3' }, NOW)).toBe(3000)
+    expect(
+      retryAfterMs({ 'Retry-After': 'Sat, 04 Jul 2026 10:00:05 GMT' }, NOW),
+    ).toBe(5000)
+    expect(retryAfterMs({ 'retry-after': 'soon' }, NOW)).toBeNull()
+    expect(retryAfterMs(undefined, NOW)).toBeNull()
+  })
+})

package/src/net/httpRetry.ts

@@ -0,0 +1,111 @@
+/**
+ * Retry policy for provider API calls (Gmail, Google Calendar):
+ * - 429 and 5xx retry with exponential backoff, honoring `Retry-After`
+ *   (seconds or HTTP-date) when the server sends one.
+ * - 401 retries exactly once — the attempt callback re-requests its access
+ *   token per attempt, and the shell refreshes transparently, so a single
+ *   retry covers a token revoked mid-flight without loops.
+ * - Thrown attempt errors (network failures) retry like 5xx.
+ * The final response (or error) is returned/rethrown untouched so callers
+ * keep their existing error handling.
+ */
+
+export interface RetryableHttpResponse {
+  status: number
+  ok: boolean
+  headers?: Record<string, string>
+}
+
+export interface HttpRetryOptions {
+  /** Total attempts including the first (default 3). */
+  maxAttempts?: number
+  baseDelayMs?: number
+  maxDelayMs?: number
+  sleep?: (ms: number) => Promise<void>
+  /** 0..1 jitter source; injectable for tests. */
+  random?: () => number
+  now?: () => number
+}
+
+const DEFAULT_MAX_ATTEMPTS = 3
+const DEFAULT_BASE_DELAY_MS = 500
+const DEFAULT_MAX_DELAY_MS = 8_000
+
+function defaultSleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+export function retryAfterMs(
+  headers: Record<string, string> | undefined,
+  now: number,
+): number | null {
+  const raw =
+    headers?.['retry-after'] ??
+    headers?.['Retry-After'] ??
+    headers?.['RETRY-AFTER']
+  if (!raw) return null
+  const seconds = Number(raw)
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000
+  const date = Date.parse(raw)
+  if (!Number.isNaN(date)) return Math.max(0, date - now)
+  return null
+}
+
+function isRetryableStatus(status: number): boolean {
+  return status === 429 || (status >= 500 && status <= 599)
+}
+
+export async function withHttpRetry<T extends RetryableHttpResponse>(
+  attempt: (attemptIndex: number) => Promise<T>,
+  options: HttpRetryOptions = {},
+): Promise<T> {
+  const maxAttempts = Math.max(1, options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS)
+  const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS
+  const maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS
+  const sleep = options.sleep ?? defaultSleep
+  const random = options.random ?? Math.random
+  const now = options.now ?? Date.now
+
+  let unauthorizedRetried = false
+  let attemptIndex = 0
+  // Retry budget counts backoff retries; the single 401 retry is separate.
+  let retriesLeft = maxAttempts - 1
+
+  for (;;) {
+    let response: T | null = null
+    let failure: unknown = null
+    try {
+      response = await attempt(attemptIndex)
+    } catch (error) {
+      failure = error
+    }
+    attemptIndex += 1
+
+    if (response) {
+      if (response.ok || !isRetryableStatus(response.status)) {
+        if (response.status === 401 && !unauthorizedRetried) {
+          unauthorizedRetried = true
+          continue
+        }
+        return response
+      }
+    }
+
+    if (retriesLeft <= 0) {
+      if (failure !== null) throw failure
+      return response as T
+    }
+    retriesLeft -= 1
+
+    const serverDelay = response
+      ? retryAfterMs(response.headers, now())
+      : null
+    const backoffStep = Math.min(
+      maxDelayMs,
+      baseDelayMs * 2 ** (maxAttempts - 2 - retriesLeft),
+    )
+    // Half-to-full jitter keeps concurrent clients from thundering.
+    const jittered = backoffStep * (0.5 + random() / 2)
+    await sleep(Math.min(maxDelayMs, serverDelay ?? jittered))
+  }
+}

package/src/theme/appAccents.test.ts

@@ -3,48 +3,49 @@ import { appAccentForSlug, applyAppAccentToTheme } from './appAccents.js'
 import { lightTheme } from './themes/light.js'
 
 describe('appAccents', () => {
-  it('allocates identity hues to all suite apps', () => {
-    expect(appAccentForSlug('teams')?.accent).toBe('oklch(0.58 0.13 8)')
-    expect(appAccentForSlug('vibes')?.accent).toBe('oklch(0.50 0.14 26)')
-    expect(appAccentForSlug('mail')?.accent).toBe('oklch(0.60 0.12 44)')
-    expect(appAccentForSlug('files')?.accent).toBe('oklch(0.50 0.13 64)')
-    expect(appAccentForSlug('slides')?.accent).toBe('oklch(0.61 0.11 84)')
-    expect(appAccentForSlug('writer')?.accent).toBe('oklch(0.50 0.12 102)')
-    expect(appAccentForSlug('manuscript')?.accent).toBe('oklch(0.61 0.12 124)')
-    expect(appAccentForSlug('book')?.accent).toBe('oklch(0.48 0.14 148)')
-    expect(appAccentForSlug('reports')?.accent).toBe('oklch(0.61 0.12 166)')
-    expect(appAccentForSlug('chart')?.accent).toBe('oklch(0.48 0.13 184)')
-    expect(appAccentForSlug('knowledge')?.accent).toBe('oklch(0.46 0.11 198)')
-    expect(appAccentForSlug('research')?.accent).toBe('oklch(0.63 0.12 222)')
-    expect(appAccentForSlug('sheets')?.accent).toBe('oklch(0.50 0.13 244)')
-    expect(appAccentForSlug('calendar')?.accent).toBe('oklch(0.63 0.13 258)')
-    expect(appAccentForSlug('desktop')?.accent).toBe('oklch(0.48 0.13 274)')
-    expect(appAccentForSlug('plan')?.accent).toBe('oklch(0.61 0.14 290)')
-    expect(appAccentForSlug('review')?.accent).toBe('oklch(0.50 0.15 308)')
-    expect(appAccentForSlug('tasks')?.accent).toBe('oklch(0.63 0.15 324)')
-    expect(appAccentForSlug('assistant')?.accent).toBe('oklch(0.50 0.15 340)')
-    expect(appAccentForSlug('people')?.accent).toBe('oklch(0.61 0.14 356)')
+  it('allocates an identity hue to every app on the 20-step ring', () => {
+    expect(appAccentForSlug('mail')?.accent).toBe('oklch(0.55 0.125 48)')
+    expect(appAccentForSlug('knowledge')?.accent).toBe('oklch(0.55 0.125 192)')
+    expect(appAccentForSlug('research')?.accent).toBe('oklch(0.55 0.125 210)')
+    expect(appAccentForSlug('whiteboard')?.accent).toBe('oklch(0.55 0.125 282)')
+    expect(appAccentForSlug('tasks')?.accent).toBe('oklch(0.55 0.125 318)')
+    expect(appAccentForSlug('teams')?.accent).toBe('oklch(0.55 0.125 12)')
+    expect(appAccentForSlug('people')?.accent).toBe('oklch(0.55 0.125 354)')
+    expect(appAccentForSlug('desktop')?.accent).toBe('oklch(0.55 0.125 264)')
   })
 
-  it('exposes the deep block tone for large fills', () => {
-    expect(appAccentForSlug('research')?.accentBlock).toBe(
-      'oklch(0.40 0.06 222)',
-    )
-    expect(appAccentForSlug('tasks')?.accentBlock).toBe('oklch(0.40 0.06 324)')
+  it('warms Mail toward terracotta with a dedicated tinted background', () => {
+    expect(appAccentForSlug('mail')?.accentMuted).toBe('oklch(0.93 0.05 48)')
   })
 
-  it('normalizes pure-prefixed slugs', () => {
-    expect(appAccentForSlug('purefiles')?.accent).toBe(
-      appAccentForSlug('files')?.accent,
-    )
-    expect(appAccentForSlug('pureknowledge')?.accent).toBe(
-      appAccentForSlug('knowledge')?.accent,
-    )
-    expect(appAccentForSlug('pureslides')?.accent).toBe(
-      appAccentForSlug('slides')?.accent,
+  it('gives previously house-ink apps their own hue', () => {
+    expect(appAccentForSlug('writer')?.accent).toBe('oklch(0.55 0.125 102)')
+    expect(appAccentForSlug('book')?.accent).toBe('oklch(0.55 0.125 138)')
+    expect(appAccentForSlug('calendar')?.accent).toBe('oklch(0.55 0.125 246)')
+    expect(appAccentForSlug('reports')?.accent).toBe('oklch(0.55 0.125 156)')
+    expect(appAccentForSlug('slides')?.accent).toBe('oklch(0.55 0.125 84)')
+  })
+
+  it('splits Sheets and Chart into distinct hues', () => {
+    expect(appAccentForSlug('sheets')?.accent).toBe('oklch(0.55 0.125 228)')
+    expect(appAccentForSlug('chart')?.accent).toBe('oklch(0.55 0.125 174)')
+    expect(appAccentForSlug('chart')?.accent).not.toBe(
+      appAccentForSlug('sheets')?.accent,
     )
   })
 
+  it('normalizes the optional pure- prefix', () => {
+    expect(appAccentForSlug('purefiles')?.accent).toBe('oklch(0.55 0.125 66)')
+    expect(appAccentForSlug('files')?.accent).toBe('oklch(0.55 0.125 66)')
+  })
+
+  it('leaves unassigned apps neutral', () => {
+    expect(appAccentForSlug('chat')).toBeNull()
+    expect(appAccentForSlug('pages')).toBeNull()
+    expect(appAccentForSlug(null)).toBeNull()
+    expect(appAccentForSlug(undefined)).toBeNull()
+  })
+
   it('does not mutate the platform theme accent', () => {
     expect(applyAppAccentToTheme(lightTheme, 'tasks')).toBe(lightTheme)
   })