@bobfrankston/mailx 1.0.171 → 1.0.173

package/packages/mailx-imap/index.js

@@ -11,6 +11,7 @@ import { EventEmitter } from "node:events";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { simpleParser } from "mailparser";
+import { GmailApiProvider } from "./providers/gmail-api.js";
 import { createTransport } from "nodemailer";
 import * as os from "node:os";
 /** Extract full error detail with provenance */
@@ -369,11 +370,46 @@ export class ImapManager extends EventEmitter {
                 }
                 else if (!this.accountErrorShown.has(account.id)) {
                     this.accountErrorShown.add(account.id);
-                    this.emit("accountError", account.id, errMsg, "Authentication may have expired", true);
+                    const config = this.configs.get(account.id);
+                    this.emit("accountError", account.id, errMsg, errMsg, !!config?.tokenProvider);
                 }
             }
         }
     }
+    /** Check if an account uses Gmail (should use API instead of IMAP) */
+    isGmailAccount(accountId) {
+        const settings = loadSettings();
+        const account = settings.accounts.find(a => a.id === accountId);
+        if (!account)
+            return false;
+        return account.imap?.host?.includes("gmail") || account.email?.endsWith("@gmail.com") || false;
+    }
+    /** Get a Gmail API provider for an account (reuses tokenProvider from IMAP config) */
+    getGmailProvider(accountId) {
+        const config = this.configs.get(accountId);
+        if (!config?.tokenProvider)
+            throw new Error(`No tokenProvider for ${accountId}`);
+        return new GmailApiProvider(config.tokenProvider);
+    }
+    /** Convert ProviderMessage to the shape expected by storeMessages/upsertMessage */
+    providerMsgToLocal(msg) {
+        return {
+            uid: msg.uid,
+            messageId: msg.messageId,
+            date: msg.date || new Date(),
+            subject: msg.subject,
+            from: msg.from,
+            to: msg.to,
+            cc: msg.cc,
+            seen: msg.seen,
+            flagged: msg.flagged,
+            answered: msg.answered,
+            draft: msg.draft,
+            size: msg.size,
+            source: msg.source,
+            providerId: msg.providerId,
+        };
+    }
     /** Sync folder list for an account */
     async syncFolders(accountId, client) {
         if (!client)
@@ -486,7 +522,7 @@ export class ImapManager extends EventEmitter {
             : new Date(0);
         if (highestUid > 0) {
             // Incremental: fetch new messages — prefetch bodies for offline access
-            const fetched = await client.fetchMessagesSinceUid(folder.path, highestUid, { source: prefetch });
+            const fetched = await client.fetchMessagesSinceUid(folder.path, highestUid, { source: false });
             // Filter out the last known message (IMAP * always returns at least one)
             messages = fetched.filter((m) => m.uid > highestUid);
             // Gap detection: check for missing UIDs within the range we've already synced
@@ -507,7 +543,7 @@ export class ImapManager extends EventEmitter {
                         for (let i = 0; i < missingUids.length; i += chunkSize) {
                             const chunk = missingUids.slice(i, i + chunkSize);
                             const range = chunk.join(",");
-                            const recovered = await client.fetchMessages(folder.path, range, { source: prefetch });
+                            const recovered = await client.fetchMessages(folder.path, range, { source: false });
                             messages.push(...recovered);
                         }
                     }
@@ -523,7 +559,7 @@ export class ImapManager extends EventEmitter {
             const oldestDate = this.db.getOldestDate(accountId, folderId);
             if (oldestDate > 0 && startDate.getTime() < oldestDate) {
                 const existingUids = new Set(this.db.getUidsForFolder(accountId, folderId));
-                const backfill = await client.fetchMessageByDate(folder.path, startDate, new Date(oldestDate), { source: prefetch });
+                const backfill = await client.fetchMessageByDate(folder.path, startDate, new Date(oldestDate), { source: false });
                 const newBackfill = backfill.filter((m) => !existingUids.has(m.uid));
                 if (newBackfill.length > 0) {
                     console.log(`  ${folder.path}: backfilling ${newBackfill.length} older messages`);
@@ -543,7 +579,8 @@ export class ImapManager extends EventEmitter {
                 }
             };
             const tomorrow = new Date(Date.now() + 86400000); // IMAP BEFORE is exclusive
-            messages = await client.fetchMessageByDate(folder.path, startDate, tomorrow, { source: prefetch }, onChunk);
+            // First sync: metadata only for fast UI — bodies prefetched in background after
+            messages = await client.fetchMessageByDate(folder.path, startDate, tomorrow, { source: false }, onChunk);
             if (totalStored > 0) {
                 console.log(`  ${folder.path}: ${totalStored} messages (streamed)`);
                 this.db.recalcFolderCounts(folderId);
@@ -694,9 +731,19 @@ export class ImapManager extends EventEmitter {
         // Sync all accounts in parallel — each manages its own connection
         const syncPromises = [...this.configs.keys()].map(accountId => this.syncAccount(accountId, priorityOrder));
         await Promise.allSettled(syncPromises);
+        // Background body prefetch — after sync, fetch bodies for messages that don't have them
+        if (getPrefetch()) {
+            for (const accountId of this.configs.keys()) {
+                this.prefetchBodies(accountId).catch(e => console.error(`  [prefetch] ${accountId}: ${e.message}`));
+            }
+        }
     }
     /** Sync a single account — manages its own connection lifecycle */
     async syncAccount(accountId, priorityOrder) {
+        // Gmail: use REST API instead of IMAP
+        if (this.isGmailAccount(accountId)) {
+            return this.syncAccountViaApi(accountId, priorityOrder);
+        }
         try {
             // Step 1: Get folder list (fast — <1s typically)
             let client = await this.getOpsClient(accountId);
@@ -781,6 +828,145 @@ export class ImapManager extends EventEmitter {
             this.handleSyncError(accountId, errMsg);
         }
     }
+    /** Sync a Gmail account via REST API — no IMAP connections */
+    async syncAccountViaApi(accountId, priorityOrder) {
+        try {
+            const api = this.getGmailProvider(accountId);
+            const t0 = Date.now();
+            // Step 1: Sync folder list via API
+            console.log(`  [api] ${accountId}: listing labels...`);
+            const apiFolders = await api.listFolders();
+            console.log(`  [api] ${accountId}: ${apiFolders.length} labels in ${Date.now() - t0}ms`);
+            // Store folders in DB (same as IMAP path)
+            for (const f of apiFolders) {
+                const specialUse = f.specialUse || "";
+                this.db.upsertFolder(accountId, f.path, f.name, specialUse, f.delimiter);
+            }
+            this.emit("folderCountsChanged", accountId, {});
+            const dbFolders = this.db.getFolders(accountId);
+            // Step 2: Sync folders — INBOX first, then by priority
+            const inbox = dbFolders.find(f => f.specialUse === "inbox");
+            const remaining = dbFolders.filter(f => f.specialUse !== "inbox");
+            remaining.sort((a, b) => {
+                const pa = priorityOrder.indexOf(a.specialUse || "") >= 0 ? priorityOrder.indexOf(a.specialUse || "") : 5;
+                const pb = priorityOrder.indexOf(b.specialUse || "") >= 0 ? priorityOrder.indexOf(b.specialUse || "") : 5;
+                return pa - pb;
+            });
+            const foldersToSync = inbox ? [inbox, ...remaining] : remaining;
+            for (const folder of foldersToSync) {
+                try {
+                    await this.syncFolderViaApi(accountId, folder, api);
+                }
+                catch (e) {
+                    console.error(`  [api] ${accountId}/${folder.path}: ${e.message}`);
+                }
+            }
+            await api.close();
+            this.accountErrorShown.delete(accountId);
+            this.emit("syncComplete", accountId);
+        }
+        catch (e) {
+            const errMsg = e.message || String(e);
+            this.emit("syncError", accountId, errMsg);
+            console.error(`  [api] Sync error for ${accountId}: ${errMsg}`);
+            this.handleSyncError(accountId, errMsg);
+        }
+    }
+    /** Sync a single folder via Gmail/Outlook API */
+    async syncFolderViaApi(accountId, folder, api) {
+        const highestUid = this.db.getHighestUid(accountId, folder.id);
+        const historyDays = getHistoryDays(accountId);
+        const effectiveDays = (historyDays === 0 && highestUid === 0) ? 30 : historyDays;
+        const startDate = effectiveDays > 0 ? new Date(Date.now() - effectiveDays * 86400000) : new Date(0);
+        const tomorrow = new Date(Date.now() + 86400000);
+        this.emit("syncProgress", accountId, `sync:${folder.path}`, 0);
+        console.log(`  [api] ${accountId}/${folder.path}: syncing (highestUid=${highestUid})...`);
+        let messages;
+        if (highestUid > 0) {
+            // Incremental: fetch messages since last known UID
+            messages = await api.fetchSince(folder.path, highestUid, { source: false });
+        }
+        else {
+            // First sync: fetch by date range
+            messages = await api.fetchByDate(folder.path, startDate, tomorrow, { source: false }, (chunk) => {
+                // Stream chunks to DB for instant UI
+                const stored = this.storeApiMessages(accountId, folder.id, chunk, highestUid);
+                if (stored > 0) {
+                    this.db.recalcFolderCounts(folder.id);
+                    this.emit("folderCountsChanged", accountId, {});
+                }
+            });
+            // First sync chunks already stored via onChunk — just update counts
+            this.db.recalcFolderCounts(folder.id);
+            this.emit("folderCountsChanged", accountId, {});
+            this.emit("syncProgress", accountId, `sync:${folder.path}`, 100);
+            if (messages.length > 0)
+                console.log(`  [api] ${accountId}/${folder.path}: ${messages.length} messages`);
+            return;
+        }
+        if (messages.length > 0) {
+            console.log(`  [api] ${accountId}/${folder.path}: ${messages.length} new messages`);
+            this.storeApiMessages(accountId, folder.id, messages, highestUid);
+        }
+        // Reconcile deletions
+        try {
+            const serverUids = new Set(await api.getUids(folder.path));
+            const localUids = this.db.getUidsForFolder(accountId, folder.id);
+            let deleted = 0;
+            for (const uid of localUids) {
+                if (!serverUids.has(uid)) {
+                    this.db.deleteMessage(accountId, uid);
+                    this.bodyStore.deleteMessage(accountId, folder.id, uid).catch(() => { });
+                    deleted++;
+                }
+            }
+            if (deleted > 0)
+                console.log(`  [api] ${accountId}/${folder.path}: ${deleted} deleted`);
+        }
+        catch (e) {
+            console.error(`  [api] ${accountId}/${folder.path}: reconciliation error: ${e.message}`);
+        }
+        this.db.recalcFolderCounts(folder.id);
+        this.emit("folderCountsChanged", accountId, {});
+        this.emit("syncProgress", accountId, `sync:${folder.path}`, 100);
+    }
+    /** Store API-fetched messages to DB */
+    storeApiMessages(accountId, folderId, msgs, highestUid) {
+        let stored = 0;
+        this.db.beginTransaction();
+        try {
+            for (const msg of msgs) {
+                if (msg.uid <= highestUid)
+                    continue;
+                const flags = [];
+                if (msg.seen)
+                    flags.push("\\Seen");
+                if (msg.flagged)
+                    flags.push("\\Flagged");
+                if (msg.answered)
+                    flags.push("\\Answered");
+                if (msg.draft)
+                    flags.push("\\Draft");
+                this.db.upsertMessage({
+                    accountId, folderId, uid: msg.uid,
+                    messageId: msg.messageId || "", inReplyTo: "", references: [],
+                    date: msg.date instanceof Date ? msg.date.getTime() : Date.now(),
+                    subject: msg.subject || "",
+                    from: toEmailAddress(msg.from?.[0] || {}),
+                    to: toEmailAddresses(msg.to || []),
+                    cc: toEmailAddresses(msg.cc || []),
+                    flags, size: msg.size || 0, hasAttachments: false, preview: "", bodyPath: ""
+                });
+                stored++;
+            }
+            this.db.commitTransaction();
+        }
+        catch (e) {
+            this.db.rollbackTransaction();
+            console.error(`  [api] storeApiMessages error: ${e.message}`);
+        }
+        return stored;
+    }
     /** Kill and recreate the persistent ops connection */
     async reconnectOps(accountId) {
         const old = this.opsClients.get(accountId);
@@ -818,7 +1004,7 @@ export class ImapManager extends EventEmitter {
         }
         else if (!this.accountErrorShown.has(accountId)) {
             this.accountErrorShown.add(accountId);
-            this.emit("accountError", accountId, errMsg, isOAuth ? "Authentication may have expired" : "Check server connectivity", isOAuth);
+            this.emit("accountError", accountId, errMsg, errMsg, isOAuth);
         }
     }
     /** Sync just INBOX for each account (fast check for new mail) */
@@ -855,6 +1041,8 @@ export class ImapManager extends EventEmitter {
             return;
         if (this.reauthenticating.has(accountId))
             return;
+        if (this.isGmailAccount(accountId))
+            return; // Gmail uses API sync, not IMAP polling
         this.quickCheckRunning.add(accountId);
         let client = null;
         try {
@@ -995,13 +1183,16 @@ export class ImapManager extends EventEmitter {
         const folder = this.db.getFolders(accountId).find(f => f.id === folderId);
         if (!folder)
             return null;
-        // Serialize: only one body fetch per account at a time (IMAP can only handle one command)
+        // Gmail: use API for body fetch (no IMAP connection needed)
+        if (this.isGmailAccount(accountId)) {
+            return this.fetchMessageBodyViaApi(accountId, folderId, uid, folder.path);
+        }
+        // IMAP: serialize — only one body fetch per account at a time
         return this.enqueueFetch(accountId, async () => {
             // Re-check cache — may have been fetched while queued
             if (await this.bodyStore.hasMessage(accountId, folderId, uid)) {
                 return this.bodyStore.getMessage(accountId, folderId, uid);
             }
-            // Body fetch uses a fresh connection — never waits behind background sync
             let client = null;
             try {
                 client = this.newClient(accountId);
@@ -1027,6 +1218,45 @@ export class ImapManager extends EventEmitter {
             }
         });
     }
+    /** Fetch message body via Gmail/Outlook API */
+    async fetchMessageBodyViaApi(accountId, folderId, uid, folderPath) {
+        try {
+            const api = this.getGmailProvider(accountId);
+            const msg = await api.fetchOne(folderPath, uid, { source: true });
+            await api.close();
+            if (!msg?.source)
+                return null;
+            const raw = Buffer.from(msg.source, "utf-8");
+            const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
+            this.db.updateBodyPath(accountId, uid, bodyPath);
+            return raw;
+        }
+        catch (e) {
+            console.error(`  [api] Body fetch error (${accountId}/${uid}): ${e.message}`);
+            return null;
+        }
+    }
+    /** Background body prefetch — download bodies for messages that don't have them */
+    async prefetchBodies(accountId) {
+        const missing = this.db.getMessagesWithoutBody(accountId, 25);
+        if (missing.length === 0)
+            return;
+        console.log(`  [prefetch] ${accountId}: ${missing.length} bodies to fetch`);
+        let fetched = 0;
+        for (const msg of missing) {
+            try {
+                const result = await this.fetchMessageBody(accountId, msg.folderId, msg.uid);
+                if (result)
+                    fetched++;
+            }
+            catch (e) {
+                console.error(`  [prefetch] ${accountId}/${msg.uid}: ${e.message}`);
+                break; // Stop on error — don't hammer a broken connection
+            }
+        }
+        if (fetched > 0)
+            console.log(`  [prefetch] ${accountId}: ${fetched} bodies cached`);
+    }
     /** Get the body store for direct access */
     getBodyStore() {
         return this.bodyStore;
@@ -1472,6 +1702,12 @@ export class ImapManager extends EventEmitter {
         const outboxFolder = this.findFolder(accountId, "outbox");
         if (!outboxFolder)
             return;
+        // Skip if this account's sync is failing — don't pile up connections
+        if (this.connectionBackoff.has(accountId) && Date.now() < (this.connectionBackoff.get(accountId) || 0))
+            return;
+        // Gmail uses SMTP for sending (not IMAP outbox) — skip IMAP outbox check
+        if (this.isGmailAccount(accountId))
+            return;
         const settings = loadSettings();
         const account = settings.accounts.find(a => a.id === accountId);
         if (!account)
@@ -1621,9 +1857,9 @@ export class ImapManager extends EventEmitter {
                     this.outboxBackoffDelay.delete(accountId);
                 }
                 catch (e) {
-                    // Exponential backoff: 30s → 60s → 120s → 300s (max 5min)
+                    // Exponential backoff: 60s → 120s → 300s (max 5min)
                     const prevDelay = this.outboxBackoffDelay.get(accountId) || 0;
-                    const delay = prevDelay ? Math.min(prevDelay * 2, 300000) : 30000;
+                    const delay = prevDelay ? Math.min(prevDelay * 2, 300000) : 60000;
                     this.outboxBackoffDelay.set(accountId, delay);
                     this.outboxBackoff.set(accountId, now + delay);
                     console.error(`  [outbox] Error for ${accountId}: ${imapError(e)} (retry in ${Math.round(delay / 1000)}s)`);

package/packages/mailx-imap/providers/gmail-api.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Gmail API provider — replaces IMAP for Gmail accounts.
+ * Uses REST API for fast, reliable sync without connection limit issues.
+ */
+import type { MailProvider, ProviderFolder, ProviderMessage, FetchOptions } from "./types.js";
+export declare class GmailApiProvider implements MailProvider {
+    private tokenProvider;
+    constructor(tokenProvider: () => Promise<string>);
+    private fetch;
+    listFolders(): Promise<ProviderFolder[]>;
+    /** List message IDs matching a query, handling pagination */
+    private listMessageIds;
+    /** Batch-fetch message metadata or full content */
+    private batchFetch;
+    /** Parse a Gmail API message response into ProviderMessage */
+    private parseMessage;
+    fetchSince(folder: string, sinceUid: number, options?: FetchOptions): Promise<ProviderMessage[]>;
+    fetchByDate(folder: string, since: Date, before: Date, options?: FetchOptions, onChunk?: (msgs: ProviderMessage[]) => void): Promise<ProviderMessage[]>;
+    fetchByUids(folder: string, uids: number[], options?: FetchOptions): Promise<ProviderMessage[]>;
+    fetchOne(folder: string, uid: number, options?: FetchOptions): Promise<ProviderMessage | null>;
+    getUids(folder: string): Promise<number[]>;
+    close(): Promise<void>;
+    /** Map folder path to Gmail label query term */
+    private folderToLabel;
+    /** Format date for Gmail query (YYYY/MM/DD) */
+    private formatDate;
+}
+//# sourceMappingURL=gmail-api.d.ts.map

package/packages/mailx-imap/providers/gmail-api.js

@@ -0,0 +1,244 @@
+/**
+ * Gmail API provider — replaces IMAP for Gmail accounts.
+ * Uses REST API for fast, reliable sync without connection limit issues.
+ */
+const API = "https://gmail.googleapis.com/gmail/v1/users/me";
+/** Convert Gmail hex ID to integer UID (lower 48 bits — deterministic, stable) */
+function idToUid(id) {
+    const hex = id.length > 12 ? id.slice(-12) : id;
+    return parseInt(hex, 16);
+}
+/** Map Gmail label to IMAP-style specialUse */
+function labelSpecialUse(label) {
+    switch (label.id) {
+        case "INBOX": return "inbox";
+        case "SENT": return "sent";
+        case "DRAFT": return "drafts";
+        case "TRASH": return "trash";
+        case "SPAM": return "junk";
+        case "STARRED": return "";
+        case "IMPORTANT": return "";
+        default: return "";
+    }
+}
+/** Parse RFC 2822 headers from Gmail metadata payload */
+function getHeader(headers, name) {
+    return headers.find(h => h.name.toLowerCase() === name.toLowerCase())?.value || "";
+}
+/** Parse "Name <addr>" or "addr" into { name, address } */
+function parseAddress(raw) {
+    const match = raw.match(/^"?([^"<]*?)"?\s*<([^>]+)>/);
+    if (match)
+        return { name: match[1].trim(), address: match[2].trim() };
+    return { address: raw.trim() };
+}
+function parseAddressList(raw) {
+    if (!raw)
+        return [];
+    // Split on commas that aren't inside quotes
+    return raw.split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/).map(s => parseAddress(s.trim())).filter(a => a.address);
+}
+export class GmailApiProvider {
+    tokenProvider;
+    constructor(tokenProvider) {
+        this.tokenProvider = tokenProvider;
+    }
+    async fetch(path, options = {}) {
+        const token = await this.tokenProvider();
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const res = await globalThis.fetch(`${API}${path}`, {
+                ...options,
+                headers: {
+                    "Authorization": `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                    ...options.headers,
+                },
+            });
+            if (res.status === 429) {
+                // Rate limited — back off and retry
+                const delay = (attempt + 1) * 2000;
+                console.log(`  [gmail] Rate limited, waiting ${delay / 1000}s...`);
+                await new Promise(r => setTimeout(r, delay));
+                continue;
+            }
+            if (!res.ok) {
+                const err = await res.text().catch(() => "");
+                throw new Error(`Gmail API ${res.status}: ${err.substring(0, 200)}`);
+            }
+            return res.json();
+        }
+        throw new Error("Gmail API: rate limited after 3 retries");
+    }
+    async listFolders() {
+        const data = await this.fetch("/labels");
+        const labels = data.labels || [];
+        const folders = [];
+        for (const label of labels) {
+            // Skip system labels that aren't useful as folders
+            if (["UNREAD", "STARRED", "IMPORTANT", "CATEGORY_PERSONAL",
+                "CATEGORY_SOCIAL", "CATEGORY_PROMOTIONS", "CATEGORY_UPDATES",
+                "CATEGORY_FORUMS", "CHAT"].includes(label.id))
+                continue;
+            const specialUse = labelSpecialUse(label);
+            // Map Gmail path separators (/) to IMAP-style
+            const path = label.name || label.id;
+            const name = path.includes("/") ? path.split("/").pop() : path;
+            folders.push({
+                path,
+                name,
+                delimiter: "/",
+                specialUse,
+                flags: label.type === "system" ? ["\\Noselect"] : [],
+            });
+        }
+        return folders;
+    }
+    /** List message IDs matching a query, handling pagination */
+    async listMessageIds(query, maxResults = 500) {
+        const ids = [];
+        let pageToken = "";
+        while (true) {
+            const params = new URLSearchParams({ q: query, maxResults: String(Math.min(maxResults - ids.length, 500)) });
+            if (pageToken)
+                params.set("pageToken", pageToken);
+            const data = await this.fetch(`/messages?${params}`);
+            for (const msg of data.messages || []) {
+                ids.push(msg.id);
+            }
+            if (!data.nextPageToken || ids.length >= maxResults)
+                break;
+            pageToken = data.nextPageToken;
+        }
+        return ids;
+    }
+    /** Batch-fetch message metadata or full content */
+    async batchFetch(ids, options = {}, onChunk) {
+        const all = [];
+        const chunkSize = options.source ? 10 : 50; // Smaller chunks for full bodies
+        const format = options.source ? "raw" : "metadata";
+        for (let i = 0; i < ids.length; i += chunkSize) {
+            const chunk = ids.slice(i, i + chunkSize);
+            // Sequential fetches to avoid Gmail 429 rate limits
+            const messages = [];
+            for (const id of chunk) {
+                const params = new URLSearchParams({ format });
+                if (format === "metadata") {
+                    for (const h of ["From", "To", "Cc", "Subject", "Message-ID", "Date"]) {
+                        params.append("metadataHeaders", h);
+                    }
+                }
+                messages.push(await this.fetch(`/messages/${id}?${params}`));
+            }
+            const parsed = messages.map(msg => this.parseMessage(msg, options));
+            all.push(...parsed);
+            if (onChunk)
+                onChunk(parsed);
+        }
+        return all;
+    }
+    /** Parse a Gmail API message response into ProviderMessage */
+    parseMessage(msg, options = {}) {
+        const labels = msg.labelIds || [];
+        const headers = msg.payload?.headers || [];
+        let source = "";
+        if (options.source && msg.raw) {
+            // Gmail returns URL-safe base64 — convert to standard base64 then decode
+            const base64 = msg.raw.replace(/-/g, "+").replace(/_/g, "/");
+            source = Buffer.from(base64, "base64").toString("utf-8");
+        }
+        const fromRaw = getHeader(headers, "From");
+        const toRaw = getHeader(headers, "To");
+        const ccRaw = getHeader(headers, "Cc");
+        const dateRaw = getHeader(headers, "Date") || "";
+        const subject = getHeader(headers, "Subject") || msg.snippet || "";
+        const messageId = getHeader(headers, "Message-ID") || "";
+        return {
+            uid: idToUid(msg.id),
+            messageId,
+            providerId: msg.id,
+            date: dateRaw ? new Date(dateRaw) : (msg.internalDate ? new Date(Number(msg.internalDate)) : null),
+            subject,
+            from: parseAddressList(fromRaw),
+            to: parseAddressList(toRaw),
+            cc: parseAddressList(ccRaw),
+            seen: !labels.includes("UNREAD"),
+            flagged: labels.includes("STARRED"),
+            answered: false, // Gmail API doesn't expose this directly
+            draft: labels.includes("DRAFT"),
+            size: msg.sizeEstimate || 0,
+            source,
+        };
+    }
+    async fetchSince(folder, sinceUid, options = {}) {
+        // Gmail doesn't have UIDs — use date-based query for incremental
+        // For now, fetch recent messages and let the caller filter by UID
+        const query = `in:${this.folderToLabel(folder)}`;
+        const ids = await this.listMessageIds(query, 200);
+        const messages = await this.batchFetch(ids, options);
+        return messages.filter(m => m.uid > sinceUid);
+    }
+    async fetchByDate(folder, since, before, options = {}, onChunk) {
+        const afterDate = this.formatDate(since);
+        const beforeDate = this.formatDate(before);
+        const query = `in:${this.folderToLabel(folder)} after:${afterDate} before:${beforeDate}`;
+        const ids = await this.listMessageIds(query);
+        return this.batchFetch(ids, options, onChunk);
+    }
+    async fetchByUids(folder, uids, options = {}) {
+        // UIDs are derived from Gmail IDs — we'd need a reverse lookup
+        // For now, fetch all messages in folder and filter
+        const query = `in:${this.folderToLabel(folder)}`;
+        const ids = await this.listMessageIds(query);
+        const uidSet = new Set(uids);
+        const matchingIds = ids.filter(id => uidSet.has(idToUid(id)));
+        return this.batchFetch(matchingIds, options);
+    }
+    async fetchOne(folder, uid, options = {}) {
+        // Need to find the Gmail ID from the UID — search all messages in folder
+        const query = `in:${this.folderToLabel(folder)}`;
+        const ids = await this.listMessageIds(query, 1000);
+        const id = ids.find(id => idToUid(id) === uid);
+        if (!id)
+            return null;
+        const format = options.source ? "raw" : "metadata";
+        const params = new URLSearchParams({ format });
+        if (format === "metadata") {
+            for (const h of ["From", "To", "Cc", "Subject", "Message-ID", "Date"]) {
+                params.append("metadataHeaders", h);
+            }
+        }
+        const msg = await this.fetch(`/messages/${id}?${params}`);
+        return this.parseMessage(msg, options);
+    }
+    async getUids(folder) {
+        const query = `in:${this.folderToLabel(folder)}`;
+        const ids = await this.listMessageIds(query, 10000);
+        return ids.map(idToUid);
+    }
+    async close() {
+        // No persistent connection to close
+    }
+    /** Map folder path to Gmail label query term */
+    folderToLabel(path) {
+        const lower = path.toLowerCase();
+        if (lower === "inbox")
+            return "inbox";
+        if (lower === "sent" || lower === "[gmail]/sent mail")
+            return "sent";
+        if (lower === "drafts" || lower === "[gmail]/drafts")
+            return "drafts";
+        if (lower === "trash" || lower === "[gmail]/trash")
+            return "trash";
+        if (lower === "spam" || lower === "[gmail]/spam" || lower === "junk email")
+            return "spam";
+        if (lower === "archive" || lower === "[gmail]/all mail")
+            return "all";
+        // Custom label — use exact name
+        return `"${path}"`;
+    }
+    /** Format date for Gmail query (YYYY/MM/DD) */
+    formatDate(d) {
+        return `${d.getFullYear()}/${String(d.getMonth() + 1).padStart(2, "0")}/${String(d.getDate()).padStart(2, "0")}`;
+    }
+}
+//# sourceMappingURL=gmail-api.js.map