zele 0.2.0 → 0.3.5

package/src/calendar-client.ts

@@ -2,6 +2,10 @@
 // Uses tsdav for CalDAV protocol and ts-ics for typed iCalendar parse/generate.
 // Auth: passes a Bearer token via headers (reuses existing google-auth-library OAuth2).
 // Google CalDAV endpoint: https://apidata.googleusercontent.com/caldav/v2/
+// Cache is built into the client for stable metadata lookups (calendar list/timezone).
+// Event listing is always fresh so CLI output reflects newly created/updated events.
+// Raw tsdav responses are stored in the cache so the cache is resilient to changes
+// in our own parsed types. Parsing happens at read time.
 
 import {
   fetchCalendars,
@@ -21,6 +25,21 @@ import {
   type IcsDateObject,
 } from 'ts-ics'
 import crypto from 'node:crypto'
+import * as errore from 'errore'
+import { getPrisma } from './db.js'
+import { AuthError, isAuthLikeError, ApiError, NotFoundError, ParseError, MissingDataError } from './api-utils.js'
+
+/** Boundary helper: wrap a tsdav/CalDAV call, converting auth-like errors to AuthError values.
+ *  Non-auth errors are wrapped in ApiError so they remain error values (no throwing).
+ *  Original error is preserved as `cause` for debugging. */
+function caldavBoundary<T>(email: string, fn: () => Promise<T>) {
+  return errore.tryAsync({
+    try: fn,
+    catch: (err) => isAuthLikeError(err)
+      ? new AuthError({ email, reason: String(err) })
+      : new ApiError({ reason: String(err), cause: err }),
+  })
+}
 
 // ---------------------------------------------------------------------------
 // Types (kept identical to previous API so commands layer is unchanged)
@@ -212,15 +231,13 @@ function icsEventToCalendarEvent(event: IcsEvent, calObj?: DAVCalendarObject): C
   }
 }
 
-/** Parse all events from a raw iCal data string using ts-ics */
-function parseICalData(data: string, calObj?: DAVCalendarObject): CalendarEvent[] {
-  try {
-    const calendar = convertIcsCalendar(undefined, data)
-    return (calendar.events ?? []).map((ev) => icsEventToCalendarEvent(ev, calObj))
-  } catch (err) {
-    console.error('[calendar] failed to parse iCal data:', err instanceof Error ? err.stack ?? err.message : err)
-    return []
-  }
+/** Parse all events from a raw iCal data string using ts-ics.
+ *  Boundary: convertIcsCalendar (ts-ics library) may throw on malformed iCal.
+ *  Returns ParseError on failure so callers can decide how to handle it. */
+function parseICalData(data: string, calObj?: DAVCalendarObject): ParseError | CalendarEvent[] {
+  const calendar = errore.tryFn(() => convertIcsCalendar(undefined, data))
+  if (calendar instanceof Error) return new ParseError({ what: 'iCal data', reason: calendar.message })
+  return (calendar.events ?? []).map((ev) => icsEventToCalendarEvent(ev, calObj))
 }
 
 /** Build an iCal string from event properties using ts-ics */
@@ -307,15 +324,25 @@ function extractTimezone(tz?: string): string {
 
 const GOOGLE_CALDAV_URL = 'https://apidata.googleusercontent.com/caldav/v2/'
 
+const TTL = {
+  CALENDAR_LIST: 30 * 60 * 1000, // 30 minutes
+} as const
+
+function isExpired(createdAt: Date, ttlMs: number): boolean {
+  return createdAt.getTime() + ttlMs < Date.now()
+}
+
 export class CalendarClient {
   private headers: Record<string, string>
   private email: string
+  private appId: string
   private calendarCache: DAVCalendar[] | null = null
   private timezoneCache: Record<string, string> = {}
 
-  constructor({ accessToken, email }: { accessToken: string; email: string }) {
+  constructor({ accessToken, email, appId }: { accessToken: string; email: string; appId: string }) {
     this.headers = { Authorization: `Bearer ${accessToken}` }
     this.email = email
+    this.appId = appId
   }
 
   /** Update the access token (e.g. after refresh) */
@@ -323,30 +350,63 @@ export class CalendarClient {
     this.headers = { Authorization: `Bearer ${token}` }
   }
 
+  // =========================================================================
+  // Cache helpers (private)
+  // =========================================================================
+
+  private get account() {
+    return { email: this.email, appId: this.appId }
+  }
+
+  private async getCachedCalendarList(): Promise<CalendarListItem[] | undefined> {
+    const prisma = await getPrisma()
+    const row = await prisma.calendarList.findUnique({ where: { email_appId: this.account } })
+    if (!row || isExpired(row.createdAt, row.ttlMs)) return undefined
+    return JSON.parse(row.rawData) as CalendarListItem[]
+  }
+
+  private async cacheCalendarListData(data: CalendarListItem[]): Promise<void> {
+    const prisma = await getPrisma()
+    await prisma.calendarList.upsert({
+      where: { email_appId: this.account },
+      create: { ...this.account, rawData: JSON.stringify(data), ttlMs: TTL.CALENDAR_LIST, createdAt: new Date() },
+      update: { rawData: JSON.stringify(data), ttlMs: TTL.CALENDAR_LIST, createdAt: new Date() },
+    })
+  }
+
+  private async invalidateCalendarLists(): Promise<void> {
+    const prisma = await getPrisma()
+    await prisma.calendarList.deleteMany({ where: this.account })
+  }
+
   // =========================================================================
   // Internal: fetch DAVCalendar list (cached per instance)
   // =========================================================================
 
-  private async fetchDAVCalendars(): Promise<DAVCalendar[]> {
+  private async fetchDAVCalendars(): Promise<DAVCalendar[] | AuthError | ApiError> {
     if (this.calendarCache) return this.calendarCache
 
-    const calendars = await fetchCalendars({
-      account: {
-        serverUrl: GOOGLE_CALDAV_URL,
-        rootUrl: GOOGLE_CALDAV_URL,
-        accountType: 'caldav',
-        homeUrl: `${GOOGLE_CALDAV_URL}${this.email}/`,
-      },
-      headers: this.headers,
-    })
+    const calendars = await caldavBoundary(this.email, () =>
+      fetchCalendars({
+        account: {
+          serverUrl: GOOGLE_CALDAV_URL,
+          rootUrl: GOOGLE_CALDAV_URL,
+          accountType: 'caldav',
+          homeUrl: `${GOOGLE_CALDAV_URL}${this.email}/`,
+        },
+        headers: this.headers,
+      }),
+    )
+    if (calendars instanceof Error) return calendars
 
     this.calendarCache = calendars
     return calendars
   }
 
   /** Resolve a calendarId to a DAVCalendar. 'primary' maps to the user's email. */
-  private async resolveCalendar(calendarId: string): Promise<DAVCalendar> {
+  private async resolveCalendar(calendarId: string): Promise<DAVCalendar | AuthError | ApiError | NotFoundError> {
     const calendars = await this.fetchDAVCalendars()
+    if (calendars instanceof Error) return calendars
 
     // 'primary' = the user's own calendar (URL contains their email)
     const targetId = calendarId === 'primary' ? this.email : calendarId
@@ -358,7 +418,7 @@ export class CalendarClient {
     })
 
     if (!match) {
-      throw new Error(`Calendar not found: ${calendarId}. Available: ${calendars.map((c) => c.displayName || c.url).join(', ')}`)
+      return new NotFoundError({ resource: `calendar "${calendarId}". Available: ${calendars.map((c) => c.displayName || c.url).join(', ')}` })
     }
 
     return match
@@ -368,10 +428,15 @@ export class CalendarClient {
   // Calendar list
   // =========================================================================
 
-  async listCalendars(): Promise<CalendarListItem[]> {
+  async listCalendars(): Promise<CalendarListItem[] | AuthError | ApiError> {
+    // Check cache
+    const cached = await this.getCachedCalendarList()
+    if (cached) return cached
+
     const calendars = await this.fetchDAVCalendars()
+    if (calendars instanceof Error) return calendars
 
-    return calendars.map((cal) => {
+    const result = calendars.map((cal) => {
       // Extract calendar ID from URL
       // URL looks like: https://apidata.googleusercontent.com/caldav/v2/user%40gmail.com/events/
       const urlParts = cal.url.replace(/\/$/, '').split('/')
@@ -392,29 +457,36 @@ export class CalendarClient {
         backgroundColor: cal.calendarColor ?? '',
       }
     })
+
+    // Write cache
+    await this.cacheCalendarListData(result)
+
+    return result
   }
 
   // =========================================================================
   // Timezone
   // =========================================================================
 
-  async getTimezone(calendarId = 'primary'): Promise<string> {
+  async getTimezone(calendarId = 'primary'): Promise<string | AuthError | ApiError | NotFoundError> {
     if (this.timezoneCache[calendarId]) return this.timezoneCache[calendarId]!
 
-    try {
-      const cal = await this.resolveCalendar(calendarId)
-      const tz = extractTimezone(cal.timezone)
-      this.timezoneCache[calendarId] = tz
-      return tz
-    } catch (err) {
-      console.error('[calendar] failed to resolve timezone for', calendarId, '-', err instanceof Error ? err.stack ?? err.message : err)
+    const cal = await this.resolveCalendar(calendarId)
+    if (cal instanceof Error) return cal
+
+    // extractTimezone is a pure function (regex on string) — no try/catch needed.
+    // Fallback to calendar list metadata if the DAVCalendar has no timezone data.
+    let tz = extractTimezone(cal.timezone)
+    if (tz === 'UTC' && cal.timezone) {
+      // extractTimezone returned UTC as default — check calendar list for a better match
       const calendars = await this.listCalendars()
+      if (calendars instanceof Error) return calendars
       const target = calendarId === 'primary' ? this.email : calendarId
       const match = calendars.find((c) => c.id.toLowerCase() === target.toLowerCase())
-      const tz = match?.timezone || 'UTC'
-      this.timezoneCache[calendarId] = tz
-      return tz
+      if (match?.timezone && match.timezone !== 'UTC') tz = match.timezone
     }
+    this.timezoneCache[calendarId] = tz
+    return tz
   }
 
   // =========================================================================
@@ -435,9 +507,13 @@ export class CalendarClient {
     query?: string
     maxResults?: number
     pageToken?: string
-  } = {}): Promise<EventListResult> {
+  } = {}): Promise<EventListResult | AuthError | ApiError | NotFoundError> {
+    // Always fresh: event lists are user-facing live data.
+
     const cal = await this.resolveCalendar(calendarId)
+    if (cal instanceof Error) return cal
     const tz = await this.getTimezone(calendarId)
+    if (tz instanceof Error) return tz
 
     const fetchOpts: Parameters<typeof fetchCalendarObjects>[0] = {
       calendar: cal,
@@ -449,12 +525,15 @@ export class CalendarClient {
       fetchOpts.timeRange = { start: timeMin, end: timeMax }
     }
 
-    const calObjects = await fetchCalendarObjects(fetchOpts)
+    const calObjects = await caldavBoundary(this.email, () => fetchCalendarObjects(fetchOpts))
+    if (calObjects instanceof Error) return calObjects
 
     let events: CalendarEvent[] = []
     for (const obj of calObjects) {
       if (!obj.data) continue
-      events.push(...parseICalData(obj.data, obj))
+      const parsed = parseICalData(obj.data, obj)
+      if (parsed instanceof ParseError) continue // skip unparseable calendar objects
+      events.push(...parsed)
     }
 
     if (query) {
@@ -468,11 +547,13 @@ export class CalendarClient {
 
     events.sort((a, b) => new Date(a.start).getTime() - new Date(b.start).getTime())
 
-    return {
+    const result: EventListResult = {
       events: events.slice(0, maxResults),
       nextPageToken: null,
       timezone: tz,
     }
+
+    return result
   }
 
   async getEvent({
@@ -481,23 +562,28 @@ export class CalendarClient {
   }: {
     calendarId?: string
     eventId: string
-  }): Promise<CalendarEvent> {
+  }): Promise<CalendarEvent | AuthError | ApiError | NotFoundError> {
     const cal = await this.resolveCalendar(calendarId)
+    if (cal instanceof Error) return cal
 
-    const calObjects = await fetchCalendarObjects({
-      calendar: cal,
-      headers: this.headers,
-      urlFilter: () => true,
-    })
+    const calObjects = await caldavBoundary(this.email, () =>
+      fetchCalendarObjects({
+        calendar: cal,
+        headers: this.headers,
+        urlFilter: () => true,
+      }),
+    )
+    if (calObjects instanceof Error) return calObjects
 
     for (const obj of calObjects) {
       if (!obj.data) continue
       const events = parseICalData(obj.data, obj)
+      if (events instanceof ParseError) continue // skip unparseable calendar objects
       const match = events.find((e) => e.id === eventId || e.uid === eventId)
       if (match) return match
     }
 
-    throw new Error(`Event not found: ${eventId}`)
+    return new NotFoundError({ resource: `event "${eventId}"` })
   }
 
   async createEvent({
@@ -530,8 +616,9 @@ export class CalendarClient {
     colorId?: string
     visibility?: string
     transparency?: string
-  }): Promise<CalendarEvent> {
+  }): Promise<CalendarEvent | AuthError | ApiError | NotFoundError | ParseError> {
     const cal = await this.resolveCalendar(calendarId)
+    if (cal instanceof Error) return cal
     const uid = generateUID()
 
     const iCalString = buildICalString({
@@ -550,16 +637,20 @@ export class CalendarClient {
 
     const filename = `${uid.split('@')[0]}.ics`
 
-    await createCalendarObject({
-      calendar: cal,
-      filename,
-      iCalString,
-      headers: this.headers,
-    })
+    const createResult = await caldavBoundary(this.email, () =>
+      createCalendarObject({
+        calendar: cal,
+        filename,
+        iCalString,
+        headers: this.headers,
+      }),
+    )
+    if (createResult instanceof Error) return createResult
 
     const events = parseICalData(iCalString)
+    if (events instanceof ParseError) return events
     const event = events[0]
-    if (!event) throw new Error('Failed to parse created event')
+    if (!event) return new ParseError({ what: 'created event', reason: 'iCal round-trip produced no events' })
     event.url = `${cal.url}${filename}`
 
     return event
@@ -595,10 +686,11 @@ export class CalendarClient {
     colorId?: string
     visibility?: string
     transparency?: string
-  }): Promise<CalendarEvent> {
+  }): Promise<CalendarEvent | AuthError | ApiError | NotFoundError | MissingDataError | ParseError> {
     const existing = await this.getEvent({ calendarId, eventId })
+    if (existing instanceof Error) return existing
     if (!existing.url || !existing.etag) {
-      throw new Error(`Cannot update event: missing CalDAV URL or etag for event ${eventId}`)
+      return new MissingDataError({ what: 'CalDAV URL or etag', resource: `event ${eventId}` })
     }
 
     // Handle attendee add/remove
@@ -635,14 +727,18 @@ export class CalendarClient {
       organizer: { email: this.email },
     })
 
-    await updateCalendarObject({
-      calendarObject: { url: existing.url, data: iCalString, etag: existing.etag },
-      headers: this.headers,
-    })
+    const updateResult = await caldavBoundary(this.email, () =>
+      updateCalendarObject({
+        calendarObject: { url: existing.url!, data: iCalString, etag: existing.etag },
+        headers: this.headers,
+      }),
+    )
+    if (updateResult instanceof Error) return updateResult
 
     const events = parseICalData(iCalString)
+    if (events instanceof ParseError) return events
     const event = events[0]
-    if (!event) throw new Error('Failed to parse updated event')
+    if (!event) return new ParseError({ what: 'updated event', reason: 'iCal round-trip produced no events' })
     event.url = existing.url
     event.etag = existing.etag
 
@@ -655,16 +751,21 @@ export class CalendarClient {
   }: {
     calendarId?: string
     eventId: string
-  }): Promise<void> {
+  }): Promise<void | AuthError | ApiError | NotFoundError | MissingDataError> {
     const existing = await this.getEvent({ calendarId, eventId })
+    if (existing instanceof Error) return existing
     if (!existing.url) {
-      throw new Error(`Cannot delete event: missing CalDAV URL for event ${eventId}`)
+      return new MissingDataError({ what: 'CalDAV URL', resource: `event ${eventId}` })
     }
 
-    await deleteCalendarObject({
-      calendarObject: { url: existing.url, etag: existing.etag },
-      headers: this.headers,
-    })
+    const deleteResult = await caldavBoundary(this.email, () =>
+      deleteCalendarObject({
+        calendarObject: { url: existing.url!, etag: existing.etag },
+        headers: this.headers,
+      }),
+    )
+    if (deleteResult instanceof Error) return deleteResult
+
   }
 
   async respondToEvent({
@@ -677,10 +778,11 @@ export class CalendarClient {
     eventId: string
     status: 'accepted' | 'declined' | 'tentative'
     comment?: string
-  }): Promise<CalendarEvent> {
+  }): Promise<CalendarEvent | AuthError | ApiError | NotFoundError | MissingDataError | ParseError> {
     const existing = await this.getEvent({ calendarId, eventId })
+    if (existing instanceof Error) return existing
     if (!existing.url || !existing.etag) {
-      throw new Error(`Cannot respond to event: missing CalDAV URL or etag for event ${eventId}`)
+      return new MissingDataError({ what: 'CalDAV URL or etag', resource: `event ${eventId}` })
     }
 
     // Update our PARTSTAT in attendees
@@ -708,14 +810,18 @@ export class CalendarClient {
         : { email: this.email },
     })
 
-    await updateCalendarObject({
-      calendarObject: { url: existing.url, data: iCalString, etag: existing.etag },
-      headers: this.headers,
-    })
+    const respondResult = await caldavBoundary(this.email, () =>
+      updateCalendarObject({
+        calendarObject: { url: existing.url!, data: iCalString, etag: existing.etag },
+        headers: this.headers,
+      }),
+    )
+    if (respondResult instanceof Error) return respondResult
 
     const events = parseICalData(iCalString)
+    if (events instanceof ParseError) return events
     const event = events[0]
-    if (!event) throw new Error('Failed to parse response event')
+    if (!event) return new ParseError({ what: 'response event', reason: 'iCal round-trip produced no events' })
     event.url = existing.url
 
     return event
@@ -733,23 +839,24 @@ export class CalendarClient {
     const results: FreeBusyResult[] = []
 
     for (const calId of calendarIds) {
-      try {
-        const { events } = await this.listEvents({
-          calendarId: calId,
-          timeMin,
-          timeMax,
-          maxResults: 200,
-        })
-
-        const busy: FreeBusyBlock[] = events
-          .filter((e) => e.transparency !== 'transparent' && !e.allDay)
-          .map((e) => ({ start: e.start, end: e.end }))
-
-        results.push({ calendar: calId, busy })
-      } catch (err) {
-        console.error('[calendar] freebusy failed for', calId, '-', err instanceof Error ? err.stack ?? err.message : err)
+      // listEvents returns errors as values — no try/catch needed.
+      // Errors (auth, not found) yield an empty busy list for that calendar.
+      const eventsResult = await this.listEvents({
+        calendarId: calId,
+        timeMin,
+        timeMax,
+        maxResults: 200,
+      })
+      if (eventsResult instanceof Error) {
         results.push({ calendar: calId, busy: [] })
+        continue
       }
+
+      const busy: FreeBusyBlock[] = eventsResult.events
+        .filter((e: CalendarEvent) => e.transparency !== 'transparent' && !e.allDay)
+        .map((e: CalendarEvent) => ({ start: e.start, end: e.end }))
+
+      results.push({ calendar: calId, busy })
     }
 
     return results

package/src/cli.ts

@@ -6,6 +6,7 @@
 
 import { goke } from 'goke'
 import { z } from 'zod'
+import React from 'react'
 import { registerAuthCommands } from './commands/auth-cmd.js'
 import { registerMailCommands } from './commands/mail.js'
 import { registerMailActionCommands } from './commands/mail-actions.js'
@@ -14,6 +15,7 @@ import { registerLabelCommands } from './commands/label.js'
 import { registerAttachmentCommands } from './commands/attachment.js'
 import { registerProfileCommands } from './commands/profile.js'
 import { registerCalendarCommands } from './commands/calendar.js'
+import { registerWatchCommands } from './commands/watch.js'
 
 const cli = goke('zele')
 
@@ -26,6 +28,34 @@ cli.option(
   z.array(z.string()).describe('Filter by email account (repeatable)'),
 )
 
+// ---------------------------------------------------------------------------
+// Default command (TUI)
+// ---------------------------------------------------------------------------
+
+cli
+  .command('', 'Browse emails in TUI')
+  .action(async () => {
+    if (typeof (globalThis as { Bun?: unknown }).Bun === 'undefined') {
+      const pc = await import('picocolors')
+      const isWindows = process.platform === 'win32'
+      const installCmd = isWindows
+        ? 'powershell -c "irm bun.sh/install.ps1 | iex"'
+        : 'curl -fsSL https://bun.sh/install | bash'
+      console.error(
+        pc.default.red('Error: ') +
+          'The TUI requires Bun to run.\n\n' +
+          'Install Bun:\n' +
+          `  ${pc.default.cyan(installCmd)}\n\n` +
+          'Then run:\n' +
+          `  ${pc.default.cyan('zele')}`,
+      )
+      process.exit(1)
+    }
+    const { renderWithProviders } = await import('termcast')
+    const { default: Command } = await import('./mail-tui.js')
+    await renderWithProviders(React.createElement(Command))
+  })
+
 // ---------------------------------------------------------------------------
 // Register all command modules (auth first so login/logout/whoami appear at top of --help)
 // ---------------------------------------------------------------------------
@@ -38,13 +68,14 @@ registerDraftCommands(cli)
 registerLabelCommands(cli)
 registerAttachmentCommands(cli)
 registerCalendarCommands(cli)
+registerWatchCommands(cli)
 
 // ---------------------------------------------------------------------------
 // Help & version
 // ---------------------------------------------------------------------------
 
 cli.help()
-cli.version('0.2.0')
+cli.version('0.3.5')
 
 // ---------------------------------------------------------------------------
 // Parse & run

package/src/commands/attachment.ts

@@ -1,5 +1,5 @@
 // Attachment commands: list, get (download).
-// Lists attachments for a message and downloads them to disk.
+// Lists attachments for a thread and downloads them to disk.
 // Skips re-download if file already exists with same size (like gogcli).
 
 import type { Goke } from 'goke'
@@ -7,8 +7,8 @@ import { z } from 'zod'
 import fs from 'node:fs'
 import path from 'node:path'
 import { getClient } from '../auth.js'
-import { GmailClient } from '../gmail-client.js'
 import * as out from '../output.js'
+import { handleCommandError } from '../output.js'
 
 export function registerAttachmentCommands(cli: Goke) {
   // =========================================================================
@@ -16,33 +16,31 @@ export function registerAttachmentCommands(cli: Goke) {
   // =========================================================================
 
   cli
-    .command('attachment list <messageId>', 'List attachments for a message')
-    .action(async (messageId, options) => {
+    .command('attachment list <threadId>', 'List attachments for all messages in a thread')
+    .action(async (threadId, options) => {
       const { client } = await getClient(options.account)
 
-      const msg = await client.getMessage({ messageId })
-      if ('raw' in msg) {
-        out.error('Cannot list attachments for raw messages')
-        process.exit(1)
-      }
-
-      const attachments = msg.attachments
+      const { parsed: thread } = await client.getThread({ threadId })
+      const attachments = thread.messages.flatMap((msg) =>
+        msg.attachments.map((attachment) => ({
+          thread_id: thread.id,
+          message_id: msg.id,
+          attachment_id: attachment.attachmentId,
+          filename: attachment.filename,
+          type: attachment.mimeType,
+          size: formatSize(attachment.size),
+        })),
+      )
 
       if (attachments.length === 0) {
         out.hint('No attachments')
         return
       }
 
-      out.printList(
-        attachments.map((a) => ({
-          attachment_id: a.attachmentId,
-          filename: a.filename,
-          type: a.mimeType,
-          size: formatSize(a.size),
-        })),
-      )
+      out.printList(attachments)
 
       out.hint(`${attachments.length} attachment(s)`)
+      out.hint('Use: zele attachment get <messageId> <attachmentId>')
     })
 
   // =========================================================================
@@ -58,6 +56,7 @@ export function registerAttachmentCommands(cli: Goke) {
 
       // Get attachment metadata first
       const msg = await client.getMessage({ messageId })
+      if (msg instanceof Error) return handleCommandError(msg)
       if ('raw' in msg) {
         out.error('Cannot get attachments for raw messages')
         process.exit(1)