zele 0.2.0 → 0.3.5

package/src/commands/auth-cmd.ts

@@ -4,14 +4,20 @@
 
 import type { Goke } from 'goke'
 import { login, logout, listAccounts, getAuthStatuses } from '../auth.js'
+import { closePrisma } from '../db.js'
 import * as out from '../output.js'
+import { handleCommandError } from '../output.js'
 
 export function registerAuthCommands(cli: Goke) {
   cli
-    .command('login', 'Authenticate with Google (opens browser)')
+    .command('login', 'Authenticate with Google (opens browser). Run in background via tmux for remote/headless environments. The command prints an authorization URL — show it to the user, ask them to complete consent in their browser, then paste back the localhost redirect URL containing the auth code.')
     .action(async () => {
-      const { email } = await login()
+      const result = await login()
+      if (result instanceof Error) handleCommandError(result)
+      const { email } = result
       out.success(`Authenticated as ${email}`)
+      await closePrisma()
+      process.exit(0)
     })
 
   cli
@@ -25,21 +31,23 @@ export function registerAuthCommands(cli: Goke) {
         return
       }
 
+      const emails = [...new Set(accounts.map((a) => a.email))]
+
       // If no email specified and multiple accounts: error with list
-      if (!email && accounts.length > 1) {
+      if (!email && emails.length > 1) {
         out.error('Multiple accounts logged in. Specify which to remove:')
-        for (const a of accounts) {
-          process.stderr.write(`  ${a}\n`)
+        for (const e of emails) {
+          console.error(`  ${e}`)
         }
         process.exit(1)
       }
 
       // If no email and only one account, use that one
-      const targetEmail = email ?? accounts[0]!
+      const targetEmail = email ?? emails[0]!
 
-      if (!accounts.includes(targetEmail)) {
+      if (!emails.includes(targetEmail)) {
         out.error(`Account not found: ${targetEmail}`)
-        out.hint(`Logged in accounts: ${accounts.join(', ')}`)
+        out.hint(`Logged in accounts: ${emails.join(', ')}`)
         process.exit(1)
       }
 
@@ -62,7 +70,8 @@ export function registerAuthCommands(cli: Goke) {
         }
       }
 
-      await logout(targetEmail)
+      const logoutResult = await logout(targetEmail)
+      if (logoutResult instanceof Error) handleCommandError(logoutResult)
       out.success(`Credentials removed for ${targetEmail}`)
     })
 
@@ -79,6 +88,7 @@ export function registerAuthCommands(cli: Goke) {
       out.printList(
         statuses.map((s) => ({
           email: s.email,
+          app_id: s.appId,
           status: 'Authenticated',
           expires: s.expiresAt?.toISOString() ?? 'unknown',
         })),

package/src/commands/calendar.ts

@@ -1,15 +1,16 @@
 // Calendar commands: list, events, get, create, update, delete, respond, freebusy.
-// Manages Google Calendar with YAML output and cache integration.
+// Manages Google Calendar with YAML output.
+// Cache is handled by the client — commands just call methods and use data.
 // Multi-account: list/events fetch all accounts concurrently and merge by start time.
-// Improved UX over gogcli: multi-account by default, +duration syntax, cleaner output.
 
 import type { Goke } from 'goke'
 import { z } from 'zod'
 import readline from 'node:readline'
 import { getCalendarClients, getCalendarClient } from '../auth.js'
 import type { CalendarClient, CalendarEvent, CalendarListItem, EventListResult } from '../calendar-client.js'
-import * as cache from '../gmail-cache.js'
+import { AuthError } from '../api-utils.js'
 import * as out from '../output.js'
+import { handleCommandError } from '../output.js'
 import { resolveTimeRange, parseTimeExpression, parseDuration, isDateOnly } from '../calendar-time.js'
 
 // ---------------------------------------------------------------------------
@@ -23,41 +24,22 @@ export function registerCalendarCommands(cli: Goke) {
 
   cli
     .command('cal list', 'List calendars')
-    .option('--no-cache', 'Skip cache')
     .action(async (options) => {
       const clients = await getCalendarClients(options.account)
 
-      const settled = await Promise.allSettled(
+      const results = await Promise.all(
         clients.map(async ({ email, client }) => {
-          if (!options.noCache) {
-            const cached = await cache.getCachedCalendarList<CalendarListItem[]>(email)
-            if (cached) return { email, calendars: cached }
-          }
-
           const calendars = await client.listCalendars()
-
-          if (!options.noCache) {
-            await cache.cacheCalendarList(email, calendars)
-          }
-
+          if (calendars instanceof Error) return calendars
           return { email, calendars }
         }),
       )
 
-      const allResults = settled
-        .filter((r): r is PromiseFulfilledResult<{ email: string; calendars: CalendarListItem[] }> => {
-          if (r.status === 'rejected') {
-            const msg = String(r.reason)
-            if (msg.includes('401') || msg.includes('403') || msg.includes('Unauthorized')) {
-              out.error('CalDAV authentication failed. Try: zele login')
-            } else {
-              out.error(`Failed to fetch calendars: ${msg}`)
-            }
-            return false
-          }
+      const allResults = results.filter((r): r is Exclude<typeof r, Error> => {
+          if (r instanceof AuthError) { out.error(`${r.message}. Try: zele login`); return false }
+          if (r instanceof Error) { out.error(`Failed to fetch calendars: ${r.message}`); return false }
           return true
         })
-        .map((r) => r.value)
 
       const showAccount = clients.length > 1
       const merged = allResults.flatMap(({ email, calendars }) =>
@@ -98,7 +80,6 @@ export function registerCalendarCommands(cli: Goke) {
     .option('--query <query>', 'Free text search')
     .option('--max [max]', 'Max results (default: 20)')
     .option('--page <page>', 'Pagination token')
-    .option('--no-cache', 'Skip cache')
     .action(async (options) => {
       const max = options.max ? Number(options.max) : 20
       const calendarId = options.calendar ?? 'primary'
@@ -115,9 +96,10 @@ export function registerCalendarCommands(cli: Goke) {
         process.exit(1)
       }
 
-      const settled = await Promise.allSettled(
+      const results = await Promise.all(
         clients.map(async ({ email, client }) => {
           const tz = await client.getTimezone(calendarId)
+          if (tz instanceof Error) return tz
           const { timeMin, timeMax } = resolveTimeRange({
             from: options.from,
             to: options.to,
@@ -127,28 +109,15 @@ export function registerCalendarCommands(cli: Goke) {
             days: options.days,
           }, tz)
 
-          const cacheParams = {
-            calendarId: options.all ? '__all__' : calendarId,
-            timeMin,
-            timeMax,
-            query: options.query,
-            maxResults: max,
-            pageToken: options.page,
-          }
-
-          if (!options.noCache) {
-            const cached = await cache.getCachedCalendarEvents<EventListResult>(email, cacheParams)
-            if (cached) return { email, result: cached, tz }
-          }
-
           let result: EventListResult
 
           if (options.all) {
             // Fetch from all calendars
             const calendars = await client.listCalendars()
+            if (calendars instanceof Error) return calendars
             const allEvents: CalendarEvent[] = []
 
-            const perCalResults = await Promise.allSettled(
+            const perCalResults = await Promise.all(
               calendars.map(async (cal) => {
                 const r = await client.listEvents({
                   calendarId: cal.id,
@@ -157,16 +126,14 @@ export function registerCalendarCommands(cli: Goke) {
                   query: options.query,
                   maxResults: max,
                 })
+                if (r instanceof Error) return r
                 return r.events.map((e) => ({ ...e, calendarId: cal.id }))
               }),
             )
 
             for (const r of perCalResults) {
-              if (r.status === 'fulfilled') {
-                allEvents.push(...r.value)
-              } else {
-                out.error(`Calendar fetch failed: ${r.reason}`)
-              }
+              if (r instanceof Error) { out.error(r instanceof AuthError ? `${r.message}. Try: zele login` : r.message); continue }
+              allEvents.push(...r)
             }
 
             result = {
@@ -175,7 +142,7 @@ export function registerCalendarCommands(cli: Goke) {
               timezone: tz,
             }
           } else {
-            result = await client.listEvents({
+            const r = await client.listEvents({
               calendarId,
               timeMin,
               timeMax,
@@ -183,30 +150,19 @@ export function registerCalendarCommands(cli: Goke) {
               maxResults: max,
               pageToken: options.page,
             })
-          }
-
-          if (!options.noCache) {
-            await cache.cacheCalendarEvents(email, cacheParams, result)
+            if (r instanceof Error) return r
+            result = r
           }
 
           return { email, result, tz }
         }),
       )
 
-      const allResults = settled
-        .filter((r): r is PromiseFulfilledResult<{ email: string; result: EventListResult; tz: string }> => {
-          if (r.status === 'rejected') {
-            const msg = String(r.reason)
-            if (msg.includes('401') || msg.includes('403') || msg.includes('Unauthorized')) {
-              out.error('CalDAV authentication failed. Try: zele login')
-            } else {
-              out.error(`Failed to fetch events: ${msg}`)
-            }
-            return false
-          }
+      const allResults = results.filter((r): r is Exclude<typeof r, Error> => {
+          if (r instanceof AuthError) { out.error(`${r.message}. Try: zele login`); return false }
+          if (r instanceof Error) { out.error(`Failed to fetch events: ${r.message}`); return false }
           return true
         })
-        .map((r) => r.value)
 
       const showAccount = clients.length > 1
 
@@ -254,6 +210,7 @@ export function registerCalendarCommands(cli: Goke) {
       const { client } = await getCalendarClient(options.account)
 
       const event = await client.getEvent({ calendarId, eventId })
+      if (event instanceof Error) handleCommandError(event)
       const time = out.formatEventTime(event.start, event.end, event.allDay)
 
       const doc: Record<string, unknown> = {
@@ -318,8 +275,9 @@ export function registerCalendarCommands(cli: Goke) {
       }
 
       const calendarId = options.calendar ?? 'primary'
-      const { email, client } = await getCalendarClient(options.account)
+      const { client } = await getCalendarClient(options.account)
       const tz = await client.getTimezone(calendarId)
+      if (tz instanceof Error) handleCommandError(tz)
 
       const allDay = options.allDay || (isDateOnly(options.from) && isDateOnly(options.to))
       const start = allDay ? options.from : parseTimeExpression(options.from, tz)
@@ -346,7 +304,7 @@ export function registerCalendarCommands(cli: Goke) {
 
       const reminders = options.reminder ? [parseReminder(options.reminder)] : undefined
 
-      const event = await client.createEvent({
+      const eventResult = await client.createEvent({
         calendarId,
         summary: options.summary,
         start,
@@ -362,9 +320,8 @@ export function registerCalendarCommands(cli: Goke) {
         visibility: options.visibility,
       })
 
-      await cache.invalidateCalendarEvents(email)
-
-      printEventDetail(event)
+      if (eventResult instanceof Error) handleCommandError(eventResult)
+      printEventDetail(eventResult)
       out.success('Event created')
     })
 
@@ -387,7 +344,7 @@ export function registerCalendarCommands(cli: Goke) {
     .option('--visibility <visibility>', 'Event visibility')
     .action(async (eventId, options) => {
       const calendarId = options.calendar ?? 'primary'
-      const { email, client } = await getCalendarClient(options.account)
+      const { client } = await getCalendarClient(options.account)
 
       const addAttendees = options.addAttendees
         ? options.addAttendees.split(',').map((e: string) => e.trim()).filter(Boolean)
@@ -417,6 +374,7 @@ export function registerCalendarCommands(cli: Goke) {
           }
         } else {
           const tz = await client.getTimezone(calendarId)
+          if (tz instanceof Error) handleCommandError(tz)
           if (options.from) start = parseTimeExpression(options.from, tz)
           if (options.to) {
             const durationMs = parseDuration(options.to)
@@ -429,7 +387,7 @@ export function registerCalendarCommands(cli: Goke) {
         }
       }
 
-      const event = await client.updateEvent({
+      const updateResult = await client.updateEvent({
         calendarId,
         eventId,
         summary: options.summary,
@@ -445,9 +403,8 @@ export function registerCalendarCommands(cli: Goke) {
         visibility: options.visibility,
       })
 
-      await cache.invalidateCalendarEvents(email)
-
-      printEventDetail(event)
+      if (updateResult instanceof Error) handleCommandError(updateResult)
+      printEventDetail(updateResult)
       out.success('Event updated')
     })
 
@@ -461,7 +418,7 @@ export function registerCalendarCommands(cli: Goke) {
     .option('--force', 'Skip confirmation')
     .action(async (eventId, options) => {
       const calendarId = options.calendar ?? 'primary'
-      const { email, client } = await getCalendarClient(options.account)
+      const { client } = await getCalendarClient(options.account)
 
       if (!options.force && process.stdin.isTTY) {
         const rl = readline.createInterface({ input: process.stdin, output: process.stderr })
@@ -476,8 +433,8 @@ export function registerCalendarCommands(cli: Goke) {
         }
       }
 
-      await client.deleteEvent({ calendarId, eventId })
-      await cache.invalidateCalendarEvents(email)
+      const deleteResult = await client.deleteEvent({ calendarId, eventId })
+      if (deleteResult instanceof Error) handleCommandError(deleteResult)
 
       out.printYaml({ deleted: true, id: eventId })
       out.success('Event deleted')
@@ -505,20 +462,19 @@ export function registerCalendarCommands(cli: Goke) {
       }
 
       const calendarId = options.calendar ?? 'primary'
-      const { email, client } = await getCalendarClient(options.account)
+      const { client } = await getCalendarClient(options.account)
 
-      const event = await client.respondToEvent({
+      const respondResult = await client.respondToEvent({
         calendarId,
         eventId,
         status: options.status as 'accepted' | 'declined' | 'tentative',
         comment: options.comment,
       })
-
-      await cache.invalidateCalendarEvents(email)
+      if (respondResult instanceof Error) handleCommandError(respondResult)
 
       out.printYaml({
-        id: event.id,
-        summary: event.summary,
+        id: respondResult.id,
+        summary: respondResult.summary,
         status: options.status,
         ...(options.comment ? { comment: options.comment } : {}),
       })
@@ -545,6 +501,7 @@ export function registerCalendarCommands(cli: Goke) {
 
       const { client } = await getCalendarClient(options.account)
       const tz = await client.getTimezone()
+      if (tz instanceof Error) handleCommandError(tz)
 
       const timeMin = parseTimeExpression(options.from, tz)
       const timeMax = parseTimeExpression(options.to, tz)

package/src/commands/draft.ts

@@ -1,14 +1,16 @@
 // Draft commands: list, create, get, send, delete.
 // Manages Gmail drafts with YAML output for list views.
+// Cache invalidation is handled by the client (sendDraft invalidates threadLists).
 // Multi-account: list fetches all accounts concurrently and merges by date.
 
 import type { Goke } from 'goke'
 import { z } from 'zod'
 import fs from 'node:fs'
 import { getClients, getClient } from '../auth.js'
-import { GmailClient } from '../gmail-client.js'
-import * as cache from '../gmail-cache.js'
+import type { GmailClient } from '../gmail-client.js'
+import { AuthError } from '../api-utils.js'
 import * as out from '../output.js'
+import { handleCommandError } from '../output.js'
 import pc from 'picocolors'
 
 export function registerDraftCommands(cli: Goke) {
@@ -29,27 +31,24 @@ export function registerDraftCommands(cli: Goke) {
         process.exit(1)
       }
 
-      // Fetch from all accounts concurrently, tolerating individual failures
-      const settled = await Promise.allSettled(
+      // Fetch from all accounts concurrently
+      const results = await Promise.all(
         clients.map(async ({ email, client }) => {
           const result = await client.listDrafts({
             query: options.query,
             maxResults: options.max,
             pageToken: options.page,
           })
+          if (result instanceof Error) return result
           return { email, result }
         }),
       )
 
-      const allResults = settled
-        .filter((r): r is PromiseFulfilledResult<{ email: string; result: Awaited<ReturnType<GmailClient['listDrafts']>> & { email: string } }> => {
-          if (r.status === 'rejected') {
-            out.error(`Failed to fetch drafts: ${r.reason}`)
-            return false
-          }
+      const allResults = results.filter((r): r is Exclude<typeof r, Error> => {
+          if (r instanceof AuthError) { out.error(`${r.message}. Try: zele login`); return false }
+          if (r instanceof Error) { out.error(`Failed to fetch drafts: ${r.message}`); return false }
           return true
         })
-        .map((r) => r.value)
 
       // Merge drafts from all accounts, sorted by date descending, capped at max
       const merged = allResults
@@ -88,20 +87,21 @@ export function registerDraftCommands(cli: Goke) {
       const { client } = await getClient(options.account)
 
       const draft = await client.getDraft({ draftId })
+      if (draft instanceof Error) handleCommandError(draft)
 
-      process.stdout.write(pc.bold(`Draft: ${draft.message.subject}`) + '\n')
-      process.stdout.write(pc.dim(`Draft ID: ${draft.id}`) + '\n')
-      process.stdout.write(`To: ${draft.to.join(', ') || '(none)'}` + '\n')
+      console.log(pc.bold(`Draft: ${draft.message.subject}`))
+      console.log(pc.dim(`Draft ID: ${draft.id}`))
+      console.log(`To: ${draft.to.join(', ') || '(none)'}`)
       if (draft.cc.length > 0) {
-        process.stdout.write(`Cc: ${draft.cc.join(', ')}` + '\n')
+        console.log(`Cc: ${draft.cc.join(', ')}`)
       }
       if (draft.bcc.length > 0) {
-        process.stdout.write(`Bcc: ${draft.bcc.join(', ')}` + '\n')
+        console.log(`Bcc: ${draft.bcc.join(', ')}`)
       }
-      process.stdout.write('\n')
+      console.log()
 
       const body = out.renderEmailBody(draft.message.body, draft.message.mimeType)
-      process.stdout.write(body + '\n')
+      console.log(body)
     })
 
   // =========================================================================
@@ -167,12 +167,9 @@ export function registerDraftCommands(cli: Goke) {
   cli
     .command('draft send <draftId>', 'Send a draft')
     .action(async (draftId, options) => {
-      const { email, client } = await getClient(options.account)
-
+      const { client } = await getClient(options.account)
       const result = await client.sendDraft({ draftId })
 
-      await cache.invalidateThreadLists(email)
-
       out.printYaml(result)
       out.success('Draft sent')
     })

package/src/commands/label.ts

@@ -1,12 +1,12 @@
 // Label commands: list, get, create, delete, counts.
-// Manages Gmail labels with YAML output and cache integration.
+// Manages Gmail labels with YAML output.
+// Cache is handled by the client — commands just call methods and use data.
 // Multi-account: list and counts fetch all accounts concurrently and merge.
 
 import type { Goke } from 'goke'
 import { z } from 'zod'
 import { getClients, getClient } from '../auth.js'
-import { GmailClient } from '../gmail-client.js'
-import * as cache from '../gmail-cache.js'
+import { AuthError } from '../api-utils.js'
 import * as out from '../output.js'
 
 export function registerLabelCommands(cli: Goke) {
@@ -16,38 +16,23 @@ export function registerLabelCommands(cli: Goke) {
 
   cli
     .command('label list', 'List all labels')
-    .option('--no-cache', 'Skip cache')
     .action(async (options) => {
       const clients = await getClients(options.account)
 
-      type LabelList = Awaited<ReturnType<GmailClient['listLabels']>>
-
-      // Fetch from all accounts concurrently, tolerating individual failures
-      const settled = await Promise.allSettled(
+      // Fetch from all accounts concurrently
+      const results = await Promise.all(
         clients.map(async ({ email, client }) => {
-          if (!options.noCache) {
-            const cached = await cache.getCachedLabels<LabelList>(email)
-            if (cached) return { email, labels: cached }
-          }
-
-          const labels = await client.listLabels()
-          if (!options.noCache) {
-            await cache.cacheLabels(email, labels)
-          }
-
-          return { email, labels }
+          const labelsResult = await client.listLabels()
+          if (labelsResult instanceof Error) return labelsResult
+          return { email, labels: labelsResult.parsed }
         }),
       )
 
-      const allResults = settled
-        .filter((r): r is PromiseFulfilledResult<{ email: string; labels: LabelList }> => {
-          if (r.status === 'rejected') {
-            out.error(`Failed to fetch labels: ${r.reason}`)
-            return false
-          }
+      const allResults = results.filter((r): r is Exclude<typeof r, Error> => {
+          if (r instanceof AuthError) { out.error(`${r.message}. Try: zele login`); return false }
+          if (r instanceof Error) { out.error(`Failed to fetch labels: ${r.message}`); return false }
           return true
         })
-        .map((r) => r.value)
 
       // Merge labels from all accounts
       const merged = allResults.flatMap(({ email, labels }) =>
@@ -109,7 +94,7 @@ export function registerLabelCommands(cli: Goke) {
     .option('--bg-color <bgColor>', z.string().describe('Background color (hex, e.g. #4986e7)'))
     .option('--text-color <textColor>', z.string().describe('Text color (hex, e.g. #ffffff)'))
     .action(async (name, options) => {
-      const { email, client } = await getClient(options.account)
+      const { client } = await getClient(options.account)
 
       const result = await client.createLabel({
         name,
@@ -118,8 +103,6 @@ export function registerLabelCommands(cli: Goke) {
           : undefined,
       })
 
-      await cache.invalidateLabels(email)
-
       out.printYaml(result)
       out.success(`Label created: "${result.name}"`)
     })
@@ -146,13 +129,9 @@ export function registerLabelCommands(cli: Goke) {
         }
       }
 
-      const { email, client } = await getClient(options.account)
-
+      const { client } = await getClient(options.account)
       await client.deleteLabel({ labelId })
 
-      await cache.invalidateLabels(email)
-      await cache.invalidateLabelCounts(email)
-
       out.printYaml({ label_id: labelId, deleted: true })
     })
 
@@ -162,38 +141,23 @@ export function registerLabelCommands(cli: Goke) {
 
   cli
     .command('label counts', 'Show unread counts per label')
-    .option('--no-cache', 'Skip cache')
     .action(async (options) => {
       const clients = await getClients(options.account)
 
-      type CountList = Awaited<ReturnType<GmailClient['getLabelCounts']>>
-
-      // Fetch from all accounts concurrently, tolerating individual failures
-      const settled = await Promise.allSettled(
+      // Fetch from all accounts concurrently
+      const results = await Promise.all(
         clients.map(async ({ email, client }) => {
-          if (!options.noCache) {
-            const cached = await cache.getCachedLabelCounts<CountList>(email)
-            if (cached) return { email, counts: cached }
-          }
-
-          const counts = await client.getLabelCounts()
-          if (!options.noCache) {
-            await cache.cacheLabelCounts(email, counts)
-          }
-
-          return { email, counts }
+          const countsResult = await client.getLabelCounts()
+          if (countsResult instanceof Error) return countsResult
+          return { email, counts: countsResult.parsed }
         }),
       )
 
-      const allResults = settled
-        .filter((r): r is PromiseFulfilledResult<{ email: string; counts: CountList }> => {
-          if (r.status === 'rejected') {
-            out.error(`Failed to fetch counts: ${r.reason}`)
-            return false
-          }
+      const allResults = results.filter((r): r is Exclude<typeof r, Error> => {
+          if (r instanceof AuthError) { out.error(`${r.message}. Try: zele login`); return false }
+          if (r instanceof Error) { out.error(`Failed to fetch counts: ${r.message}`); return false }
           return true
         })
-        .map((r) => r.value)
 
       // Merge counts from all accounts
       const merged = allResults.flatMap(({ email, counts }) =>