@bobfrankston/mailx 1.0.265 → 1.0.278

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.265",
+  "version": "1.0.278",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,11 +20,11 @@
     "postinstall": "node bin/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow-direct": "^0.1.20",
-    "@bobfrankston/iflow-node": "^0.1.5",
+    "@bobfrankston/iflow-direct": "^0.1.22",
+    "@bobfrankston/iflow-node": "^0.1.6",
     "@bobfrankston/miscinfo": "^1.0.8",
     "@bobfrankston/oauthsupport": "^1.0.24",
-    "@bobfrankston/msger": "^0.1.318",
+    "@bobfrankston/msger": "^0.1.320",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -35,10 +35,10 @@
     "quill": "^2.0.3",
     "ws": "^8.18.0",
     "sql.js": "^1.14.1",
-    "@bobfrankston/tcp-transport": "^0.1.3",
-    "@bobfrankston/node-tcp-transport": "^0.1.1",
-    "@bobfrankston/smtp-direct": "^0.1.2",
-    "@bobfrankston/mailx-sync": "^0.1.4"
+    "@bobfrankston/tcp-transport": "^0.1.4",
+    "@bobfrankston/node-tcp-transport": "^0.1.3",
+    "@bobfrankston/smtp-direct": "^0.1.3",
+    "@bobfrankston/mailx-sync": "^0.1.6"
   },
   "devDependencies": {
     "@types/mailparser": "^3.4.6"
@@ -82,11 +82,11 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/iflow-direct": "^0.1.20",
-      "@bobfrankston/iflow-node": "^0.1.5",
+      "@bobfrankston/iflow-direct": "^0.1.22",
+      "@bobfrankston/iflow-node": "^0.1.6",
       "@bobfrankston/miscinfo": "^1.0.8",
       "@bobfrankston/oauthsupport": "^1.0.24",
-      "@bobfrankston/msger": "^0.1.318",
+      "@bobfrankston/msger": "^0.1.320",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",
       "@capacitor/core": "^8.3.0",
@@ -97,10 +97,10 @@
       "quill": "^2.0.3",
       "ws": "^8.18.0",
       "sql.js": "^1.14.1",
-      "@bobfrankston/tcp-transport": "^0.1.3",
-      "@bobfrankston/node-tcp-transport": "^0.1.1",
-      "@bobfrankston/smtp-direct": "^0.1.2",
-      "@bobfrankston/mailx-sync": "^0.1.4"
+      "@bobfrankston/tcp-transport": "^0.1.4",
+      "@bobfrankston/node-tcp-transport": "^0.1.3",
+      "@bobfrankston/smtp-direct": "^0.1.3",
+      "@bobfrankston/mailx-sync": "^0.1.6"
     }
   }
 }

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

@@ -28,6 +28,7 @@ export declare function getMessages(params: {
     sort?: string;
     sortDir?: string;
     search?: string;
+    flaggedOnly?: boolean;
 }): import("@bobfrankston/mailx-types").PagedResult<import("@bobfrankston/mailx-types").MessageEnvelope>;
 export declare function getUnifiedInbox(params: {
     page?: number;

package/packages/mailx-core/index.js

@@ -122,6 +122,7 @@ export function getMessages(params) {
         sort: params.sort || "date",
         sortDir: params.sortDir || "desc",
         search: params.search,
+        flaggedOnly: params.flaggedOnly,
     });
 }
 export function getUnifiedInbox(params) {

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

@@ -19,6 +19,9 @@ export interface ImapManagerEvents {
     }>) => void;
     accountError: (accountId: string, error: string, hint: string, isOAuth: boolean) => void;
     configChanged: (filename: string) => void;
+    /** Fired after a message body has been written to the local store — lets
+     *  the UI flip a row's "not-downloaded" indicator without re-rendering. */
+    bodyCached: (accountId: string, uid: number) => void;
 }
 export declare class ImapManager extends EventEmitter {
     private configs;
@@ -55,13 +58,31 @@ export declare class ImapManager extends EventEmitter {
     private opsClients;
     /** Operation queues — ensures sequential access per account */
     private opsQueues;
+    /** Persistent body-fetch connections — separate from ops so on-demand
+     *  body reads never queue behind a slow sync operation (bobma's IMAP
+     *  SEARCH can sit idle for 300s during backfill). */
+    private bodyClients;
+    /** Per-account backoff after the IMAP server rejected a connection with
+     *  the per-user+IP cap (Dovecot mail_max_userip_connections). Subsequent
+     *  body fetches short-circuit until the timestamp passes. */
+    private bodyBackoff;
     /** Get (or create) the persistent operational connection for an account.
      *  logout() is wrapped as a no-op so legacy callers don't close it. */
     private getOpsClient;
     /** Run an operation on the account's connection — queued, sequential, no concurrency */
     withConnection<T>(accountId: string, fn: (client: any) => Promise<T>): Promise<T>;
-    /** Create a new IMAP client (internal — callers use getOpsClient or withConnection) */
+    /** Open IMAP clients per account, used to trace who's opening sockets
+     *  when we hit the Dovecot per-user+IP connection cap. */
+    private openClients;
+    /** Create a new IMAP client (internal — callers use getOpsClient or withConnection).
+     *  `purpose` is a short tag printed alongside the `[conn+]` log so we can tell
+     *  which code path (sync/idle/body/outbox/move/…) opened each connection. */
     private newClient;
+    /** Get (or lazily create) the persistent body-fetch client. Separate from
+     *  the ops client so body reads never wait on a slow sync command. */
+    private getBodyClient;
+    /** Drop the body-fetch connection (e.g. after a socket error). */
+    private dropBodyClient;
     /** Disconnect the persistent operational connection for an account */
     disconnectOps(accountId: string): Promise<void>;
     /** Legacy API — callers that still create/destroy connections.

package/packages/mailx-imap/index.js

@@ -216,7 +216,7 @@ export class ImapManager extends EventEmitter {
     }
     /** 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);
+        const client = this.createClient(accountId, "delete-server");
         try {
             await client.deleteMessageByUid(folderPath, uid);
             console.log(`  Deleted UID ${uid} from ${folderPath} on server`);
@@ -256,19 +256,27 @@ export class ImapManager extends EventEmitter {
     opsClients = new Map();
     /** Operation queues — ensures sequential access per account */
     opsQueues = new Map();
+    /** Persistent body-fetch connections — separate from ops so on-demand
+     *  body reads never queue behind a slow sync operation (bobma's IMAP
+     *  SEARCH can sit idle for 300s during backfill). */
+    bodyClients = new Map();
+    /** Per-account backoff after the IMAP server rejected a connection with
+     *  the per-user+IP cap (Dovecot mail_max_userip_connections). Subsequent
+     *  body fetches short-circuit until the timestamp passes. */
+    bodyBackoff = new Map();
     /** Get (or create) the persistent operational connection for an account.
      *  logout() is wrapped as a no-op so legacy callers don't close it. */
     async getOpsClient(accountId) {
         let client = this.opsClients.get(accountId);
         if (client)
             return client;
-        client = this.newClient(accountId);
-        // Wrap logout as no-op — this is a persistent connection
+        client = this.newClient(accountId, "ops");
+        // Wrap logout as no-op — this is a persistent connection. The
+        // newClient wrapper's close-counter runs on `_realLogout`.
         const realLogout = client.logout.bind(client);
         client.logout = async () => { };
-        client._realLogout = realLogout; // stash for actual disconnect
+        client._realLogout = realLogout;
         this.opsClients.set(accountId, client);
-        console.log(`  [conn] ${accountId}: connected`);
         return client;
     }
     /** Run an operation on the account's connection — queued, sequential, no concurrency */
@@ -312,8 +320,13 @@ export class ImapManager extends EventEmitter {
         this.opsQueues.set(accountId, next.catch(() => { }));
         return next;
     }
-    /** Create a new IMAP client (internal — callers use getOpsClient or withConnection) */
-    newClient(accountId) {
+    /** Open IMAP clients per account, used to trace who's opening sockets
+     *  when we hit the Dovecot per-user+IP connection cap. */
+    openClients = new Map();
+    /** Create a new IMAP client (internal — callers use getOpsClient or withConnection).
+     *  `purpose` is a short tag printed alongside the `[conn+]` log so we can tell
+     *  which code path (sync/idle/body/outbox/move/…) opened each connection. */
+    newClient(accountId, purpose = "?") {
         if (this.reauthenticating.has(accountId))
             throw new Error(`Account ${accountId} is re-authenticating`);
         const backoffUntil = this.connectionBackoff.get(accountId);
@@ -323,7 +336,73 @@ export class ImapManager extends EventEmitter {
         const config = this.configs.get(accountId);
         if (!config)
             throw new Error(`No config for account ${accountId}`);
-        return new CompatImapClient(config, this.transportFactory);
+        const client = new CompatImapClient(config, this.transportFactory);
+        let open = this.openClients.get(accountId);
+        if (!open) {
+            open = new Set();
+            this.openClients.set(accountId, open);
+        }
+        open.add(client);
+        console.log(`  [conn+] ${accountId} (${purpose}) — ${open.size} open`);
+        let closed = false;
+        const markClosed = (how) => {
+            if (closed)
+                return;
+            closed = true;
+            open.delete(client);
+            console.log(`  [conn-] ${accountId} (${purpose}/${how}) — ${open.size} open`);
+        };
+        const origLogout = client.logout?.bind(client);
+        if (origLogout) {
+            client.logout = async () => {
+                try {
+                    await origLogout();
+                }
+                finally {
+                    markClosed("logout");
+                }
+            };
+        }
+        const origDestroy = client.destroy?.bind(client);
+        if (origDestroy) {
+            client.destroy = () => {
+                try {
+                    origDestroy();
+                }
+                finally {
+                    markClosed("destroy");
+                }
+            };
+        }
+        return client;
+    }
+    /** Get (or lazily create) the persistent body-fetch client. Separate from
+     *  the ops client so body reads never wait on a slow sync command. */
+    async getBodyClient(accountId) {
+        let client = this.bodyClients.get(accountId);
+        if (client)
+            return client;
+        client = this.newClient(accountId, "body");
+        const realLogout = client.logout.bind(client);
+        client.logout = async () => { };
+        client._realLogout = realLogout;
+        this.bodyClients.set(accountId, client);
+        return client;
+    }
+    /** Drop the body-fetch connection (e.g. after a socket error). */
+    async dropBodyClient(accountId) {
+        const client = this.bodyClients.get(accountId);
+        if (!client)
+            return;
+        this.bodyClients.delete(accountId);
+        try {
+            await (client._realLogout || client.logout)();
+        }
+        catch { /* */ }
+        try {
+            client.destroy?.();
+        }
+        catch { /* */ }
     }
     /** Disconnect the persistent operational connection for an account */
     async disconnectOps(accountId) {
@@ -350,9 +429,9 @@ export class ImapManager extends EventEmitter {
     async createClientWithLimit(accountId) {
         return this.getOpsClient(accountId);
     }
-    createClient(accountId) {
+    createClient(accountId, purpose = "misc") {
         // Return a fresh disposable client (used by IDLE watcher and one-off operations)
-        return this.newClient(accountId);
+        return this.newClient(accountId, purpose);
     }
     trackLogout(_accountId) { }
     /** Number of registered IMAP accounts */
@@ -605,11 +684,14 @@ export class ImapManager extends EventEmitter {
                     if (missingUids.length > 0 && missingUids.length <= 5000) {
                         console.log(`  ${folder.path}: gap detected — ${missingUids.length} missing UIDs in range ${lowestUid}..${highestUid}`);
                         const chunkSize = 500;
+                        let recoveredTotal = 0;
                         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: false });
                             messages.push(...recovered);
+                            recoveredTotal += recovered.length;
+                            console.log(`  ${folder.path}: gap-fill ${recoveredTotal}/${missingUids.length}`);
                         }
                     }
                     else if (missingUids.length > 5000) {
@@ -803,7 +885,16 @@ export class ImapManager extends EventEmitter {
         // has a 10-minute wall-clock timeout that killed it first — so
         // prefetch never ran.
         const syncAndPrefetch = async (accountId) => {
-            await this.syncAccount(accountId, priorityOrder);
+            try {
+                await this.syncAccount(accountId, priorityOrder);
+            }
+            catch {
+                // syncAccount already logs + emits syncError. Don't follow a
+                // failed sync with a body-prefetch storm into the same API:
+                // a 429 on listLabels means Gmail is in cooldown, so firing
+                // prefetch next would just re-trigger the same limit.
+                return;
+            }
             if (getPrefetch()) {
                 this.prefetchBodies(accountId).catch(e => console.error(`  [prefetch] ${accountId}: ${e.message}`));
             }
@@ -837,6 +928,16 @@ export class ImapManager extends EventEmitter {
                         await this.syncFolder(accountId, inbox.id, client);
                         console.log(`  [sync] ${accountId}: INBOX sync complete`);
                         inboxDone = true;
+                        // Kick off prefetch as soon as INBOX is fresh, not
+                        // after all 105 folders finish — bobma's full sync
+                        // can take 30+ minutes on a wide folder tree, and
+                        // INBOX is the only folder the user is staring at.
+                        // Uses the body client (separate connection from
+                        // ops), so it runs concurrently with the rest of the
+                        // folder sync without contending for the same socket.
+                        if (getPrefetch()) {
+                            this.prefetchBodies(accountId).catch(e => console.error(`  [prefetch] ${accountId}: ${e.message}`));
+                        }
                     }
                     catch (e) {
                         console.error(`  Inbox sync error for ${accountId} (attempt ${attempt}/${maxAttempts}): ${e.message}`);
@@ -943,6 +1044,9 @@ export class ImapManager extends EventEmitter {
             this.emit("syncError", accountId, errMsg);
             console.error(`  [api] Sync error for ${accountId}: ${errMsg}`);
             this.handleSyncError(accountId, errMsg);
+            // Propagate so the caller skips the prefetch that would otherwise
+            // fire straight into the same 429/cooldown and make it worse.
+            throw e;
         }
     }
     /** Sync a single folder via Gmail/Outlook API */
@@ -1374,44 +1478,98 @@ export class ImapManager extends EventEmitter {
         if (this.isGmailAccount(accountId)) {
             return this.fetchMessageBodyViaApi(accountId, folderId, uid, folder.path);
         }
-        // IMAP: fresh connection per on-demand fetch — never queued behind prefetch
-        let client = null;
-        try {
-            client = this.newClient(accountId);
-            const msg = await client.fetchMessageByUid(folder.path, uid, { source: true });
-            await client.logout();
-            client = null;
-            if (!msg) {
-                // IMAP server says the UID is gone — message was deleted
-                // elsewhere. Raise NotFound so the caller can remove the row.
-                throw makeNotFoundError(accountId, folderId, uid);
-            }
-            if (!msg.source)
+        // IMAP: use the persistent body-fetch client (separate from ops so we
+        // don't wait behind a slow sync command), serialized via enqueueFetch
+        // so overlapping requests share one socket instead of spawning fresh
+        // ones and blowing past the Dovecot connection cap.
+        return this.enqueueFetch(accountId, async () => {
+            // Cap-error backoff: when Dovecot has rejected us recently with
+            // "Maximum number of connections", short-circuit instead of
+            // queueing every body request behind a doomed login attempt.
+            const backoffUntil = this.bodyBackoff.get(accountId) || 0;
+            if (backoffUntil > Date.now()) {
+                const wait = Math.round((backoffUntil - Date.now()) / 1000);
+                console.warn(`  Body fetch (${accountId}/${uid}) skipped — server connection cap, retry in ${wait}s`);
                 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) {
-            if (e?.isNotFound) {
-                if (client) {
+            }
+            const attempt = async () => {
+                const client = await this.getBodyClient(accountId);
+                const msg = await client.fetchMessageByUid(folder.path, uid, { source: true });
+                if (!msg)
+                    throw makeNotFoundError(accountId, folderId, uid);
+                if (!msg.source)
+                    return null;
+                return Buffer.from(msg.source, "utf-8");
+            };
+            const classify = (msg) => ({
+                staleSocket: /Not connected|ECONNRESET|socket hang up|EPIPE|write after end|ended|closed/i.test(msg),
+                connCap: /UNAVAILABLE|Maximum number of connections|too many connections/i.test(msg),
+            });
+            let raw;
+            try {
+                raw = await attempt();
+            }
+            catch (e) {
+                if (e?.isNotFound)
+                    throw e;
+                const msg = e?.message || "";
+                const { staleSocket, connCap } = classify(msg);
+                // Always drop the cached client on any failure — keeping a
+                // half-broken client poisoned every subsequent request.
+                await this.dropBodyClient(accountId);
+                if (connCap) {
+                    // The dedicated body socket is locked out by the server's
+                    // per-user+IP cap (something else holds the slots). Fall
+                    // back to the already-open ops connection — slower (queues
+                    // behind sync commands), but actually works.
+                    this.bodyBackoff.set(accountId, Date.now() + 30_000);
+                    console.warn(`  Body fetch (${accountId}/${uid}): connection cap — falling back to ops connection`);
                     try {
-                        await client.logout();
+                        const fallbackRaw = await this.withConnection(accountId, async (client) => {
+                            const msg = await client.fetchMessageByUid(folder.path, uid, { source: true });
+                            if (!msg)
+                                throw makeNotFoundError(accountId, folderId, uid);
+                            if (!msg.source)
+                                return null;
+                            return Buffer.from(msg.source, "utf-8");
+                        });
+                        if (!fallbackRaw)
+                            return null;
+                        const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, fallbackRaw);
+                        this.db.updateBodyPath(accountId, uid, bodyPath);
+                        this.emit("bodyCached", accountId, uid);
+                        return fallbackRaw;
+                    }
+                    catch (e3) {
+                        if (e3?.isNotFound)
+                            throw e3;
+                        console.error(`  Body fetch fallback failed (${accountId}/${uid}): ${e3?.message}`);
+                        return null;
                     }
-                    catch { /* */ }
                 }
-                throw e;
-            }
-            console.error(`  Body fetch error (${accountId}/${uid}): ${e.message}`);
-            if (client) {
+                if (!staleSocket) {
+                    console.error(`  Body fetch error (${accountId}/${uid}): ${msg}`);
+                    return null;
+                }
+                // Stale socket — try once more with a fresh client.
                 try {
-                    await client.logout();
+                    raw = await attempt();
+                }
+                catch (e2) {
+                    if (e2?.isNotFound)
+                        throw e2;
+                    await this.dropBodyClient(accountId);
+                    console.error(`  Body fetch error (${accountId}/${uid}) after reconnect: ${e2?.message}`);
+                    return null;
                 }
-                catch { /* */ }
             }
-            return null;
-        }
+            if (!raw)
+                return null;
+            const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
+            this.db.updateBodyPath(accountId, uid, bodyPath);
+            this.emit("bodyCached", accountId, uid);
+            return raw;
+        });
     }
     /** Fetch message body via Gmail/Outlook API.
      *  Throws `MessageNotFoundError` when the server says the message is gone
@@ -1441,6 +1599,7 @@ export class ImapManager extends EventEmitter {
             const raw = Buffer.from(msg.source, "utf-8");
             const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
             this.db.updateBodyPath(accountId, uid, bodyPath);
+            this.emit("bodyCached", accountId, uid);
             return raw;
         }
         catch (e) {
@@ -1526,6 +1685,7 @@ export class ImapManager extends EventEmitter {
                                         const raw = Buffer.from(source, "utf-8");
                                         const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
                                         this.db.updateBodyPath(accountId, uid, bodyPath);
+                                        this.emit("bodyCached", accountId, uid);
                                         counters.totalFetched++;
                                         madeProgress = true;
                                     }
@@ -1616,6 +1776,7 @@ export class ImapManager extends EventEmitter {
                                         const raw = Buffer.from(source, "utf-8");
                                         const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
                                         this.db.updateBodyPath(accountId, uid, bodyPath);
+                                        this.emit("bodyCached", accountId, uid);
                                         counters.totalFetched++;
                                         madeProgress = true;
                                     }
@@ -1824,6 +1985,47 @@ export class ImapManager extends EventEmitter {
         if (actions.length === 0)
             return;
         const folders = this.db.getFolders(accountId);
+        // Gmail path: push flag/label changes through the REST provider so
+        // they actually reach the server. Earlier this method always went
+        // through withConnection → IMAP, which silently no-op'd for Gmail
+        // accounts (REST-only, no IMAP connection) and left local-only stars
+        // that vanished on the next full sync.
+        if (this.isGmailAccount(accountId)) {
+            const api = this.getGmailProvider(accountId);
+            try {
+                for (const action of actions) {
+                    const folder = folders.find(f => f.id === action.folderId);
+                    if (!folder) {
+                        this.db.completeSyncAction(action.id);
+                        continue;
+                    }
+                    try {
+                        if (action.action === "flags" && api.setFlags) {
+                            await api.setFlags(folder.path, action.uid, action.flags || []);
+                            console.log(`  [api] ${accountId}: flags synced UID ${action.uid}`);
+                        }
+                        else {
+                            // move/delete/append via API not implemented yet — leave queued
+                            continue;
+                        }
+                        this.db.completeSyncAction(action.id);
+                    }
+                    catch (e) {
+                        console.error(`  [api] ${accountId}: flag sync failed UID ${action.uid}: ${e.message}`);
+                        this.db.failSyncAction(action.id, e.message);
+                        if (action.attempts >= 5)
+                            this.db.completeSyncAction(action.id);
+                    }
+                }
+            }
+            finally {
+                try {
+                    await api.close();
+                }
+                catch { /* */ }
+            }
+            return;
+        }
         await this.withConnection(accountId, async (client) => {
             for (const action of actions) {
                 const folder = folders.find(f => f.id === action.folderId);

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

@@ -13,7 +13,7 @@ export declare class MailxService {
     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;
+    getMessages(accountId: string, folderId: number, page?: number, pageSize?: number, sort?: string, sortDir?: string, search?: string, flaggedOnly?: boolean): 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): Promise<void>;

package/packages/mailx-service/index.js

@@ -67,8 +67,8 @@ export class MailxService {
     getUnifiedInbox(page = 1, pageSize = 50) {
         return this.db.getUnifiedInbox(page, pageSize);
     }
-    getMessages(accountId, folderId, page = 1, pageSize = 50, sort = "date", sortDir = "desc", search) {
-        return this.db.getMessages({ accountId, folderId, page, pageSize, sort: sort, sortDir: sortDir, search });
+    getMessages(accountId, folderId, page = 1, pageSize = 50, sort = "date", sortDir = "desc", search, flaggedOnly = false) {
+        return this.db.getMessages({ accountId, folderId, page, pageSize, sort: sort, sortDir: sortDir, search, flaggedOnly });
     }
     async getMessage(accountId, uid, allowRemote = false, folderId) {
         const envelope = this.db.getMessageByUid(accountId, uid, folderId);
@@ -670,9 +670,7 @@ export class MailxService {
             return;
         }
         const { cloudWrite } = await import("@bobfrankston/mailx-settings");
-        const ok = await cloudWrite(name, content);
-        if (!ok)
-            throw new Error(`Failed to write ${name}`);
+        await cloudWrite(name, content); // throws on failure with descriptive error
     }
     // ── Settings ──
     getSettings() {
@@ -717,17 +715,27 @@ export class MailxService {
             return { ok: true, message: `Loaded ${accounts.length} existing account(s) from cloud.` };
         }
         // No existing accounts — create new one
+        const isGoogle = ["gmail.com", "googlemail.com"].includes(domain) || detected?.cloud === "gdrive";
+        const isOAuth = ["gmail.com", "googlemail.com", "outlook.com", "hotmail.com", "live.com"].includes(domain);
         const account = { email, name: name || email.split("@")[0] };
         if (password)
             account.password = password;
-        if (detected && !["gmail.com", "googlemail.com", "outlook.com", "hotmail.com", "live.com"].includes(domain)) {
+        if (detected && !isOAuth) {
             account.imap = { host: detected.imapHost, port: 993, tls: true, auth: detected.auth, user: email };
             account.smtp = { host: detected.smtpHost, port: 587, tls: true, auth: detected.auth, user: email };
         }
         account.id = domain.split(".")[0] || "account";
-        await saveAccounts([account]);
+        // Save provisional account so addAccount can register it. Cloud failures
+        // surface via onCloudError listeners (UI banner) — don't fail setup itself.
+        try {
+            await saveAccounts([account]);
+        }
+        catch (e) {
+            console.error(`  [setup] saveAccounts failed: ${e.message}`);
+            return { ok: false, error: `Failed to save account: ${e.message}` };
+        }
         // Re-read normalized settings and register
-        const settings = loadSettings();
+        let settings = loadSettings();
         for (const acct of settings.accounts) {
             if (!acct.enabled)
                 continue;
@@ -739,6 +747,34 @@ export class MailxService {
                 console.error(`  Account ${acct.id} error: ${e.message}`);
             }
         }
+        // For Google accounts where the user didn't supply a name, fetch the
+        // display name from the People API now that addAccount has authenticated.
+        // contacts.readonly is in the Gmail OAuth scope, so the same token works.
+        if (!name && isGoogle) {
+            try {
+                const tok = await this.imapManager.getOAuthToken(account.id);
+                if (tok) {
+                    const { getGoogleProfile } = await import("@bobfrankston/mailx-settings/cloud.js");
+                    const profile = await getGoogleProfile(tok);
+                    if (profile?.name && profile.name !== account.name) {
+                        console.log(`  [setup] Display name from Google: ${profile.name}`);
+                        account.name = profile.name;
+                        // Re-save with the resolved name (best-effort; cloud errors
+                        // surface via onCloudError).
+                        try {
+                            await saveAccounts([account]);
+                        }
+                        catch (e) {
+                            console.error(`  [setup] re-saveAccounts with profile name failed: ${e.message}`);
+                        }
+                        settings = loadSettings();
+                    }
+                }
+            }
+            catch (e) {
+                console.error(`  [setup] getGoogleProfile failed: ${e.message}`);
+            }
+        }
         this.imapManager.syncAll().catch(() => { });
         return { ok: true, message: `${settings.accounts.length} account(s) configured and syncing.` };
     }

package/packages/mailx-service/jsonrpc.js

@@ -29,7 +29,7 @@ async function dispatchAction(svc, action, p) {
             return svc.getFolders(p.accountId);
         // Messages
         case "getMessages":
-            return svc.getMessages(p.accountId, p.folderId, p.page, p.pageSize);
+            return svc.getMessages(p.accountId, p.folderId, p.page, p.pageSize, p.sort, p.sortDir, p.search, p.flaggedOnly);
         case "getUnifiedInbox":
             return svc.getUnifiedInbox(p.page || 1, p.pageSize || 50);
         case "getMessage":