@bobfrankston/mailx 1.0.57 → 1.0.61

package/client/app.js

@@ -561,6 +561,44 @@ onWsEvent((event) => {
                 statusSync.textContent = `Error: ${event.message}`;
             showAlert(event.message, "ws-error");
             break;
+        case "accountError": {
+            const acctEl = document.getElementById("status-accounts");
+            if (acctEl) {
+                acctEl.innerHTML = "";
+                acctEl.style.color = "oklch(0.65 0.2 25)";
+                const text = document.createElement("span");
+                text.textContent = `${event.accountId}: ${event.hint} `;
+                acctEl.appendChild(text);
+                // Add re-auth button for auth errors
+                if (event.error.includes("token") || event.error.includes("auth") || event.error.includes("Command failed")) {
+                    const btn = document.createElement("button");
+                    btn.textContent = "Re-authenticate";
+                    btn.className = "status-action";
+                    btn.addEventListener("click", async () => {
+                        btn.disabled = true;
+                        btn.textContent = "Authenticating...";
+                        try {
+                            const res = await fetch(`/api/reauth/${event.accountId}`, { method: "POST" });
+                            const data = await res.json();
+                            if (data.ok) {
+                                acctEl.textContent = `${event.accountId}: reconnected`;
+                                acctEl.style.color = "";
+                            }
+                            else {
+                                btn.textContent = "Re-authenticate";
+                                btn.disabled = false;
+                            }
+                        }
+                        catch {
+                            btn.textContent = "Re-authenticate";
+                            btn.disabled = false;
+                        }
+                    });
+                    acctEl.appendChild(btn);
+                }
+            }
+            break;
+        }
     }
 });
 // ── Keyboard shortcuts ──

package/client/styles/components.css

@@ -564,6 +564,18 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
     font-size: var(--font-size-sm);
     color: var(--color-text-muted);
 }
+.status-action {
+    border: 1px solid oklch(0.65 0.15 25);
+    background: transparent;
+    color: oklch(0.75 0.15 25);
+    padding: 1px 8px;
+    border-radius: var(--radius-sm);
+    font-size: var(--font-size-sm);
+    cursor: pointer;
+    margin-left: var(--gap-xs);
+}
+.status-action:hover { background: oklch(0.65 0.15 25); color: #fff; }
+.status-action:disabled { opacity: 0.5; cursor: default; }
 
 /* ── Startup Overlay ── */
 

package/package.json

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

package/packages/mailx-api/index.js

@@ -75,6 +75,15 @@ export function createApiRouter(db, imapManager) {
             res.status(500).json({ error: e.message });
         }
     });
+    router.post("/reauth/:accountId", async (req, res) => {
+        try {
+            const ok = await svc.reauthenticate(req.params.accountId);
+            res.json({ ok });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
     // ── Send ──
     router.post("/send", async (req, res) => {
         try {

package/packages/mailx-imap/index.d.ts

@@ -30,6 +30,8 @@ export declare class ImapManager extends EventEmitter {
     constructor(db: MailxDB);
     /** Get OAuth access token for an account (for SMTP auth) */
     getOAuthToken(accountId: string): Promise<string | null>;
+    /** Force re-authentication for an OAuth account — deletes cached token, triggers browser consent */
+    reauthenticate(accountId: string): Promise<boolean>;
     /** Delete a message directly on the IMAP server (for stuck outbox messages not in local DB) */
     deleteOnServer(accountId: string, folderPath: string, uid: number): Promise<void>;
     /** Search messages on the IMAP server — returns matching UIDs */
@@ -103,6 +105,7 @@ export declare class ImapManager extends EventEmitter {
     /** Process Outbox — send pending messages with flag-based interlock */
     processOutbox(accountId: string): Promise<void>;
     /** Start background Outbox worker — runs immediately then every 10 seconds */
+    private outboxBackoff;
     startOutboxWorker(): void;
     /** Stop Outbox worker */
     stopOutboxWorker(): void;

package/packages/mailx-imap/index.js

@@ -72,6 +72,40 @@ export class ImapManager extends EventEmitter {
             return null;
         return config.tokenProvider();
     }
+    /** Force re-authentication for an OAuth account — deletes cached token, triggers browser consent */
+    async reauthenticate(accountId) {
+        const settings = loadSettings();
+        const account = settings.accounts.find(a => a.id === accountId);
+        if (!account)
+            return false;
+        // Delete cached tokens
+        const accountDir = account.imap.user.replace(/[@.]/g, "_");
+        const tokenDir = path.join(getConfigDir(), "tokens", accountDir);
+        for (const f of ["token.json", "contacts-token.json"]) {
+            const p = path.join(tokenDir, f);
+            if (fs.existsSync(p)) {
+                fs.unlinkSync(p);
+                console.log(`  [reauth] Deleted ${p}`);
+            }
+        }
+        // Re-register the account to get a fresh config with new tokenProvider
+        this.configs.delete(accountId);
+        await this.addAccount(account);
+        // Trigger the OAuth flow by requesting a token
+        try {
+            const token = await this.getOAuthToken(accountId);
+            if (token) {
+                console.log(`  [reauth] ${accountId}: success`);
+                // Trigger a sync now that auth works
+                this.syncInbox().catch(() => { });
+                return true;
+            }
+        }
+        catch (e) {
+            console.error(`  [reauth] ${accountId}: ${e.message}`);
+        }
+        return false;
+    }
     /** Delete a message directly on the IMAP server (for stuck outbox messages not in local DB) */
     async deleteOnServer(accountId, folderPath, uid) {
         const client = this.createClient(accountId);
@@ -126,6 +160,17 @@ export class ImapManager extends EventEmitter {
         this.configs.set(account.id, config);
         // Register account in DB
         this.db.upsertAccount(account.id, account.name, account.email, JSON.stringify(account));
+        // Pre-validate OAuth token (so browser consent happens now, not during a timed sync)
+        if (config.tokenProvider) {
+            try {
+                await config.tokenProvider();
+                console.log(`  [auth] ${account.id}: token valid`);
+            }
+            catch (e) {
+                console.error(`  [auth] ${account.id}: ${e.message}`);
+                this.emit("accountError", account.id, e.message, "Re-authenticate: click the button below or run mailx -setup");
+            }
+        }
     }
     /** Sync folder list for an account */
     async syncFolders(accountId, client) {
@@ -278,24 +323,35 @@ export class ImapManager extends EventEmitter {
         }
         if (newCount > 0)
             console.log(`    stored ${newCount} new messages`);
-        // Remove messages deleted on the server
+        // Remove messages deleted on the server (skip on first sync — nothing to reconcile)
         let deletedCount = 0;
-        try {
-            const serverUids = new Set(await client.getUids(folder.path));
-            const localUids = this.db.getUidsForFolder(accountId, folderId);
-            for (const uid of localUids) {
-                if (!serverUids.has(uid)) {
-                    this.db.deleteMessage(accountId, uid);
-                    // Also remove cached body
-                    this.bodyStore.deleteMessage(accountId, folderId, uid).catch(() => { });
-                    deletedCount++;
+        if (!firstSync) {
+            let delClient = null;
+            try {
+                delClient = this.createClient(accountId);
+                const serverUids = new Set(await delClient.getUids(folder.path));
+                const localUids = this.db.getUidsForFolder(accountId, folderId);
+                for (const uid of localUids) {
+                    if (!serverUids.has(uid)) {
+                        this.db.deleteMessage(accountId, uid);
+                        this.bodyStore.deleteMessage(accountId, folderId, uid).catch(() => { });
+                        deletedCount++;
+                    }
                 }
+                if (deletedCount > 0)
+                    console.log(`    removed ${deletedCount} deleted messages`);
+                await delClient.logout();
+            }
+            catch (e) {
+                console.error(`    deletion sync error: ${e.message}`);
+            }
+            finally {
+                if (delClient)
+                    try {
+                        await delClient.logout();
+                    }
+                    catch { /* ignore */ }
             }
-            if (deletedCount > 0)
-                console.log(`    removed ${deletedCount} deleted messages`);
-        }
-        catch (e) {
-            console.error(`    deletion sync error: ${e.message}`);
         }
         // Update folder counts from local DB (after deletions + additions)
         const result = this.db.getMessages({ accountId, folderId, page: 1, pageSize: 1 });
@@ -367,6 +423,14 @@ export class ImapManager extends EventEmitter {
             catch (e) {
                 this.emit("syncError", accountId, e.message);
                 console.error(`Sync error for ${accountId}: ${e.message}`);
+                // Classify error and emit user-facing hint
+                const msg = e.message || "";
+                if (msg.includes("token") || msg.includes("auth") || msg.includes("Command failed")) {
+                    this.emit("accountError", accountId, msg, "Re-authenticate: mailx -setup or check credentials");
+                }
+                else if (msg.includes("timeout")) {
+                    this.emit("accountError", accountId, msg, "Server slow or unreachable — will retry");
+                }
             }
             finally {
                 if (client)
@@ -376,17 +440,32 @@ export class ImapManager extends EventEmitter {
                     catch { /* ignore */ }
             }
         }
-        // Phase 2: Sync remaining folders for all accounts
+        // Phase 2: Sync remaining folders — priority order, skip Trash subfolders on first sync
+        const priorityOrder = ["sent", "drafts", "archive", "junk", "trash"];
         for (const [accountId, folders] of accountFolders) {
+            // Sort: sent/drafts first, then regular, then trash subfolders last
+            const remaining = folders.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;
+            });
             let client = null;
-            for (const folder of folders) {
-                if (folder.specialUse === "inbox")
-                    continue; // already synced
+            for (const folder of remaining) {
+                // Skip Trash subfolders on first sync — they're large and low priority
+                const isTrashChild = folder.path.includes("/") && folder.path.toLowerCase().startsWith("trash");
+                const highestUid = this.db.getHighestUid(accountId, folder.id);
+                if (isTrashChild && highestUid === 0) {
+                    console.log(`  Deferring first sync of ${folder.path} (Trash subfolder)`);
+                    continue;
+                }
+                // Longer timeout for folders we know are large (Trash, first sync)
+                const timeout = highestUid === 0 ? 180000 : 60000;
                 try {
                     client = this.createClient(accountId);
                     await Promise.race([
                         this.syncFolder(accountId, folder.id, client),
-                        new Promise((_, reject) => setTimeout(() => reject(new Error("Sync timeout (60s)")), 60000))
+                        new Promise((_, reject) => setTimeout(() => reject(new Error(`Sync timeout (${timeout / 1000}s)`)), timeout))
                     ]);
                     await client.logout();
                     client = null;
@@ -1054,35 +1133,33 @@ export class ImapManager extends EventEmitter {
         }
     }
     /** Start background Outbox worker — runs immediately then every 10 seconds */
+    outboxBackoff = new Map(); // accountId → next retry time
     startOutboxWorker() {
         if (this.outboxInterval)
             return;
-        // Run once immediately on startup
         const processAll = async () => {
+            const now = Date.now();
             for (const [accountId] of this.configs) {
+                // Skip accounts in backoff
+                const retryAfter = this.outboxBackoff.get(accountId) || 0;
+                if (now < retryAfter)
+                    continue;
                 try {
                     await this.processLocalQueue(accountId);
                     await this.processOutbox(accountId);
+                    this.outboxBackoff.delete(accountId); // success — clear backoff
                 }
                 catch (e) {
-                    console.error(`  [outbox] Error for ${accountId}: ${e.message}`);
+                    // Exponential backoff: 30s, 60s, 120s, max 5min
+                    const prev = this.outboxBackoff.get(accountId);
+                    const delay = prev ? Math.min((now - prev + 30000) * 2, 300000) : 30000;
+                    this.outboxBackoff.set(accountId, now + delay);
+                    console.error(`  [outbox] Error for ${accountId}: ${e.message} (retry in ${Math.round(delay / 1000)}s)`);
                 }
             }
         };
-        setTimeout(() => processAll(), 3000); // 3s after startup (let connections settle)
-        this.outboxInterval = setInterval(async () => {
-            for (const [accountId] of this.configs) {
-                try {
-                    // First move any local queued messages to IMAP
-                    await this.processLocalQueue(accountId);
-                    // Then process IMAP Outbox
-                    await this.processOutbox(accountId);
-                }
-                catch (e) {
-                    console.error(`  [outbox] Error for ${accountId}: ${e.message}`);
-                }
-            }
-        }, 10000);
+        setTimeout(() => processAll(), 3000);
+        this.outboxInterval = setInterval(processAll, 10000);
     }
     /** Stop Outbox worker */
     stopOutboxWorker() {

package/packages/mailx-server/index.js

@@ -199,6 +199,9 @@ imapManager.on("folderCountsChanged", (accountId, counts) => {
 imapManager.on("syncError", (accountId, error) => {
     broadcast({ type: "error", message: `${accountId}: ${error}` });
 });
+imapManager.on("accountError", (accountId, error, hint) => {
+    broadcast({ type: "accountError", accountId, error, hint });
+});
 // ── Startup ──
 async function start() {
     console.log("mailx server starting...");

package/packages/mailx-service/index.d.ts

@@ -28,6 +28,8 @@ export declare class MailxService {
     };
     syncAll(): Promise<void>;
     syncAccount(accountId: string): Promise<void>;
+    /** Force re-authentication for an account (deletes token, opens browser consent) */
+    reauthenticate(accountId: string): Promise<boolean>;
     send(msg: any): Promise<void>;
     deleteMessage(accountId: string, uid: number): Promise<void>;
     moveMessage(accountId: string, uid: number, targetFolderId: number, targetAccountId?: string): Promise<void>;

package/packages/mailx-service/index.js

@@ -257,6 +257,10 @@ export class MailxService {
             }
         }
     }
+    /** Force re-authentication for an account (deletes token, opens browser consent) */
+    async reauthenticate(accountId) {
+        return this.imapManager.reauthenticate(accountId);
+    }
     // ── Send ──
     async send(msg) {
         const settings = loadSettings();

package/packages/mailx-types/index.d.ts

@@ -172,6 +172,11 @@ export type WsEvent = {
 } | {
     type: "error";
     message: string;
+} | {
+    type: "accountError";
+    accountId: string;
+    error: string;
+    hint: string;
 };
 export interface MailxSettings {
     accounts: AccountConfig[];