@bobfrankston/mailx 1.0.55 → 1.0.61

package/packages/mailx-api/package.json

@@ -13,9 +13,8 @@
     "@bobfrankston/mailx-store": "file:../mailx-store",
     "@bobfrankston/mailx-imap": "file:../mailx-imap",
     "@bobfrankston/mailx-settings": "file:../mailx-settings",
-    "express": "^4.21.0",
-    "mailparser": "^3.7.2",
-    "nodemailer": "^7.0.0"
+    "@bobfrankston/mailx-service": "file:../mailx-service",
+    "express": "^4.21.0"
   },
   "devDependencies": {
     "@types/express": "^5.0.0",

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

@@ -0,0 +1,60 @@
+/**
+ * @bobfrankston/mailx-service
+ * Pure business logic — no HTTP, no Express.
+ * Both the Express API (mailx-api) and the Android bridge call these functions.
+ */
+import { MailxDB } from "@bobfrankston/mailx-store";
+import { ImapManager } from "@bobfrankston/mailx-imap";
+import type { Folder } from "@bobfrankston/mailx-types";
+export declare function sanitizeHtml(html: string): {
+    html: string;
+    hasRemoteContent: boolean;
+};
+export declare class MailxService {
+    private db;
+    private imapManager;
+    constructor(db: MailxDB, imapManager: ImapManager);
+    getAccounts(): any[];
+    getFolders(accountId: string): Folder[];
+    getUnifiedInbox(page?: number, pageSize?: number): any;
+    getMessages(accountId: string, folderId: number, page?: number, pageSize?: number, sort?: string, sortDir?: string, search?: string): any;
+    getMessage(accountId: string, uid: number, allowRemote?: boolean, folderId?: number): Promise<any>;
+    updateFlags(accountId: string, uid: number, flags: string[]): Promise<void>;
+    allowRemoteContent(type: "sender" | "domain" | "recipient", value: string): void;
+    search(q: string, page?: number, pageSize?: number, scope?: string, accountId?: string, folderId?: number): Promise<any>;
+    rebuildSearchIndex(): number;
+    getSyncPending(): {
+        pending: number;
+    };
+    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>;
+    undeleteMessage(accountId: string, uid: number, folderId: number): Promise<void>;
+    deleteOnServer(accountId: string, folderPath: string, uid: number): Promise<void>;
+    createFolder(accountId: string, parentPath: string, name: string): Promise<void>;
+    renameFolder(accountId: string, folderId: number, newName: string): Promise<void>;
+    deleteFolder(accountId: string, folderId: number): Promise<void>;
+    markFolderRead(folderId: number): void;
+    emptyFolder(accountId: string, folderId: number): Promise<void>;
+    getAttachment(accountId: string, uid: number, attachmentId: number, folderId?: number): Promise<{
+        content: Buffer;
+        contentType: string;
+        filename: string;
+    }>;
+    saveDraft(accountId: string, subject: string, bodyHtml: string, bodyText: string, to?: string, cc?: string, previousDraftUid?: number): Promise<number | null>;
+    deleteDraft(accountId: string, draftUid: number): Promise<void>;
+    searchContacts(query: string): any[];
+    syncGoogleContacts(): Promise<void>;
+    seedContacts(): number;
+    getSettings(): any;
+    saveSettings(settings: any): void;
+    getStorageInfo(): {
+        provider: string;
+        mode: string;
+    };
+}
+//# sourceMappingURL=index.d.ts.map