zele 0.3.0 → 0.3.5

package/src/commands/watch.ts

@@ -1,30 +1,14 @@
 // Mail watch command: poll for new emails using Gmail History API.
-// Uses incremental historyId-based sync — each tick fetches only changes
-// since the last known historyId, not the full inbox. On a quiet inbox
-// this is a single API call returning nothing.
+// Thin CLI wrapper around GmailClient.watchInbox() async generator.
 // Multi-account: watches all accounts concurrently and merges output.
 
 import type { Goke } from 'goke'
 import { z } from 'zod'
 import { getClients } from '../auth.js'
-import type { GmailClient } from '../gmail-client.js'
-import { mapConcurrent } from '../api-utils.js'
-import * as cache from '../gmail-cache.js'
+import type { WatchEvent } from '../gmail-client.js'
+import { AuthError } from '../api-utils.js'
 import * as out from '../output.js'
 
-// ---------------------------------------------------------------------------
-// Folder label mapping (reuses mail list conventions)
-// ---------------------------------------------------------------------------
-
-const FOLDER_LABELS: Record<string, string> = {
-  inbox: 'INBOX',
-  sent: 'SENT',
-  trash: 'TRASH',
-  spam: 'SPAM',
-  starred: 'STARRED',
-  drafts: 'DRAFT',
-}
-
 // ---------------------------------------------------------------------------
 // Register commands
 // ---------------------------------------------------------------------------
@@ -44,312 +28,61 @@ export function registerWatchCommands(cli: Goke) {
       }
 
       const folder = options.folder ?? 'inbox'
-      const filterLabelId = FOLDER_LABELS[folder]
-
-      if (!filterLabelId) {
-        out.error(`Unsupported folder for watch: "${folder}". Supported: ${Object.keys(FOLDER_LABELS).join(', ')}`)
-        process.exit(1)
-      }
-
       const clients = await getClients(options.account)
 
-      // Seed historyId for each account
-      const states = await Promise.all(
-        clients.map(async ({ email, client }) => {
-          let historyId = await cache.getLastHistoryId(email)
-
-          if (!historyId) {
-            const profile = await client.getProfile()
-            historyId = profile.historyId
-            await cache.setLastHistoryId(email, historyId)
-            out.hint(`${email}: watching from now (historyId ${historyId})`)
-          } else {
-            out.hint(`${email}: resuming from historyId ${historyId}`)
-          }
-
-          return { email, client, historyId }
-        }),
-      )
-
       // Clean exit on SIGINT
-      let running = true
       process.on('SIGINT', () => {
-        running = false
         out.hint('Stopped watching')
         process.exit(0)
       })
 
       out.hint(`Polling every ${interval}s for ${folder} changes (Ctrl+C to stop)`)
 
-      // Poll loop
-      while (running) {
-        const settled = await Promise.allSettled(
-          states.map(async (state) => {
-            try {
-              return await pollAccount(state, filterLabelId, options.query)
-            } catch (err: any) {
-              // historyId expired — Google only keeps ~7 days
-              if (isHistoryExpired(err)) {
-                out.hint(`${state.email}: history expired, re-seeding...`)
-                const profile = await state.client.getProfile()
-                state.historyId = profile.historyId
-                await cache.setLastHistoryId(state.email, state.historyId)
-                // Retry once after reseed (important for --once mode)
-                return await pollAccount(state, filterLabelId, options.query)
-              }
-              throw err
-            }
-          }),
-        )
+      // Watch all accounts concurrently, print events as they arrive
+      const generators = clients.map(({ client }) =>
+        client.watchInbox({
+          folder,
+          intervalMs: interval * 1000,
+          query: options.query,
+          once: options.once,
+        }),
+      )
 
-        const allItems: Array<Record<string, unknown>> = []
-        for (const result of settled) {
-          if (result.status === 'fulfilled' && result.value) {
-            allItems.push(...result.value)
-          } else if (result.status === 'rejected') {
-            out.error(`${result.reason?.message ?? result.reason}`)
+      // Consume all generators concurrently, surface errors to the user
+      const settled = await Promise.allSettled(
+        generators.map(async (gen) => {
+          for await (const event of gen) {
+            out.printList([formatWatchEvent(event)])
           }
-        }
+        }),
+      )
 
-        if (allItems.length > 0) {
-          out.printList(allItems)
+      for (const result of settled) {
+        if (result.status === 'rejected') {
+          const err = result.reason
+          if (err instanceof AuthError) {
+            out.error(`${err.message}. Try: zele login`)
+          } else {
+            out.error(`Watch failed: ${err instanceof Error ? err.message : String(err)}`)
+          }
         }
-
-        if (options.once) break
-
-        await sleep(interval * 1000)
       }
     })
 }
 
-// ---------------------------------------------------------------------------
-// Poll a single account for changes
-// ---------------------------------------------------------------------------
-
-async function pollAccount(
-  state: { email: string; client: GmailClient; historyId: string },
-  filterLabelId: string,
-  query: string | undefined,
-): Promise<Array<Record<string, unknown>>> {
-  const { history, historyId: newHistoryId } = await state.client.listHistory({
-    startHistoryId: state.historyId,
-    labelId: filterLabelId,
-    historyTypes: ['messageAdded'],
-  })
-
-  // Update stored historyId even if no changes
-  if (newHistoryId !== state.historyId) {
-    state.historyId = newHistoryId
-    await cache.setLastHistoryId(state.email, newHistoryId)
-  }
-
-  if (history.length === 0) return []
-
-  // Collect unique message IDs from messageAdded events.
-  // No client-side label filtering here — listHistory already filters by
-  // labelId server-side, and the partial message objects in history responses
-  // often have incomplete/missing labelIds.
-  const seenIds = new Set<string>()
-  const messageIds: string[] = []
-
-  for (const entry of history) {
-    for (const added of entry.messagesAdded ?? []) {
-      const id = added.message?.id
-      if (id && !seenIds.has(id)) {
-        seenIds.add(id)
-        messageIds.push(id)
-      }
-    }
-  }
-
-  if (messageIds.length === 0) return []
-
-  // Hydrate messages with metadata (bounded concurrency)
-  const hydrated = await mapConcurrent(messageIds, async (msgId) => {
-    try {
-      const msg = await state.client.getMessage({ messageId: msgId, format: 'metadata' })
-      if ('raw' in msg) return null
-
-      // If user specified a query, do a client-side check on subject/from
-      // (the history API doesn't support query filtering natively)
-      if (query && !matchesQuery(msg, query)) return null
-
-      return {
-        account: state.email,
-        type: 'new_message',
-        from: out.formatSender(msg.from),
-        subject: msg.subject,
-        date: out.formatDate(msg.date),
-        thread_id: msg.threadId,
-        message_id: msg.id,
-        flags: out.formatFlags(msg),
-      }
-    } catch (err: any) {
-      const status = err?.code ?? err?.status ?? err?.response?.status
-      if (status === 404) return null // message deleted between history fetch and hydration
-      out.hint(`Failed to fetch message ${msgId}: ${err.message ?? err}`)
-      return null
-    }
-  })
-
-  return hydrated.filter((item) => item !== null)
-}
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function isHistoryExpired(err: any): boolean {
-  const status = err?.code ?? err?.status ?? err?.response?.status
-  if (status === 404) return true
-  // Google sometimes returns 400 with "Invalid historyId"
-  if (status === 400) {
-    const message = err?.message ?? err?.response?.data?.error?.message ?? ''
-    if (message.includes('historyId')) return true
-  }
-  return false
-}
-
-// ---------------------------------------------------------------------------
-// Client-side Gmail query matching
-// ---------------------------------------------------------------------------
-// The History API doesn't support server-side query filtering, so we parse
-// common Gmail search operators and match against message metadata.
-//
-// Supported operators: from:, to:, cc:, subject:, is:unread/read/starred,
-// has:attachment, and plain text (matches subject + from).
-// Multiple terms are AND-ed together. Quoted phrases and negation supported.
-//
-// Limitations vs full Gmail search:
-// - label: not supported (labelIds are API IDs like Label_123, not names)
-// - has:attachment uses Content-Type heuristic (metadata format lacks parts)
-// - OR, {}, newer_than:, older_than:, etc. are server-only — warned & skipped
-//
-// See https://support.google.com/mail/answer/7190 for the full Gmail spec.
-// ---------------------------------------------------------------------------
-
-// Operators that only work server-side in Gmail search — we skip these
-// with a warning rather than silently treating them as plain text.
-const SERVER_ONLY_OPERATORS = new Set([
-  'in', 'label', 'after', 'before', 'newer_than', 'older_than',
-  'filename', 'size', 'larger', 'smaller', 'deliveredto', 'rfc822msgid',
-  'list', 'category',
-])
-
-// Set of operators we support client-side
-const SUPPORTED_OPERATORS = new Set([
-  'from', 'to', 'cc', 'subject', 'is', 'has',
-])
-
-interface MatchableMessage {
-  subject: string
-  from: { name?: string; email: string }
-  to: Array<{ name?: string; email: string }>
-  cc: Array<{ name?: string; email: string }> | null
-  labelIds: string[]
-  unread: boolean
-  starred: boolean
-  mimeType: string // Content-Type of the message — used for attachment heuristic
-}
-
-let warnedOperators = new Set<string>()
-
-function matchesQuery(msg: MatchableMessage, query: string): boolean {
-  const terms = parseQueryTerms(query)
-  return terms.every((term) => matchesTerm(msg, term))
-}
-
-interface QueryTerm {
-  operator: string | null // null = plain text, otherwise from/to/cc/subject/is/has
-  value: string
-  negated: boolean
-}
-
-function parseQueryTerms(query: string): QueryTerm[] {
-  const terms: QueryTerm[] = []
-  // Match: optional -, optional operator:, then either "quoted phrase" or non-space word
-  const regex = /(-?)(?:(\w+):)?(?:"([^"]*)"|([\S]+))/gi
-  let match: RegExpExecArray | null
-
-  while ((match = regex.exec(query)) !== null) {
-    const negated = match[1] === '-'
-    const rawOperator = match[2]?.toLowerCase() ?? null
-    const value = (match[3] ?? match[4] ?? '').toLowerCase()
-    if (!value) continue
-
-    // Skip OR keyword — it's a Gmail boolean operator, not a search term
-    if (!rawOperator && value === 'or') continue
-
-    // Warn once and skip server-only operators
-    if (rawOperator && SERVER_ONLY_OPERATORS.has(rawOperator)) {
-      if (!warnedOperators.has(rawOperator)) {
-        warnedOperators.add(rawOperator)
-        out.hint(`--query: "${rawOperator}:" is a server-only operator (use "mail search" instead), skipping`)
-      }
-      continue
-    }
-
-    // Warn once and skip completely unknown operators
-    if (rawOperator && !SUPPORTED_OPERATORS.has(rawOperator)) {
-      if (!warnedOperators.has(rawOperator)) {
-        warnedOperators.add(rawOperator)
-        out.hint(`--query: unknown operator "${rawOperator}:", skipping`)
-      }
-      continue
-    }
-
-    terms.push({ operator: rawOperator, value, negated })
+function formatWatchEvent(event: WatchEvent): Record<string, unknown> {
+  return {
+    account: event.account.email,
+    type: event.type,
+    from: out.formatSender(event.message.from),
+    subject: event.message.subject,
+    date: out.formatDate(event.message.date),
+    thread_id: event.threadId,
+    message_id: event.message.id,
+    flags: out.formatFlags(event.message),
   }
-
-  return terms
-}
-
-function senderMatches(sender: { name?: string; email: string }, value: string): boolean {
-  const full = `${sender.name ?? ''} ${sender.email}`.toLowerCase()
-  return full.includes(value)
-}
-
-function matchesTerm(msg: MatchableMessage, term: QueryTerm): boolean {
-  let result: boolean
-
-  switch (term.operator) {
-    case 'from':
-      result = senderMatches(msg.from, term.value)
-      break
-    case 'to':
-      result = msg.to.some((r) => senderMatches(r, term.value))
-      break
-    case 'cc':
-      result = (msg.cc ?? []).some((r) => senderMatches(r, term.value))
-      break
-    case 'subject':
-      result = msg.subject.toLowerCase().includes(term.value)
-      break
-    case 'is':
-      if (term.value === 'unread') result = msg.unread
-      else if (term.value === 'read') result = !msg.unread
-      else if (term.value === 'starred') result = msg.starred
-      else result = false
-      break
-    case 'has':
-      // In metadata format, payload.parts is absent so we can't inspect
-      // attachments directly. Use Content-Type heuristic: multipart/mixed
-      // almost always indicates attachments.
-      if (term.value === 'attachment') result = msg.mimeType.includes('multipart/mixed')
-      else result = false
-      break
-    default: {
-      // Plain text: match against subject + from
-      const subject = msg.subject.toLowerCase()
-      const from = `${msg.from.name ?? ''} ${msg.from.email}`.toLowerCase()
-      result = subject.includes(term.value) || from.includes(term.value)
-      break
-    }
-  }
-
-  return term.negated ? !result : result
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
 }

package/src/db.ts

@@ -1,7 +1,7 @@
 // Prisma singleton for zele.
-// Manages a single SQLite database at ~/.zele/zele.db for all state:
+// Manages a single SQLite database at ~/.zele/sqlite.db for all state:
 // accounts (OAuth tokens), cache (threads, labels, profiles), and sync state.
-// Runs idempotent schema migration on every startup using src/schema.sql.
+// Runs idempotent schema setup on every startup using src/schema.sql.
 
 import fs from 'node:fs'
 import path from 'node:path'
@@ -16,7 +16,7 @@ const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
 const ZELE_DIR = path.join(os.homedir(), '.zele')
-const DB_PATH = path.join(ZELE_DIR, 'zele.db')
+const DB_PATH = path.join(ZELE_DIR, 'sqlite.db')
 
 let prismaInstance: PrismaClient | null = null
 let initPromise: Promise<PrismaClient> | null = null
@@ -44,14 +44,21 @@ async function initializePrisma(): Promise<PrismaClient> {
   const adapter = new PrismaLibSql({ url: `file:${DB_PATH}` })
   const prisma = new PrismaClient({ adapter })
 
-  // Always run migrations — schema.sql uses IF NOT EXISTS so it's idempotent
-  await migrateSchema(prisma)
+  // WAL mode: allows concurrent readers + single writer, persists on the DB file.
+  // busy_timeout: wait up to 5s for locks to clear instead of failing instantly.
+  // Prevents "database is locked" errors when multiple processes (TUI, watch, CLI)
+  // access the DB, or after macOS sleep/wake leaves stale locks.
+  await prisma.$executeRawUnsafe('PRAGMA journal_mode = WAL')
+  await prisma.$executeRawUnsafe('PRAGMA busy_timeout = 5000')
+
+  // Run schema.sql — uses CREATE TABLE IF NOT EXISTS so it's idempotent
+  await applySchema(prisma)
 
   prismaInstance = prisma
   return prisma
 }
 
-async function migrateSchema(prisma: PrismaClient): Promise<void> {
+async function applySchema(prisma: PrismaClient): Promise<void> {
   // When running from source (tsx), __dirname is src/
   // When running from dist, __dirname is dist/ and schema.sql is at ../src/schema.sql
   let schemaPath = path.join(__dirname, 'schema.sql')
@@ -74,16 +81,6 @@ async function migrateSchema(prisma: PrismaClient): Promise<void> {
     .map((s) => s.replace(/^CREATE\s+UNIQUE\s+INDEX\b(?!\s+IF)/i, 'CREATE UNIQUE INDEX IF NOT EXISTS')
                  .replace(/^CREATE\s+INDEX\b(?!\s+IF)/i, 'CREATE INDEX IF NOT EXISTS'))
 
-  // Compatibility migration: older DBs may not have account_status yet.
-  try {
-    await prisma.$executeRawUnsafe(
-      "ALTER TABLE \"accounts\" ADD COLUMN \"account_status\" TEXT NOT NULL DEFAULT 'active'",
-    )
-  } catch {
-    // Column already exists.
-  }
-
-
   for (const statement of statements) {
     await prisma.$executeRawUnsafe(statement)
   }

package/src/generated/browser.ts

@@ -0,0 +1,49 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma-related types and utilities in a browser. 
+ * Use it to get access to models, enums, and input types.
+ * 
+ * This file does not contain a `PrismaClient` class, nor several other helpers that are intended as server-side only.
+ * See `client.ts` for the standard, server-side entry point.
+ *
+ * 🟢 You can import this file directly.
+ */
+
+import * as Prisma from './internal/prismaNamespaceBrowser.js'
+export { Prisma }
+export * as $Enums from './enums.js'
+export * from './enums.js';
+/**
+ * Model Account
+ * 
+ */
+export type Account = Prisma.AccountModel
+/**
+ * Model Thread
+ * 
+ */
+export type Thread = Prisma.ThreadModel
+/**
+ * Model Label
+ * 
+ */
+export type Label = Prisma.LabelModel
+/**
+ * Model Profile
+ * 
+ */
+export type Profile = Prisma.ProfileModel
+/**
+ * Model CalendarList
+ * 
+ */
+export type CalendarList = Prisma.CalendarListModel
+/**
+ * Model SyncState
+ * 
+ */
+export type SyncState = Prisma.SyncStateModel

package/src/generated/client.ts

@@ -0,0 +1,71 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma. Through it you get access to all the models, enums, and input types.
+ * If you're looking for something you can import in the client-side of your application, please refer to the `browser.ts` file instead.
+ *
+ * 🟢 You can import this file directly.
+ */
+
+import * as process from 'node:process'
+import * as path from 'node:path'
+import { fileURLToPath } from 'node:url'
+globalThis['__dirname'] = path.dirname(fileURLToPath(import.meta.url))
+
+import * as runtime from "@prisma/client/runtime/client"
+import * as $Enums from "./enums.js"
+import * as $Class from "./internal/class.js"
+import * as Prisma from "./internal/prismaNamespace.js"
+
+export * as $Enums from './enums.js'
+export * from "./enums.js"
+/**
+ * ## Prisma Client
+ * 
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient()
+ * // Fetch zero or more Accounts
+ * const accounts = await prisma.account.findMany()
+ * ```
+ * 
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+export const PrismaClient = $Class.getPrismaClientClass()
+export type PrismaClient<LogOpts extends Prisma.LogLevel = never, OmitOpts extends Prisma.PrismaClientOptions["omit"] = Prisma.PrismaClientOptions["omit"], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $Class.PrismaClient<LogOpts, OmitOpts, ExtArgs>
+export { Prisma }
+
+/**
+ * Model Account
+ * 
+ */
+export type Account = Prisma.AccountModel
+/**
+ * Model Thread
+ * 
+ */
+export type Thread = Prisma.ThreadModel
+/**
+ * Model Label
+ * 
+ */
+export type Label = Prisma.LabelModel
+/**
+ * Model Profile
+ * 
+ */
+export type Profile = Prisma.ProfileModel
+/**
+ * Model CalendarList
+ * 
+ */
+export type CalendarList = Prisma.CalendarListModel
+/**
+ * Model SyncState
+ * 
+ */
+export type SyncState = Prisma.SyncStateModel