@bobfrankston/mailx 1.0.50 → 1.0.57

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

@@ -49,6 +49,10 @@ export declare class ImapManager extends EventEmitter {
     private _syncAll;
     /** Sync just INBOX for each account (fast check for new mail) */
     syncInbox(): Promise<void>;
+    /** Quick inbox check — uses IMAP STATUS (single command, no mailbox open).
+     *  If message count changed, triggers a full inbox sync. */
+    private lastInboxCounts;
+    quickInboxCheck(): Promise<void>;
     /** Start periodic sync */
     startPeriodicSync(intervalMinutes: number): void;
     /** Stop periodic sync */

package/packages/mailx-imap/index.js

@@ -170,6 +170,7 @@ export class ImapManager extends EventEmitter {
         // Get the highest UID we already have for this folder
         const highestUid = this.db.getHighestUid(accountId, folderId);
         let messages;
+        const firstSync = highestUid === 0;
         if (highestUid > 0) {
             // Incremental: only fetch messages newer than what we have
             const fetched = await client.fetchMessagesSinceUid(folder.path, highestUid, { source: true });
@@ -184,18 +185,47 @@ export class ImapManager extends EventEmitter {
                 ? new Date(Date.now() - historyDays * 86400000)
                 : new Date(0);
             messages = await client.fetchMessageByDate(folder.path, startDate, new Date(), { source: true });
+            // Sort newest first so most recent messages appear in the UI immediately
+            messages.sort((a, b) => {
+                const da = a.date instanceof Date ? a.date.getTime() : (typeof a.date === "number" ? a.date : 0);
+                const db = b.date instanceof Date ? b.date.getTime() : (typeof b.date === "number" ? b.date : 0);
+                return db - da;
+            });
         }
         if (messages.length > 0)
             console.log(`  ${folder.path}: ${messages.length} new messages`);
         let newCount = 0;
         const batchSize = 50;
-        this.db.beginTransaction();
-        try {
-            for (let i = 0; i < messages.length; i++) {
-                const msg = messages[i];
-                // Skip if we already have this UID
-                if (msg.uid <= highestUid) {
-                    // But update flags in case they changed
+        for (let batchStart = 0; batchStart < messages.length; batchStart += batchSize) {
+            const batchEnd = Math.min(batchStart + batchSize, messages.length);
+            this.db.beginTransaction();
+            try {
+                for (let i = batchStart; i < batchEnd; i++) {
+                    const msg = messages[i];
+                    // Skip if we already have this UID
+                    if (msg.uid <= highestUid) {
+                        // But update flags in case they changed
+                        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.updateMessageFlags(accountId, msg.uid, flags);
+                        continue;
+                    }
+                    // Store body
+                    const source = msg.source || "";
+                    let bodyPath = "";
+                    if (source) {
+                        bodyPath = await this.bodyStore.putMessage(accountId, folderId, msg.uid, Buffer.from(source, "utf-8"));
+                    }
+                    // Parse for preview and attachment info
+                    const parsed = await extractPreview(source);
+                    // Build flags array
                     const flags = [];
                     if (msg.seen)
                         flags.push("\\Seen");
@@ -205,61 +235,49 @@ export class ImapManager extends EventEmitter {
                         flags.push("\\Answered");
                     if (msg.draft)
                         flags.push("\\Draft");
-                    this.db.updateMessageFlags(accountId, msg.uid, flags);
-                    continue;
-                }
-                // Store body
-                const source = msg.source || "";
-                let bodyPath = "";
-                if (source) {
-                    bodyPath = await this.bodyStore.putMessage(accountId, folderId, msg.uid, Buffer.from(source, "utf-8"));
+                    // Store metadata
+                    this.db.upsertMessage({
+                        accountId,
+                        folderId,
+                        uid: msg.uid,
+                        messageId: msg.messageId || "",
+                        inReplyTo: "",
+                        references: [],
+                        date: msg.date instanceof Date ? msg.date.getTime() : (typeof msg.date === "number" ? msg.date : Date.now()),
+                        subject: msg.subject || "",
+                        from: toEmailAddress(msg.from?.[0] || {}),
+                        to: toEmailAddresses(msg.to || []),
+                        cc: toEmailAddresses(msg.cc || []),
+                        flags,
+                        size: msg.size || 0,
+                        hasAttachments: parsed.hasAttachments,
+                        preview: parsed.preview,
+                        bodyPath
+                    });
+                    newCount++;
                 }
-                // Parse for preview and attachment info
-                const parsed = await extractPreview(source);
-                // Build flags array
-                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");
-                // Store metadata
-                this.db.upsertMessage({
-                    accountId,
-                    folderId,
-                    uid: msg.uid,
-                    messageId: msg.messageId || "",
-                    inReplyTo: "",
-                    references: [],
-                    date: msg.date instanceof Date ? msg.date.getTime() : (typeof msg.date === "number" ? msg.date : Date.now()),
-                    subject: msg.subject || "",
-                    from: toEmailAddress(msg.from?.[0] || {}),
-                    to: toEmailAddresses(msg.to || []),
-                    cc: toEmailAddresses(msg.cc || []),
-                    flags,
-                    size: msg.size || 0,
-                    hasAttachments: parsed.hasAttachments,
-                    preview: parsed.preview,
-                    bodyPath
+                this.db.commitTransaction();
+            }
+            catch (e) {
+                console.error(`    transaction error: ${e.message}`);
+                this.db.rollbackTransaction();
+                throw e;
+            }
+            // Emit progress and notify client after each batch
+            this.emit("syncProgress", accountId, `sync:${folder.path}`, Math.round((batchEnd / messages.length) * 100));
+            // On first sync, emit folderCountsChanged per batch so newest messages appear immediately
+            if (firstSync && newCount > 0) {
+                const total = newCount;
+                const unread = this.db.getMessages({ accountId, folderId, page: 1, pageSize: total })
+                    .items.filter((m) => !m.flags.includes("\\Seen")).length;
+                this.db.updateFolderCounts(folderId, total, unread);
+                this.emit("folderCountsChanged", accountId, {
+                    [folderId]: { total, unread }
                 });
-                newCount++;
-                // Emit progress periodically
-                if (i % batchSize === 0) {
-                    this.emit("syncProgress", accountId, `sync:${folder.path}`, Math.round((i / messages.length) * 100));
-                }
             }
-            this.db.commitTransaction();
-            if (newCount > 0)
-                console.log(`    stored ${newCount} new messages`);
-        }
-        catch (e) {
-            console.error(`    transaction error: ${e.message}`);
-            this.db.rollbackTransaction();
-            throw e;
         }
+        if (newCount > 0)
+            console.log(`    stored ${newCount} new messages`);
         // Remove messages deleted on the server
         let deletedCount = 0;
         try {
@@ -308,10 +326,12 @@ export class ImapManager extends EventEmitter {
         }
     }
     async _syncAll() {
+        // Phase 1: Sync folder lists and inboxes for ALL accounts first
+        // so every account has content visible quickly
+        const accountFolders = new Map();
         for (const [accountId] of this.configs) {
             let client = null;
             try {
-                // Fresh client for folder list (30s timeout)
                 client = this.createClient(accountId);
                 const folders = await Promise.race([
                     this.syncFolders(accountId, client),
@@ -319,20 +339,14 @@ export class ImapManager extends EventEmitter {
                 ]);
                 await client.logout();
                 client = null;
-                // INBOX first so it's available fastest
-                folders.sort((a, b) => {
-                    if (a.specialUse === "inbox")
-                        return -1;
-                    if (b.specialUse === "inbox")
-                        return 1;
-                    return 0;
-                });
-                // Fresh client per folder with 60s timeout — IMAP connections can hang
-                for (const folder of folders) {
+                accountFolders.set(accountId, folders);
+                // Sync inbox immediately
+                const inbox = folders.find(f => f.specialUse === "inbox");
+                if (inbox) {
                     try {
                         client = this.createClient(accountId);
                         await Promise.race([
-                            this.syncFolder(accountId, folder.id, client),
+                            this.syncFolder(accountId, inbox.id, client),
                             new Promise((_, reject) => setTimeout(() => reject(new Error("Sync timeout (60s)")), 60000))
                         ]);
                         await client.logout();
@@ -346,16 +360,9 @@ export class ImapManager extends EventEmitter {
                             catch { /* ignore */ }
                             client = null;
                         }
-                        if (e.responseText?.includes("doesn't exist")) {
-                            console.log(`  Removing non-existent folder: ${folder.path}`);
-                            this.db.deleteFolder(folder.id);
-                        }
-                        else {
-                            console.error(`  Skipping folder ${folder.path}: ${e.message}`);
-                        }
+                        console.error(`  Inbox sync error for ${accountId}: ${e.message}`);
                     }
                 }
-                this.emit("syncComplete", accountId);
             }
             catch (e) {
                 this.emit("syncError", accountId, e.message);
@@ -369,6 +376,40 @@ export class ImapManager extends EventEmitter {
                     catch { /* ignore */ }
             }
         }
+        // Phase 2: Sync remaining folders for all accounts
+        for (const [accountId, folders] of accountFolders) {
+            let client = null;
+            for (const folder of folders) {
+                if (folder.specialUse === "inbox")
+                    continue; // already synced
+                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))
+                    ]);
+                    await client.logout();
+                    client = null;
+                }
+                catch (e) {
+                    if (client) {
+                        try {
+                            await client.logout();
+                        }
+                        catch { /* ignore */ }
+                        client = null;
+                    }
+                    if (e.responseText?.includes("doesn't exist")) {
+                        console.log(`  Removing non-existent folder: ${folder.path}`);
+                        this.db.deleteFolder(folder.id);
+                    }
+                    else {
+                        console.error(`  Skipping folder ${folder.path}: ${e.message}`);
+                    }
+                }
+            }
+            this.emit("syncComplete", accountId);
+        }
     }
     /** Sync just INBOX for each account (fast check for new mail) */
     async syncInbox() {
@@ -419,19 +460,59 @@ export class ImapManager extends EventEmitter {
             this.inboxSyncing = false;
         }
     }
+    /** Quick inbox check — uses IMAP STATUS (single command, no mailbox open).
+     *  If message count changed, triggers a full inbox sync. */
+    lastInboxCounts = new Map();
+    async quickInboxCheck() {
+        for (const [accountId] of this.configs) {
+            let client = null;
+            try {
+                const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
+                if (!inbox)
+                    continue;
+                client = this.createClient(accountId);
+                const count = await client.getMessagesCount("INBOX");
+                await client.logout();
+                client = null;
+                const prev = this.lastInboxCounts.get(accountId) ?? count;
+                this.lastInboxCounts.set(accountId, count);
+                if (count !== prev) {
+                    console.log(`  [check] ${accountId} INBOX: ${prev} → ${count}`);
+                    // New mail detected — do a full inbox sync
+                    client = this.createClient(accountId);
+                    await this.syncFolder(accountId, inbox.id, client);
+                    await client.logout();
+                    client = null;
+                }
+            }
+            catch {
+                // Lightweight check — silently ignore errors (full sync will catch up)
+            }
+            finally {
+                if (client)
+                    try {
+                        await client.logout();
+                    }
+                    catch { /* ignore */ }
+            }
+        }
+    }
     /** Start periodic sync */
     startPeriodicSync(intervalMinutes) {
         this.stopPeriodicSync();
-        // INBOX poll + sync actions (IDLE handles instant, this catches gaps)
-        const inboxInterval = setInterval(async () => {
-            // Process pending local→IMAP sync actions (sends + flags/deletes/moves)
+        // Quick inbox check every 3 seconds — lightweight STATUS command
+        const quickCheck = setInterval(() => {
+            this.quickInboxCheck().catch(() => { });
+        }, 3000);
+        this.syncIntervals.set("quick", quickCheck);
+        // Sync actions (sends + flags/deletes/moves) every 30 seconds
+        const actionsInterval = setInterval(async () => {
             for (const [accountId] of this.configs) {
                 this.processSendActions(accountId).catch(() => { });
                 this.processSyncActions(accountId).catch(() => { });
             }
-            this.syncInbox().catch(e => console.error(`  [inbox] error: ${e.message}`));
         }, 30000);
-        this.syncIntervals.set("inbox", inboxInterval);
+        this.syncIntervals.set("actions", actionsInterval);
         // Full sync (all folders + IDLE restart) at configured interval
         const fullInterval = setInterval(async () => {
             console.log(`  [periodic] Full sync at ${new Date().toLocaleTimeString()}`);

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

@@ -0,0 +1,58 @@
+/**
+ * @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>;
+    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