@bobfrankston/mailx 1.0.298 → 1.0.300

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.298",
+  "version": "1.0.300",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",

package/packages/mailx-imap/index.js

@@ -468,7 +468,7 @@ export class ImapManager extends EventEmitter {
                 // a hung OAuth server could block the entire sync thread indefinitely.
                 const TOKEN_FETCH_TIMEOUT_MS = 30000;
                 const authPromise = authenticateOAuth(credPath, {
-                    scope: "https://mail.google.com/ https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/calendar",
+                    scope: "https://mail.google.com/ https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/drive",
                     tokenDirectory: tokenDir,
                     credentialsKey: "installed",
                     loginHint: account.imap.user,
@@ -1060,8 +1060,20 @@ export class ImapManager extends EventEmitter {
         console.log(`  [api] ${accountId}/${folder.path}: syncing (highestUid=${highestUid})...`);
         let messages;
         if (highestUid > 0) {
-            // Incremental: fetch messages since last known UID
+            // Incremental: fetch messages since last known UID.
+            // Gmail "UIDs" are hashed (not chronological), so fetchSince
+            // returns messages in hash order — they can be from ANY date.
+            // Filter by the history window so years-old messages don't
+            // suddenly flood the inbox on every incremental sync.
             messages = await api.fetchSince(folder.path, highestUid, { source: false });
+            if (effectiveDays > 0) {
+                const cutoff = startDate.getTime();
+                const before = messages.length;
+                messages = messages.filter(m => !m.date || m.date.getTime() >= cutoff);
+                if (messages.length < before) {
+                    console.log(`  [api] ${accountId}/${folder.path}: filtered ${before - messages.length} messages older than ${effectiveDays}d`);
+                }
+            }
         }
         else {
             // First sync: fetch by date range

package/packages/mailx-settings/cloud.js

@@ -59,30 +59,69 @@ const GDRIVE_SCOPES = "https://www.googleapis.com/auth/drive";
  *  is the auto-created default. First one that exists on GDrive wins. */
 const GDRIVE_PATH_SEARCH_ORDER = ["home/.mailx", "mailx"];
 // ── Token helpers ──
+/** Get a GDrive-capable token. Prefers the Gmail token (which now includes
+ *  drive scope) — avoids a second OAuth consent prompt. Falls back to the
+ *  dedicated GDrive token dir for non-Gmail setups or when Gmail token
+ *  doesn't have drive scope yet. */
 async function getGoogleDriveToken() {
+    // Strategy 1: reuse a Gmail token that already has drive scope.
+    // Scan the tokens/ dir for any account token with drive in its scope.
+    const tokensDir = path.join(SETTINGS_DIR, "tokens");
+    if (fs.existsSync(tokensDir)) {
+        try {
+            for (const entry of fs.readdirSync(tokensDir)) {
+                if (entry === "gdrive")
+                    continue;
+                const tokenPath = path.join(tokensDir, entry, "oauth-token.json");
+                if (!fs.existsSync(tokenPath))
+                    continue;
+                try {
+                    const tok = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
+                    if (tok.scope?.includes("drive") && tok.refresh_token) {
+                        console.log(`  [cloud] Reusing Gmail token from ${entry} (has drive scope)`);
+                        const creds = findGoogleCredentials();
+                        if (!creds)
+                            continue;
+                        const refreshed = await authenticateOAuth(creds, {
+                            scope: tok.scope,
+                            tokenDirectory: path.join(tokensDir, entry),
+                            tokenFileName: "oauth-token.json",
+                            credentialsKey: "installed",
+                            includeOfflineAccess: true,
+                        });
+                        if (refreshed?.access_token) {
+                            console.log(`  [cloud] GDrive auth: success (via Gmail token)`);
+                            return refreshed.access_token;
+                        }
+                    }
+                }
+                catch { /* skip this token */ }
+            }
+        }
+        catch { /* tokens dir unreadable */ }
+    }
+    // Strategy 2: dedicated GDrive token (legacy path or non-Gmail setups)
     const creds = findGoogleCredentials();
     if (!creds) {
         console.error("  [cloud] No Google credentials found (checked ~/.mailx/google-credentials.json and iflow package)");
         return null;
     }
     const tokenPath = path.join(GDRIVE_TOKEN_DIR, "token.json");
-    // Log token state so failures are diagnosable
     if (fs.existsSync(tokenPath)) {
         try {
             const existing = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
             const expired = existing.expires_at ? Date.now() >= existing.expires_at : true;
             const hasRefresh = !!existing.refresh_token;
-            console.log(`  [cloud] GDrive token: ${expired ? "expired" : "valid"}, refresh_token: ${hasRefresh ? "yes" : "NO"}, scope: ${existing.scope || "?"}`);
-            // Delete stale token if scope changed (drive → drive.file or vice versa)
+            console.log(`  [cloud] GDrive token (dedicated): ${expired ? "expired" : "valid"}, refresh_token: ${hasRefresh ? "yes" : "NO"}, scope: ${existing.scope || "?"}`);
             if (existing.scope && existing.scope !== GDRIVE_SCOPES) {
                 console.log(`  [cloud] Scope changed (${existing.scope} → ${GDRIVE_SCOPES}) — re-authenticating...`);
                 fs.unlinkSync(tokenPath);
             }
         }
-        catch { /* ignore parse errors */ }
+        catch { /* ignore */ }
     }
     else {
-        console.log(`  [cloud] GDrive token: not found at ${tokenPath}`);
+        console.log(`  [cloud] GDrive token: not found at ${tokenPath} (will auth)`);
     }
     try {
         const token = await authenticateOAuth(creds, {
@@ -93,10 +132,10 @@ async function getGoogleDriveToken() {
             includeOfflineAccess: true,
         });
         if (token?.access_token) {
-            console.log(`  [cloud] GDrive auth: success (token refreshed/valid)`);
+            console.log(`  [cloud] GDrive auth: success (dedicated token)`);
         }
         else {
-            console.error(`  [cloud] GDrive auth: returned null — OAuth callback likely timed out or was denied`);
+            console.error(`  [cloud] GDrive auth: returned null — OAuth likely timed out`);
         }
         return token?.access_token || null;
     }