zele 0.3.0 → 0.3.6

package/src/commands/mail-actions.ts

@@ -1,36 +1,31 @@
 // Mail action commands: star, unstar, archive, trash, untrash, mark read/unread, label modify.
-// Bulk operations on threads — all invalidate relevant caches after mutation.
+// Bulk operations on threads — cache invalidation is handled by the client methods.
 
 import type { Goke } from 'goke'
 import { z } from 'zod'
 import { 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 * as out from '../output.js'
+import { handleCommandError } from '../output.js'
 
 // ---------------------------------------------------------------------------
-// Helper: run a bulk action with cache invalidation
+// Helper: run a bulk action
 // ---------------------------------------------------------------------------
 
 async function bulkAction(
   threadIds: string[],
   actionName: string,
-  account: string[] | undefined,
-  fn: (client: GmailClient, ids: string[]) => Promise<void>,
+  accountFilter: string[] | undefined,
+  fn: (client: GmailClient, ids: string[]) => Promise<void | Error>,
 ) {
   if (threadIds.length === 0) {
     out.error('No thread IDs provided')
     process.exit(1)
   }
 
-  const { email, client } = await getClient(account)
-
-  await fn(client, threadIds)
-
-  // Invalidate caches
-  await cache.invalidateThreads(email, threadIds)
-  await cache.invalidateThreadLists(email)
-  await cache.invalidateLabelCounts(email)
+  const { client } = await getClient(accountFilter)
+  const result = await fn(client, threadIds)
+  if (result instanceof Error) handleCommandError(result)
 
   out.printYaml({ action: actionName, thread_ids: threadIds, success: true })
 }
@@ -106,12 +101,9 @@ export function registerMailActionCommands(cli: Goke) {
   cli
     .command('mail trash-spam', 'Trash all spam threads')
     .action(async (options) => {
-      const { email, client } = await getClient(options.account)
-
+      const { client } = await getClient(options.account)
       const result = await client.trashAllSpam()
-
-      await cache.invalidateThreadLists(email)
-      await cache.invalidateLabelCounts(email)
+      if (result instanceof Error) handleCommandError(result)
 
       out.printYaml(result)
       out.success(`Trashed ${result.count} spam thread(s)`)

package/src/commands/mail.ts

@@ -1,15 +1,17 @@
 // Mail commands: list, search, read, send, reply, forward.
-// Core email operations wrapping GmailClient with cache-first reads
-// and YAML output for list views.
+// Core email operations wrapping GmailClient with YAML output for list views.
+// Cache is handled by the client — commands just call methods and use data.
 // Multi-account: list/search fetch all accounts concurrently and merge by date.
 
 import type { Goke } from 'goke'
 import { z } from 'zod'
 import fs from 'node:fs'
-import { getClients, getClient } from '../auth.js'
-import { GmailClient, type ThreadData, type ThreadListResult } from '../gmail-client.js'
-import * as cache from '../gmail-cache.js'
+import React from 'react'
+import { getClients, getClient, listAccounts, login } from '../auth.js'
+import type { ThreadListResult } 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'
 
 // ---------------------------------------------------------------------------
@@ -17,6 +19,24 @@ import pc from 'picocolors'
 // ---------------------------------------------------------------------------
 
 export function registerMailCommands(cli: Goke) {
+  // =========================================================================
+  // mail (TUI)
+  // =========================================================================
+
+  cli
+    .command('mail', 'Browse emails in TUI')
+    .action(async () => {
+      const accounts = await listAccounts()
+      if (accounts.length === 0) {
+        const result = await login()
+        if (result instanceof Error) handleCommandError(result)
+      }
+
+      const { renderWithProviders } = await import('termcast')
+      const { default: Command } = await import('../mail-tui.js')
+      await renderWithProviders(React.createElement(Command))
+    })
+
   // =========================================================================
   // mail list
   // =========================================================================
@@ -27,7 +47,6 @@ export function registerMailCommands(cli: Goke) {
     .option('--max [max]', 'Max results per page (default: 20)')
     .option('--page <page>', 'Pagination token')
     .option('--label <label>', 'Filter by label name')
-    .option('--no-cache', 'Skip cache')
     .action(async (options) => {
       const folder = options.folder ?? 'inbox'
       const max = options.max ? Number(options.max) : 20
@@ -38,47 +57,25 @@ export function registerMailCommands(cli: Goke) {
         process.exit(1)
       }
 
-      const cacheParams = {
-        folder,
-        maxResults: max,
-        labelIds: options.label ? [options.label] : undefined,
-        pageToken: options.page,
-      }
-
-      // 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.getCachedThreadList<ThreadListResult>(email, cacheParams)
-            if (cached) {
-              return { email, result: cached }
-            }
-          }
-
           const result = await client.listThreads({
             folder,
             maxResults: max,
             labelIds: options.label ? [options.label] : undefined,
             pageToken: options.page,
           })
-
-          if (!options.noCache) {
-            await cache.cacheThreadList(email, cacheParams, result)
-          }
-
+          if (result instanceof Error) return result
           return { email, result }
         }),
       )
 
-      const allResults = settled
-        .filter((r): r is PromiseFulfilledResult<{ email: string; result: ThreadListResult }> => {
-          if (r.status === 'rejected') {
-            out.error(`Failed to fetch: ${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: ${r.message}`); return false }
           return true
         })
-        .map((r) => r.value)
 
       // Merge threads from all accounts, sorted by date descending, capped at max
       const merged = allResults
@@ -97,6 +94,7 @@ export function registerMailCommands(cli: Goke) {
       out.printList(
         merged.map((t) => ({
           ...(showAccount ? { account: t.account } : {}),
+          id: t.id,
           flags: out.formatFlags(t),
           from: out.formatSender(t.from),
           subject: t.subject,
@@ -125,27 +123,24 @@ export function registerMailCommands(cli: Goke) {
         process.exit(1)
       }
 
-      // Search all accounts concurrently, tolerating individual failures
-      const settled = await Promise.allSettled(
+      // Search all accounts concurrently
+      const results = await Promise.all(
         clients.map(async ({ email, client }) => {
           const result = await client.listThreads({
             query,
             maxResults: max,
             pageToken: options.page,
           })
+          if (result instanceof Error) return result
           return { email, result }
         }),
       )
 
-      const allResults = settled
-        .filter((r): r is PromiseFulfilledResult<{ email: string; result: ThreadListResult }> => {
-          if (r.status === 'rejected') {
-            out.error(`Failed to search: ${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 search: ${r.message}`); return false }
           return true
         })
-        .map((r) => r.value)
 
       const merged = allResults
         .flatMap(({ email, result }) =>
@@ -163,6 +158,7 @@ export function registerMailCommands(cli: Goke) {
       out.printList(
         merged.map((t) => ({
           ...(showAccount ? { account: t.account } : {}),
+          id: t.id,
           flags: out.formatFlags(t),
           from: out.formatSender(t.from),
           subject: t.subject,
@@ -181,65 +177,93 @@ export function registerMailCommands(cli: Goke) {
   cli
     .command('mail read <threadId>', 'Read a full email thread')
     .option('--raw', 'Show raw message (first message only)')
-    .option('--no-cache', 'Skip cache')
+    .option('--raw-html', 'Show raw HTML body per message (no markdown conversion)')
     .action(async (threadId, options) => {
-      const { email, client } = await getClient(options.account)
+      const { client } = await getClient(options.account)
+
+      if (options.raw && options.rawHtml) {
+        out.error('--raw and --raw-html cannot be used together')
+        process.exit(1)
+      }
 
       if (options.raw) {
-        const thread = await client.getThread({ threadId })
+        const { parsed: thread } = await client.getThread({ threadId })
         if (thread.messages.length === 0) {
           out.hint('No messages in thread')
           return
         }
         const rawMsg = await client.getRawMessage({ messageId: thread.messages[0]!.id })
-        process.stdout.write(rawMsg + '\n')
+        if (rawMsg instanceof Error) handleCommandError(rawMsg)
+        console.log(rawMsg)
         return
       }
 
-      // Cache-first read
-      let thread: ThreadData | undefined
-      if (!options.noCache) {
-        thread = await cache.getCachedThread<ThreadData>(email, threadId)
-      }
-      if (!thread) {
-        thread = await client.getThread({ threadId })
-        if (!options.noCache) {
-          await cache.cacheThread(email, threadId, thread)
-        }
-      }
+      const { parsed: thread } = await client.getThread({ threadId })
 
       if (thread.messages.length === 0) {
         out.hint('No messages in thread')
         return
       }
 
+      if (options.rawHtml) {
+        thread.messages.forEach((msg, index) => {
+          console.log(msg.body)
+          if (index < thread.messages.length - 1) {
+            console.log('\n<!-- ZELE_MESSAGE_SEPARATOR -->\n')
+          }
+        })
+        return
+      }
+
+      const w = Math.min(process.stdout.columns || 72, 72)
+      const rule = pc.dim('─'.repeat(w))
+
       // Render thread header
-      process.stdout.write(pc.bold(thread.subject) + '\n')
-      process.stdout.write(pc.dim(`Thread ID: ${thread.id} | ${thread.messageCount} message(s)`) + '\n')
-      process.stdout.write(pc.dim('─'.repeat(60)) + '\n\n')
+      console.log(pc.bold(thread.subject))
+      // Collect unique participants
+      const participants = new Map<string, string>()
+      for (const msg of thread.messages) {
+        participants.set(msg.from.email, msg.from.name || msg.from.email)
+        for (const r of msg.to) participants.set(r.email, r.name || r.email)
+      }
+      const participantStr = [...participants.values()].join(', ')
+      console.log(pc.dim(`${thread.messageCount} message(s) · ${participantStr}`))
+      console.log(pc.dim(`ID: ${thread.id}`))
+      console.log(rule + '\n')
 
       // Render each message
       for (const msg of thread.messages) {
         const fromStr = out.formatSender(msg.from)
         const dateStr = out.formatDate(msg.date)
-        const flags = out.formatFlags(msg)
 
-        process.stdout.write(pc.bold(fromStr) + (flags ? ` ${flags}` : '') + '\n')
-        process.stdout.write(pc.dim(`To: ${msg.to.map((t) => t.email).join(', ')}`) + '\n')
+        // Flags as dim tags
+        const flagParts: string[] = []
+        if (msg.unread) flagParts.push(pc.yellow('[unread]'))
+        if (msg.starred) flagParts.push(pc.yellow('[starred]'))
+        const flagStr = flagParts.length > 0 ? ' ' + flagParts.join(' ') : ''
+
+        console.log(pc.bold(`From: `) + fromStr + flagStr)
+        console.log(pc.dim(`  To: ${msg.to.map((t) => t.email).join(', ')}`))
         if (msg.cc && msg.cc.length > 0) {
-          process.stdout.write(pc.dim(`Cc: ${msg.cc.map((c) => c.email).join(', ')}`) + '\n')
+          console.log(pc.dim(`  Cc: ${msg.cc.map((c) => c.email).join(', ')}`))
         }
-        process.stdout.write(pc.dim(`Date: ${dateStr} | ID: ${msg.id}`) + '\n')
+        console.log(pc.dim(`Date: ${dateStr}`))
 
         if (msg.attachments.length > 0) {
-          process.stdout.write(pc.dim(`Attachments: ${msg.attachments.map((a) => a.filename).join(', ')}`) + '\n')
+          const attList = msg.attachments.map((a) => {
+            const size = a.size < 1024 ? `${a.size} B`
+              : a.size < 1048576 ? `${(a.size / 1024).toFixed(1)} KB`
+              : `${(a.size / 1048576).toFixed(1)} MB`
+            return `${a.filename} (${size})`
+          })
+          console.log(pc.dim(`Attachments: ${attList.join(', ')}`))
         }
 
-        process.stdout.write('\n')
+        console.log()
 
         const body = out.renderEmailBody(msg.body, msg.mimeType)
-        process.stdout.write(body + '\n')
-        process.stdout.write('\n' + pc.dim('─'.repeat(60)) + '\n\n')
+        console.log(body)
+        console.log('\n' + rule + '\n')
       }
     })
 
@@ -287,7 +311,7 @@ export function registerMailCommands(cli: Goke) {
       const parseEmails = (str: string) =>
         str.split(',').map((e) => e.trim()).filter(Boolean).map((email) => ({ email }))
 
-      const { email, client } = await getClient(options.account)
+      const { client } = await getClient(options.account)
 
       const result = await client.sendMessage({
         to: parseEmails(options.to),
@@ -298,8 +322,6 @@ export function registerMailCommands(cli: Goke) {
         fromEmail: options.from,
       })
 
-      await cache.invalidateThreadLists(email)
-
       out.printYaml(result)
       out.success(`Sent to ${options.to}`)
     })
@@ -316,16 +338,6 @@ export function registerMailCommands(cli: Goke) {
     .option('--all', 'Reply all (include all original recipients)')
     .option('--from <from>', z.string().describe('Send-as alias email'))
     .action(async (threadId, options) => {
-      const { email, client } = await getClient(options.account)
-
-      const thread = await client.getThread({ threadId })
-      if (thread.messages.length === 0) {
-        out.error('No messages in thread')
-        process.exit(1)
-      }
-
-      const lastMsg = thread.messages[thread.messages.length - 1]!
-
       let body = options.body ?? ''
       if (options.bodyFile) {
         if (options.bodyFile === '-') {
@@ -344,49 +356,20 @@ export function registerMailCommands(cli: Goke) {
         process.exit(1)
       }
 
-      const replyTo = lastMsg.replyTo ?? lastMsg.from.email
-      const to = [{ email: replyTo }]
-
-      let cc: Array<{ email: string }> | undefined
-      if (options.all) {
-        const profile = await client.getProfile()
-        const myEmail = profile.emailAddress.toLowerCase()
-
-        const allRecipients = [
-          ...lastMsg.to.map((r) => r.email),
-          ...(lastMsg.cc?.map((r) => r.email) ?? []),
-        ]
-          .filter((e) => e.toLowerCase() !== myEmail)
-          .filter((e) => e.toLowerCase() !== replyTo.toLowerCase())
-
-        if (allRecipients.length > 0) {
-          cc = allRecipients.map((e) => ({ email: e }))
-        }
-      }
-
-      if (options.cc) {
-        const extra = options.cc
-          .split(',')
-          .map((e: string) => ({ email: e.trim() }))
-          .filter((e: { email: string }) => e.email)
-        cc = [...(cc ?? []), ...extra]
-      }
+      const { client } = await getClient(options.account)
 
-      const refs = [lastMsg.references, lastMsg.messageId].filter(Boolean).join(' ')
+      const cc = options.cc
+        ? options.cc.split(',').map((e: string) => ({ email: e.trim() })).filter((e: { email: string }) => e.email)
+        : undefined
 
-      const result = await client.sendMessage({
-        to,
-        subject: lastMsg.subject.startsWith('Re:') ? lastMsg.subject : `Re: ${lastMsg.subject}`,
+      const result = await client.replyToThread({
+        threadId,
         body,
+        replyAll: options.all,
         cc,
-        threadId,
-        inReplyTo: lastMsg.messageId,
-        references: refs || undefined,
         fromEmail: options.from,
       })
-
-      await cache.invalidateThread(email, threadId)
-      await cache.invalidateThreadLists(email)
+      if (result instanceof Error) handleCommandError(result)
 
       out.printYaml(result)
       out.success('Reply sent')
@@ -407,42 +390,20 @@ export function registerMailCommands(cli: Goke) {
         process.exit(1)
       }
 
-      const { email, client } = await getClient(options.account)
-
-      const thread = await client.getThread({ threadId })
-      if (thread.messages.length === 0) {
-        out.error('No messages in thread')
-        process.exit(1)
-      }
-
-      const lastMsg = thread.messages[thread.messages.length - 1]!
-      const forwardedBody = out.renderEmailBody(lastMsg.body, lastMsg.mimeType)
-
-      const fullBody = [
-        options.body ?? '',
-        '',
-        '---------- Forwarded message ----------',
-        `From: ${out.formatSender(lastMsg.from)}`,
-        `Date: ${lastMsg.date}`,
-        `Subject: ${lastMsg.subject}`,
-        `To: ${lastMsg.to.map((t) => t.email).join(', ')}`,
-        '',
-        forwardedBody,
-      ].join('\n')
-
       const recipients = options.to
         .split(',')
         .map((e: string) => ({ email: e.trim() }))
         .filter((e: { email: string }) => e.email)
 
-      const result = await client.sendMessage({
+      const { client } = await getClient(options.account)
+
+      const result = await client.forwardThread({
+        threadId,
         to: recipients,
-        subject: `Fwd: ${lastMsg.subject}`,
-        body: fullBody,
+        body: options.body,
         fromEmail: options.from,
       })
-
-      await cache.invalidateThreadLists(email)
+      if (result instanceof Error) handleCommandError(result)
 
       out.printYaml(result)
       out.success(`Forwarded to ${options.to}`)

package/src/commands/profile.ts

@@ -1,52 +1,36 @@
 // Profile command: show account info.
 // Displays email address, message/thread counts, and aliases as YAML.
+// Cache is handled by the client — commands just call methods and use data.
 // Multi-account: shows all accounts or filtered by --account.
 
 import type { Goke } from 'goke'
 import { getClients } 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 registerProfileCommands(cli: Goke) {
   cli
     .command('profile', 'Show Gmail account info')
-    .option('--no-cache', 'Skip cache')
     .action(async (options) => {
       const clients = await getClients(options.account)
 
-      type Profile = Awaited<ReturnType<GmailClient['getProfile']>>
-
-      // Fetch all accounts concurrently, tolerating individual failures
-      const settled = await Promise.allSettled(
-        clients.map(async ({ email, client }) => {
-          let profile: Profile | undefined
-          if (!options.noCache) {
-            profile = await cache.getCachedProfile<Profile>(email)
-          }
-          if (!profile) {
-            profile = await client.getProfile()
-            if (!options.noCache) {
-              await cache.cacheProfile(email, profile)
-            }
-          }
-
+      // Fetch all accounts concurrently
+      const allResults = await Promise.all(
+        clients.map(async ({ client }) => {
+          const profile = await client.getProfile()
+          if (profile instanceof Error) return profile
           // Always fetch aliases fresh
           const aliases = await client.getEmailAliases()
-
-          return { email, profile, aliases }
+          if (aliases instanceof Error) return aliases
+          return { profile, aliases }
         }),
       )
 
-      const results = settled
-        .filter((r): r is PromiseFulfilledResult<{ email: string; profile: Profile; aliases: Awaited<ReturnType<GmailClient['getEmailAliases']>> }> => {
-          if (r.status === 'rejected') {
-            out.error(`Failed to fetch profile: ${r.reason}`)
-            return false
-          }
+      const results = allResults.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 profile: ${r.message}`); return false }
           return true
         })
-        .map((r) => r.value)
 
       for (const { profile, aliases } of results) {
         out.printYaml({