@bobfrankston/mailx 1.0.98 → 1.0.100

package/bin/mailx.js

@@ -49,6 +49,13 @@ if (hasFlag("kill")) {
     const { execSync } = await import("node:child_process");
     let killed = 0;
 
+    // Try graceful exit first
+    try {
+        execSync(`curl -s -m 2 http://localhost:${PORT}/api/exit`, { stdio: "pipe" });
+        log("Sent graceful exit");
+        execSync("timeout /t 1 /nobreak", { stdio: "pipe" });
+    } catch { /* server may not be responding */ }
+
     if (process.platform === "win32") {
         // Kill by port
         try {
@@ -59,17 +66,14 @@ if (hasFlag("kill")) {
             }
         } catch { /* no process on port */ }
 
-        // Kill any node.exe holding handles on the mailx install directory
-        const installDir = path.join(import.meta.dirname, "..");
+        // Kill any node.exe running mailx-server (uses tasklist + powershell instead of wmic)
         try {
-            const wmic = execSync(`wmic process where "name='node.exe'" get processid,commandline /format:csv`, { encoding: "utf-8" });
-            for (const line of wmic.split("\n")) {
-                if (line.includes("mailx-server") || line.includes("mailx\\packages")) {
-                    const pid = line.trim().split(",").pop();
-                    if (pid && /^\d+$/.test(pid)) {
-                        try { execSync(`taskkill /F /PID ${pid}`, { stdio: "pipe" }); console.log(`Killed PID ${pid} (mailx node process)`); killed++; } catch { /* */ }
-                    }
-                }
+            const ps = execSync(
+                `powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"name='node.exe'\\" | Where-Object { $_.CommandLine -match 'mailx-server|mailx\\\\packages' } | Select-Object -ExpandProperty ProcessId"`,
+                { encoding: "utf-8" }
+            ).trim();
+            for (const pid of ps.split("\n").map(s => s.trim()).filter(s => /^\d+$/.test(s))) {
+                try { execSync(`taskkill /F /PID ${pid}`, { stdio: "pipe" }); console.log(`Killed PID ${pid} (mailx node process)`); killed++; } catch { /* */ }
             }
         } catch { /* */ }
 
@@ -79,8 +83,15 @@ if (hasFlag("kill")) {
         try { execSync(`fuser -k ${PORT}/tcp`, { stdio: "pipe" }); console.log(`Killed process on port ${PORT}`); killed++; } catch { /* */ }
     }
 
+    // Clean up stale SQLite WAL/SHM files
+    const mailxDir = path.join(process.env.USERPROFILE || process.env.HOME || ".", ".mailx");
+    for (const ext of ["mailx.db-shm", "mailx.db-wal"]) {
+        const p = path.join(mailxDir, ext);
+        try { fs.unlinkSync(p); log(`Cleaned ${ext}`); } catch { /* */ }
+    }
+
     // Remove lock file
-    const lockPath = path.join(process.env.USERPROFILE || process.env.HOME || ".", ".mailx", "mailx-app.lock");
+    const lockPath = path.join(mailxDir, "mailx-app.lock");
     try { fs.unlinkSync(lockPath); log("Removed lock file"); } catch { /* */ }
 
     if (killed === 0) console.log("No mailx processes found");

package/killmail.cmd

@@ -1,6 +1,13 @@
 @echo off
-REM Kill mailx server (port 9333) and launcher window
+REM Kill mailx server (port 9333), launcher, and clean up stale DB locks
 REM Safe: only kills mailx processes, never all node.exe
 
+REM Try graceful exit first, then force kill
+curl -s -m 2 http://localhost:9333/api/exit >nul 2>&1
+timeout /t 1 /nobreak >nul 2>&1
 taskkill /F /IM mailx-app.exe >nul 2>&1 && echo Killed mailx-app.exe || echo mailx-app.exe not running
 killport 9333
+
+REM Clean up stale SQLite WAL/SHM files (left by zombie processes)
+if exist "%USERPROFILE%\.mailx\mailx.db-shm" del "%USERPROFILE%\.mailx\mailx.db-shm" && echo Cleaned mailx.db-shm
+if exist "%USERPROFILE%\.mailx\mailx.db-wal" del "%USERPROFILE%\.mailx\mailx.db-wal" && echo Cleaned mailx.db-wal

package/package.json

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

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

@@ -47,9 +47,13 @@ export declare class ImapManager extends EventEmitter {
     searchOnServer(accountId: string, mailboxPath: string, criteria: any): Promise<number[]>;
     /** Create a fresh IMAP client for an account (public access for API endpoints) */
     createPublicClient(accountId: string): any;
+    /** Track active IMAP connections for diagnostics */
+    private activeConnections;
     /** Create a fresh IMAP client for an account (disposable, single-use).
      *  Returns CompatImapClient (native) or ImapClient (imapflow) based on useNativeClient flag. */
     private createClient;
+    /** Track client logout for connection counting */
+    private trackLogout;
     /** Register an account */
     addAccount(account: AccountConfig): Promise<void>;
     /** Sync folder list for an account */

package/packages/mailx-imap/index.js

@@ -12,13 +12,26 @@ import * as path from "node:path";
 import { simpleParser } from "mailparser";
 import { createTransport } from "nodemailer";
 import * as os from "node:os";
-/** Extract full error detail from imapflow errors */
+/** Extract full error detail with provenance */
 function imapError(err) {
-    const parts = [err.message || "Unknown error"];
+    const msg = err.message || err.reason || err.code || (typeof err === "string" ? err : "");
+    const parts = [];
+    if (msg)
+        parts.push(msg);
     if (err.responseText)
         parts.push(err.responseText);
     if (err.responseStatus)
         parts.push(`[${err.responseStatus}]`);
+    if (err.code && err.code !== msg)
+        parts.push(`[${err.code}]`);
+    if (parts.length === 0)
+        parts.push(`Unexpected error: ${JSON.stringify(err).slice(0, 200)}`);
+    // Add source location if available
+    if (err.stack) {
+        const frame = err.stack.split("\n").find((l) => l.includes("imap") || l.includes("transport") || l.includes("compat"));
+        if (frame)
+            parts.push(`(${frame.trim().replace(/^at\s+/, "")})`);
+    }
     return parts.join(" — ");
 }
 /** Convert iflow address objects to our EmailAddress */
@@ -166,6 +179,11 @@ export class ImapManager extends EventEmitter {
     createPublicClient(accountId) {
         return this.createClient(accountId);
     }
+    // Legacy fallback disabled — was doubling connections without helping.
+    // To re-enable: uncomment legacyFallbacks logic in createClient and _syncAll.
+    // private legacyFallbacks = new Set<string>();
+    /** Track active IMAP connections for diagnostics */
+    activeConnections = new Map(); // accountId → count
     /** Create a fresh IMAP client for an account (disposable, single-use).
      *  Returns CompatImapClient (native) or ImapClient (imapflow) based on useNativeClient flag. */
     createClient(accountId) {
@@ -179,11 +197,21 @@ export class ImapManager extends EventEmitter {
         const config = this.configs.get(accountId);
         if (!config)
             throw new Error(`No config for account ${accountId}`);
+        const count = (this.activeConnections.get(accountId) || 0) + 1;
+        this.activeConnections.set(accountId, count);
+        const clientType = this.useNativeClient ? "native" : "imapflow";
+        console.log(`  [conn] ${accountId}: +1 ${clientType} (${count} active)`);
         if (this.useNativeClient) {
             return new CompatImapClient(config, () => new NodeTransport({ rejectUnauthorized: config.rejectUnauthorized !== false }));
         }
         return new ImapClient(config);
     }
+    /** Track client logout for connection counting */
+    trackLogout(accountId) {
+        const count = Math.max(0, (this.activeConnections.get(accountId) || 1) - 1);
+        this.activeConnections.set(accountId, count);
+        console.log(`  [conn] ${accountId}: -1 (${count} active)`);
+    }
     /** Register an account */
     async addAccount(account) {
         if (this.configs.has(account.id))
@@ -220,7 +248,10 @@ export class ImapManager extends EventEmitter {
         if (!client)
             client = this.createClient(accountId);
         this.emit("syncProgress", accountId, "folders", 0);
+        const t0 = Date.now();
+        console.log(`  [diag] ${accountId}: getFolderList starting...`);
         const folders = await client.getFolderList();
+        console.log(`  [diag] ${accountId}: getFolderList done in ${Date.now() - t0}ms (${folders.length} folders)`);
         const specialFolders = client.getSpecialFolders(folders);
         for (const folder of folders) {
             // Skip non-selectable folders (virtual parents like "Added", "Added2")
@@ -368,10 +399,9 @@ export class ImapManager extends EventEmitter {
         // Remove messages deleted on the server (skip on first sync — nothing to reconcile)
         let deletedCount = 0;
         if (!firstSync) {
-            let delClient = null;
             try {
-                delClient = this.createClient(accountId);
-                const serverUids = new Set(await delClient.getUids(folder.path));
+                // Reuse the passed-in client instead of opening a new connection
+                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)) {
@@ -382,18 +412,10 @@ export class ImapManager extends EventEmitter {
                 }
                 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 */ }
-            }
         }
         // Update folder counts from local DB (after deletions + additions)
         const result = this.db.getMessages({ accountId, folderId, page: 1, pageSize: 1 });
@@ -430,12 +452,17 @@ export class ImapManager extends EventEmitter {
         for (const [accountId] of this.configs) {
             let client = null;
             try {
+                const t0 = Date.now();
                 client = this.createClient(accountId);
                 const folders = await Promise.race([
                     this.syncFolders(accountId, client),
                     new Promise((_, reject) => setTimeout(() => reject(new Error("Folder list timeout (30s)")), 30000))
                 ]);
+                console.log(`  [timing] ${accountId}: folder list ${Date.now() - t0}ms (${folders.length} folders)`);
+                // Legacy fallback removed — was doubling connections.
+                // If native client has issues, set useNativeClient=false or use --legacy-imap flag.
                 await client.logout();
+                this.trackLogout(accountId);
                 client = null;
                 accountFolders.set(accountId, folders);
                 // Sync inbox immediately
@@ -448,6 +475,7 @@ export class ImapManager extends EventEmitter {
                             new Promise((_, reject) => setTimeout(() => reject(new Error("Sync timeout (60s)")), 60000))
                         ]);
                         await client.logout();
+                        this.trackLogout(accountId);
                         client = null;
                     }
                     catch (e) {
@@ -456,6 +484,7 @@ export class ImapManager extends EventEmitter {
                                 await client.logout();
                             }
                             catch { /* ignore */ }
+                            this.trackLogout(accountId);
                             client = null;
                         }
                         console.error(`  Inbox sync error for ${accountId}: ${e.message}`);
@@ -466,28 +495,49 @@ export class ImapManager extends EventEmitter {
                 const errMsg = imapError(e);
                 this.emit("syncError", accountId, errMsg);
                 console.error(`Sync error for ${accountId}: ${errMsg}`);
+                const config = this.configs.get(accountId);
+                const isOAuth = !!config?.tokenProvider;
                 // Connection limit — back off for 60 seconds
                 if (errMsg.includes("max_userip_connections") || errMsg.includes("Too many simultaneous")) {
                     this.connectionBackoff.set(accountId, Date.now() + 60000);
                     console.log(`  [backoff] ${accountId}: connection limit hit, backing off 60s`);
                 }
-                // Emit user-facing error once per account per session
-                if (!this.accountErrorShown.has(accountId)) {
+                // Classify error: transient (timeout, connection) vs auth (credentials, token)
+                const isTransient = /timeout|ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|Too many/i.test(errMsg);
+                const isAuth = /auth|login|credential|token|AUTHENTICATIONFAILED/i.test(errMsg);
+                if (isTransient) {
+                    // Transient: just log, will auto-retry on next sync cycle
+                    console.log(`  [transient] ${accountId}: ${errMsg} — will retry next cycle`);
+                }
+                else if (isAuth && isOAuth) {
+                    // OAuth auth error: auto-attempt re-auth
+                    console.log(`  [auth] ${accountId}: attempting automatic re-authentication...`);
+                    this.reauthenticate(accountId).then(ok => {
+                        if (!ok && !this.accountErrorShown.has(accountId)) {
+                            this.accountErrorShown.add(accountId);
+                            this.emit("accountError", accountId, errMsg, "Authentication expired — re-authenticate", true);
+                        }
+                    }).catch(() => {
+                        if (!this.accountErrorShown.has(accountId)) {
+                            this.accountErrorShown.add(accountId);
+                            this.emit("accountError", accountId, errMsg, "Authentication expired — re-authenticate", true);
+                        }
+                    });
+                }
+                else if (!this.accountErrorShown.has(accountId)) {
+                    // Non-transient, non-OAuth: show error banner
                     this.accountErrorShown.add(accountId);
-                    const config = this.configs.get(accountId);
-                    const isOAuth = !!config?.tokenProvider;
-                    const hint = errMsg.includes("max_userip_connections") || errMsg.includes("Too many")
-                        ? "Too many connections — backing off"
-                        : isOAuth ? "Authentication may have expired" : "Check server connectivity";
-                    this.emit("accountError", accountId, errMsg, hint, isOAuth);
+                    this.emit("accountError", accountId, errMsg, isOAuth ? "Authentication may have expired" : "Check server connectivity", isOAuth);
                 }
             }
             finally {
-                if (client)
+                if (client) {
                     try {
                         await client.logout();
                     }
                     catch { /* ignore */ }
+                    this.trackLogout(accountId);
+                }
             }
         }
         // Phase 2: Sync remaining folders — priority order, skip Trash subfolders on first sync
@@ -500,41 +550,51 @@ export class ImapManager extends EventEmitter {
                 const pb = priorityOrder.indexOf(b.specialUse || "") >= 0 ? priorityOrder.indexOf(b.specialUse || "") : 5;
                 return pa - pb;
             });
+            // Reuse one IMAP connection per account for all folders (avoid 87+ TLS handshakes)
             let client = null;
-            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 (${timeout / 1000}s)`)), timeout))
-                    ]);
-                    await client.logout();
-                    client = null;
-                }
-                catch (e) {
-                    if (client) {
-                        try {
-                            await client.logout();
-                        }
-                        catch { /* ignore */ }
-                        client = null;
+            try {
+                client = this.createClient(accountId);
+                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;
                     }
-                    if (e.responseText?.includes("doesn't exist")) {
-                        console.log(`  Removing non-existent folder: ${folder.path}`);
-                        this.db.deleteFolder(folder.id);
+                    // Longer timeout for folders we know are large (Trash, first sync)
+                    const timeout = highestUid === 0 ? 180000 : 60000;
+                    try {
+                        await Promise.race([
+                            this.syncFolder(accountId, folder.id, client),
+                            new Promise((_, reject) => setTimeout(() => reject(new Error(`Sync timeout (${timeout / 1000}s) on ${folder.path}`)), timeout))
+                        ]);
                     }
-                    else {
-                        console.error(`  Skipping folder ${folder.path}: ${e.message}`);
+                    catch (e) {
+                        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}`);
+                            // Connection may be broken — reconnect
+                            try {
+                                await client.logout();
+                            }
+                            catch { /* */ }
+                            this.trackLogout(accountId);
+                            client = this.createClient(accountId);
+                        }
+                    }
+                }
+            }
+            finally {
+                if (client) {
+                    try {
+                        await client.logout();
                     }
+                    catch { /* */ }
+                    this.trackLogout(accountId);
                 }
             }
             this.accountErrorShown.delete(accountId);

package/packages/mailx-server/index.js

@@ -57,7 +57,10 @@ if (settings.accounts.length === 0) {
 const dbDir = getConfigDir();
 const db = new MailxDB(dbDir);
 const imapManager = new ImapManager(db);
-if (process.argv.includes("--native-imap") || process.argv.includes("-native-imap")) {
+if (process.argv.includes("--legacy-imap") || process.argv.includes("-legacy-imap")) {
+    console.log("  Using legacy IMAP client (imapflow)");
+}
+else {
     imapManager.useNativeClient = true;
     console.log("  Using native IMAP client (transport-agnostic)");
 }
@@ -88,6 +91,9 @@ app.get("/api/version", (req, res) => {
     const storage = getStorageInfo();
     res.json({ version: SERVER_VERSION, theme: settings.ui?.theme || "system", storage });
 });
+app.all("/info", (req, res) => {
+    res.json({ version: SERVER_VERSION, uptime: Math.round(process.uptime()), port: PORT });
+});
 app.get("/status", (req, res) => {
     const accounts = db.getAccounts();
     const pendingSync = db.getTotalPendingSyncCount();