@bobfrankston/mailx 1.0.313 → 1.0.317

package/client/compose/compose.js

@@ -4,7 +4,7 @@
  * Receives init data via window.opener.postMessage or URL params.
  */
 import { createEditor } from "./editor.js";
-import { getVersion, getSettings, getAccounts, searchContacts, sendMessage, saveDraft as apiSaveDraft, deleteDraft } from "../lib/api-client.js";
+import { getSettings, getAccounts, searchContacts, sendMessage, saveDraft as apiSaveDraft, deleteDraft } from "../lib/api-client.js";
 /** Close compose window */
 function closeCompose() {
     window.close();
@@ -45,15 +45,37 @@ async function loadEditorAssets(type) {
     }
 }
 // ── Determine editor type from settings ──
+//
+// Compose must open fast. The previous flow awaited getVersion() then
+// getSettings() sequentially before the editor was even loaded — any
+// service-side stall (busy sync, slow IMAP, hung OAuth refresh) turned
+// "click Reply" into a multi-second / multi-minute wait with a blank
+// compose window. Local-first: read the editor-type preference from a
+// tiny localStorage cache that we update whenever getSettings succeeds
+// in the background. Default to quill on first run / cache miss.
 let editorType = "quill";
 let appSettings = null;
 try {
-    await getVersion(); // verify server is up
-    appSettings = await getSettings();
-    if (appSettings.ui?.editor === "tiptap")
-        editorType = "tiptap";
+    const cached = localStorage.getItem("mailx-editor-type");
+    if (cached === "tiptap" || cached === "quill")
+        editorType = cached;
 }
-catch { /* default to quill */ }
+catch { /* private-mode / SecurityError — default quill */ }
+// Refresh the cache asynchronously — doesn't block compose open.
+(async () => {
+    try {
+        appSettings = await getSettings();
+        const next = appSettings?.ui?.editor === "tiptap" ? "tiptap" : "quill";
+        try {
+            localStorage.setItem("mailx-editor-type", next);
+        }
+        catch { /* */ }
+        // Note: we don't hot-swap the editor if the preference changed while
+        // compose was opening — the old type is already instantiated. Next
+        // compose open will pick up the new preference.
+    }
+    catch { /* non-fatal */ }
+})();
 await loadEditorAssets(editorType);
 const container = document.getElementById("compose-editor");
 container.classList.add(editorType === "tiptap" ? "editor-tiptap" : "editor-quill");
@@ -382,26 +404,63 @@ function scheduleDraftSave() {
         clearTimeout(draftDebounceTimer);
     draftDebounceTimer = setTimeout(() => { draftDebounceTimer = null; saveDraft(); }, DRAFT_INPUT_DEBOUNCE_MS);
 }
-// ── Initialize: always fetch real accounts from the API before applying init, then
-//    start the auto-save timer. Callers like message-viewer's Edit Draft pass
-//    init.accounts=[], so we can't trust what's in the init blob. ──
+// ── Initialize: local-first population.
+//
+// Reply / Reply-All / Forward callers pre-populate `init.accounts` with the
+// full account list (app.ts:openCompose). In that common case we do NOT need
+// to call getAccounts() — everything required to fill the compose form is
+// already in sessionStorage and reads synchronously. That turns "click Reply"
+// into an instant-open instead of "wait for getAccounts IPC to respond,
+// which can take >120s when the service is busy syncing / hung on IMAP".
+//
+// getAccounts is still called (non-blocking) to refresh the dropdown with
+// the freshest data — and it IS awaited only in the fallback path where
+// init doesn't have an account list (message-viewer's Edit Draft passes
+// init.accounts=[]).
 (async () => {
-    let accounts = [];
-    try {
-        accounts = await getAccounts();
-    }
-    catch (e) {
-        console.error("Failed to load accounts:", e);
-    }
     const stored = sessionStorage.getItem("composeInit");
     if (stored) {
         sessionStorage.removeItem("composeInit");
         const init = JSON.parse(stored);
-        if (!init.accounts || init.accounts.length === 0)
-            init.accounts = accounts;
-        applyInit(init);
+        if (init.accounts && init.accounts.length > 0) {
+            // Happy path — init is complete. Apply immediately. Kick
+            // getAccounts in the background to refresh the dropdown if the
+            // user keeps compose open long enough for the result.
+            applyInit(init);
+            getAccounts().then((fresh) => {
+                if (Array.isArray(fresh) && fresh.length > 0) {
+                    init.accounts = fresh;
+                    // Re-populate the From dropdown only — don't clobber
+                    // anything the user may have already typed.
+                    try {
+                        populateFromOptions(fresh);
+                    }
+                    catch { /* */ }
+                }
+            }).catch(() => { });
+        }
+        else {
+            // Edit Draft / other callers that didn't pre-fill accounts.
+            // Have to wait on getAccounts here — the From dropdown needs it.
+            let fresh = [];
+            try {
+                fresh = await getAccounts();
+            }
+            catch (e) {
+                console.error("Failed to load accounts:", e);
+            }
+            init.accounts = fresh;
+            applyInit(init);
+        }
     }
     else {
+        let accounts = [];
+        try {
+            accounts = await getAccounts();
+        }
+        catch (e) {
+            console.error("Failed to load accounts:", e);
+        }
         populateFromOptions(accounts);
         toInput.focus();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.313",
+  "version": "1.0.317",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -24,7 +24,7 @@
     "@bobfrankston/iflow-node": "^0.1.7",
     "@bobfrankston/miscinfo": "^1.0.9",
     "@bobfrankston/oauthsupport": "^1.0.24",
-    "@bobfrankston/msger": "^0.1.342",
+    "@bobfrankston/msger": "^0.1.343",
     "@bobfrankston/mailx-host": "^0.1.3",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
@@ -88,7 +88,7 @@
       "@bobfrankston/iflow-node": "^0.1.7",
       "@bobfrankston/miscinfo": "^1.0.9",
       "@bobfrankston/oauthsupport": "^1.0.24",
-      "@bobfrankston/msger": "^0.1.342",
+      "@bobfrankston/msger": "^0.1.343",
       "@bobfrankston/mailx-host": "^0.1.3",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",

package/packages/mailx-imap/index.js

@@ -564,6 +564,11 @@ export class ImapManager extends EventEmitter {
         const folders = await client.getFolderList();
         console.log(`  [diag] ${accountId}: getFolderList done in ${Date.now() - t0}ms (${folders.length} folders)`);
         const specialFolders = client.getSpecialFolders(folders);
+        // Collect server paths so we can prune anything the server no longer
+        // has (user-renamed / -deleted / case-flipped a folder from another
+        // client). IMAP paths are case-sensitive, so "Foo" → "foo" is a real
+        // delete+create of two distinct mailboxes.
+        const serverPaths = new Set();
         for (const folder of folders) {
             // Skip non-selectable folders (virtual parents like "Added", "Added2")
             const flags = folder.flags;
@@ -584,6 +589,34 @@ export class ImapManager extends EventEmitter {
             else if (specialFolders.archive === folder.path)
                 specialUse = "archive";
             this.db.upsertFolder(accountId, folder.path, folder.name || folder.path.split(folder.delimiter || "/").pop() || folder.path, specialUse, folder.delimiter || "/");
+            serverPaths.add(folder.path);
+        }
+        // Prune: any local folder whose exact path (case-sensitive) isn't in
+        // the server's list has been deleted or renamed server-side. Safety
+        // rails: only prune when the server returned a non-empty list (empty
+        // result is more likely a transient protocol / auth error than "all
+        // your folders were deleted"). Never prune INBOX under any
+        // circumstances — even a broken server response shouldn't make us
+        // drop the account's primary mailbox. All other special-use folders
+        // ARE prunable: if the user actually deleted Sent on the server,
+        // we should reflect that locally, and the next sync will re-detect
+        // the server's real Sent folder and re-upsert.
+        if (folders.length > 0) {
+            const localFolders = this.db.getFolders(accountId);
+            const stale = localFolders.filter(f => !serverPaths.has(f.path) &&
+                f.specialUse !== "inbox");
+            for (const f of stale) {
+                console.log(`  [sync] ${accountId}: pruning stale folder "${f.path}" (id=${f.id}) — no longer on server`);
+                try {
+                    this.db.deleteFolder(f.id);
+                }
+                catch (e) {
+                    console.error(`  [sync] ${accountId}: prune failed for "${f.path}": ${e.message}`);
+                }
+            }
+            if (stale.length > 0) {
+                this.emit("folderCountsChanged", accountId, {});
+            }
         }
         this.emit("syncProgress", accountId, "folders", 100);
         // Notify UI that folder structure changed — triggers tree re-render

package/packages/mailx-service/index.js

@@ -587,16 +587,33 @@ export class MailxService {
             throw new Error("Folder not found");
         const client = this.imapManager.createPublicClient(accountId);
         try {
-            if (client.deleteMailbox) {
-                await client.deleteMailbox(folder.path);
+            try {
+                if (client.deleteMailbox) {
+                    await client.deleteMailbox(folder.path);
+                }
+                else {
+                    await client.withConnection(async () => {
+                        await client.client.mailboxDelete(folder.path);
+                    });
+                }
             }
-            else {
-                await client.withConnection(async () => {
-                    await client.client.mailboxDelete(folder.path);
-                });
+            catch (e) {
+                // Server already doesn't have this folder — common case when
+                // the user deleted / renamed it from another client and mailx
+                // is still showing the stale local row. Silently treat as
+                // success and proceed with local cleanup; the user's intent
+                // ("make this go away") is met either way.
+                const msg = String(e?.message || e || "").toLowerCase();
+                const alreadyGone = /nonexistent|does not exist|no such|not found|NO \[.*\] Mailbox|404/i.test(msg);
+                if (!alreadyGone)
+                    throw e;
+                console.log(`  [folder] ${accountId} delete "${folder.path}": server says already gone — cleaning local DB`);
             }
             this.db.deleteFolder(folderId);
-            await client.logout();
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
         }
         finally {
             try {
@@ -647,6 +664,16 @@ export class MailxService {
     }
     // ── Drafts ──
     async saveDraft(accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid, draftId) {
+        // Local-first: commit the draft to the local filesystem synchronously
+        // and return immediately. The IMAP APPEND (and the previous-draft
+        // delete) run in the background. Previously this method awaited IMAP
+        // inline, which produced the 30/120s `mailxapi timeout: saveDraft`
+        // the user reported — every IMAP stall (slow server, hung OAuth,
+        // maxed connection pool) froze autosave. The local `.eml` written
+        // below is the user's crash-safety net; IMAP is a sync target, not
+        // a prerequisite. X-Mailx-Draft-ID is carried in the MIME headers
+        // so the reconciler can de-duplicate on the server by header search
+        // even without the previousDraftUid round-trip.
         const settings = loadSettings();
         const account = settings.accounts.find(a => a.id === accountId);
         if (!account)
@@ -663,7 +690,8 @@ export class MailxService {
             `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`, `Content-Transfer-Encoding: quoted-printable`,
         ].filter(h => h !== null).join("\r\n");
         const raw = `${headers}\r\n\r\n${bodyEncoded}`;
-        // Save local editing copy — crash recovery, keep last 3
+        // Local commit: write editing copy to disk. Crash recovery lives in
+        // the last 3 files. Synchronous fs (~ms) so the caller returns fast.
         try {
             const editingDir = path.join(getConfigDir(), "sending", accountId, "editing");
             fs.mkdirSync(editingDir, { recursive: true });
@@ -677,9 +705,16 @@ export class MailxService {
                 fs.unlinkSync(path.join(editingDir, files.shift()));
             }
         }
-        catch { /* ignore */ }
-        const draftUid = await this.imapManager.saveDraft(accountId, raw, previousDraftUid, id);
-        return { draftUid, draftId: id };
+        catch { /* non-fatal — draft stays in memory at least */ }
+        // Background reconcile to server Drafts folder. Fire-and-forget —
+        // the ACK to the client is already on its way.
+        this.imapManager.saveDraft(accountId, raw, previousDraftUid, id).catch((e) => {
+            console.error(`  [draft] background IMAP save failed for ${id}: ${e?.message || e}`);
+            // Surface as an event so the UI can show a status-bar hint without
+            // blocking the caller. Draft is preserved on disk regardless.
+            this.emit?.("draftSaveDeferred", { accountId, draftId: id, error: String(e?.message || e) });
+        });
+        return { draftUid: null, draftId: id };
     }
     async deleteDraft(accountId, draftUid, draftId) {
         await this.imapManager.deleteDraft(accountId, draftUid, draftId);