@bobfrankston/mailx-imap 0.1.108 → 0.1.110

package/index.js

@@ -1764,7 +1764,18 @@ export class ImapManager extends EventEmitter {
                     // Apply changed-state FETCH — flag updates since prior modSeq.
                     for (const m of qr.changedMessages) {
                         try {
+                            // LOCAL-FIRST: never let a server reconcile clobber a flag
+                            // the user just changed locally but whose push hasn't drained
+                            // yet — that's the "I unflag it and it quickly comes back"
+                            // bug (Bob 2026-06-27). Skip any message with a pending flag
+                            // action; the drain will push it and a later reconcile syncs.
+                            const pendingFlag = this.db.findPendingSyncAction(accountId, "flags", m.uid, folderId);
+                            if (pendingFlag) {
+                                console.error(`  [flag-reconcile] SKIP uid=${m.uid} folder=${folderId} — pending local flag action wins`);
+                                continue;
+                            }
                             const flagsArr = Array.from(m.flags || []).map(f => String(f));
+                            console.error(`  [flag-reconcile] OVERWRITE uid=${m.uid} folder=${folderId} server=[${flagsArr.join(",")}]`);
                             this.db.updateMessageFlags(accountId, folderId, m.uid, flagsArr);
                         }
                         catch { /* row may have just been VANISHED */ }
@@ -4168,13 +4179,17 @@ export class ImapManager extends EventEmitter {
                             const MANAGED = ["\\Seen", "\\Flagged"];
                             const impliedRemove = MANAGED.filter(f => !desired.includes(f));
                             const toRemove = [...new Set([...explicitRemove, ...impliedRemove])];
+                            // console.error so it lands in the captured daemon log
+                            // (worker stdout is NOT piped; stderr is). Temporary
+                            // diagnostic for the "flag won't persist" hunt.
+                            console.error(`  [flag-drain] ${accountId} uid=${action.uid} folder="${folder.path}" +[${desired.join(",")}] -[${toRemove.join(",")}]`);
                             if (desired.length > 0) {
                                 await client.addFlags(folder.path, action.uid, desired);
                             }
                             if (toRemove.length > 0) {
                                 await client.removeFlags(folder.path, action.uid, toRemove);
                             }
-                            console.log(`  [sync] Updated flags UID ${action.uid} (+[${desired.join(",")}] -[${toRemove.join(",")}])`);
+                            console.error(`  [flag-drain] ${accountId} uid=${action.uid} OK (server STORE done)`);
                             break;
                         }
                         case "append": {
@@ -5174,54 +5189,68 @@ export class ImapManager extends EventEmitter {
             // long outbox drain never blocks them.
             const result = await this.withConnection(accountId, async (client) => {
                 const flags = await client.getFlags(outboxFolder.path, uid);
-                // Sweep stale claims. $Sending-<host>-<sec> with old timestamp,
-                // or legacy $Sending-<host> without timestamp (treated as
-                // stale; if the real owner is alive it'll re-claim next tick).
-                const claimFlags = flags.filter((f) => f.startsWith("$Sending"));
-                for (const cf of claimFlags) {
-                    const m = cf.match(/^\$Sending-(.+?)(?:-(\d+))?$/);
-                    if (!m)
-                        continue;
-                    const tsSec = m[2] ? parseInt(m[2]) : 0;
-                    const ageSec = nowSec - tsSec;
-                    if (ageSec * 1000 > STALE_CLAIM_MS) {
-                        try {
-                            await client.removeFlags(outboxFolder.path, uid, [cf]);
-                            console.log(`  [outbox] Swept stale claim ${cf} on UID ${uid} (age ${Math.round(ageSec / 60)}m)`);
+                // The $Sending/$Failed/$PermanentFailure interlock uses CUSTOM
+                // IMAP keywords, which only work when the server advertises \*
+                // in PERMANENTFLAGS. AOL (and some others) don't, and reject a
+                // STORE of any custom keyword with "[CLIENTBUG] UID STORE
+                // Command arguments invalid" — which wedged the whole outbox in
+                // a 5-minute retry loop, so nothing ever sent (Bob 2026-06-26,
+                // from the log). Gate the keyword dance on real support; without
+                // it, send best-effort with no IMAP-side claim (correct for a
+                // single device — there's no keyword to coordinate on anyway).
+                const supportsKeywords = !!client.mailboxInfo?.permanentFlags?.includes("\\*");
+                if (supportsKeywords) {
+                    // Sweep stale claims. $Sending-<host>-<sec> with old timestamp,
+                    // or legacy $Sending-<host> without timestamp (treated as
+                    // stale; if the real owner is alive it'll re-claim next tick).
+                    const claimFlags = flags.filter((f) => f.startsWith("$Sending"));
+                    for (const cf of claimFlags) {
+                        const m = cf.match(/^\$Sending-(.+?)(?:-(\d+))?$/);
+                        if (!m)
+                            continue;
+                        const tsSec = m[2] ? parseInt(m[2]) : 0;
+                        const ageSec = nowSec - tsSec;
+                        if (ageSec * 1000 > STALE_CLAIM_MS) {
+                            try {
+                                await client.removeFlags(outboxFolder.path, uid, [cf]);
+                                console.log(`  [outbox] Swept stale claim ${cf} on UID ${uid} (age ${Math.round(ageSec / 60)}m)`);
+                            }
+                            catch { /* ignore */ }
                         }
-                        catch { /* ignore */ }
                     }
-                }
-                const flagsNow = (claimFlags.length > 0)
-                    ? await client.getFlags(outboxFolder.path, uid)
-                    : flags;
-                if (flagsNow.some((f) => f.startsWith("$Sending")))
-                    return { skip: true };
-                if (flagsNow.includes("$PermanentFailure"))
-                    return { skip: true };
-                if (flagsNow.includes("$Failed")) {
-                    await client.removeFlags(outboxFolder.path, uid, ["$Failed"]);
-                }
-                await client.addFlags(outboxFolder.path, uid, [sendingFlag]);
-                // TOCTOU re-check: if two devices addFlags concurrently both
-                // see ≥2 sending flags. Fail-safe: both back off, next tick
-                // one wins.
-                const flagsAfter = await client.getFlags(outboxFolder.path, uid);
-                const sendingFlags = flagsAfter.filter((f) => f.startsWith("$Sending"));
-                if (sendingFlags.length > 1 || (sendingFlags.length === 1 && sendingFlags[0] !== sendingFlag)) {
-                    await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);
-                    return { skip: true };
+                    const flagsNow = (claimFlags.length > 0)
+                        ? await client.getFlags(outboxFolder.path, uid)
+                        : flags;
+                    if (flagsNow.some((f) => f.startsWith("$Sending")))
+                        return { skip: true };
+                    if (flagsNow.includes("$PermanentFailure"))
+                        return { skip: true };
+                    if (flagsNow.includes("$Failed")) {
+                        await client.removeFlags(outboxFolder.path, uid, ["$Failed"]);
+                    }
+                    await client.addFlags(outboxFolder.path, uid, [sendingFlag]);
+                    // TOCTOU re-check: if two devices addFlags concurrently both
+                    // see ≥2 sending flags. Fail-safe: both back off, next tick
+                    // one wins.
+                    const flagsAfter = await client.getFlags(outboxFolder.path, uid);
+                    const sendingFlags = flagsAfter.filter((f) => f.startsWith("$Sending"));
+                    if (sendingFlags.length > 1 || (sendingFlags.length === 1 && sendingFlags[0] !== sendingFlag)) {
+                        await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);
+                        return { skip: true };
+                    }
                 }
                 const msg = await client.fetchMessageByUid(outboxFolder.path, uid, { source: true });
                 if (!msg?.source) {
-                    await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);
+                    if (supportsKeywords)
+                        await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);
                     return { skip: true };
                 }
-                return { source: msg.source };
+                return { source: msg.source, supportsKeywords };
             }, { lane: "outbox" });
             if (result.skip)
                 continue;
             const source = result.source;
+            const supportsKeywords = !!result.supportsKeywords;
             // SMTP send is its own connection — not an IMAP op, doesn't go
             // through withConnection.
             try {
@@ -5267,13 +5296,15 @@ export class ImapManager extends EventEmitter {
             catch (e) {
                 const errMsg = e.message || String(e);
                 console.error(`  [outbox] Send failed UID ${uid}: ${errMsg}`);
-                try {
-                    await this.withConnection(accountId, async (client) => {
-                        await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);
-                        await client.addFlags(outboxFolder.path, uid, ["$Failed"]);
-                    }, { lane: "outbox" });
+                if (supportsKeywords) {
+                    try {
+                        await this.withConnection(accountId, async (client) => {
+                            await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);
+                            await client.addFlags(outboxFolder.path, uid, ["$Failed"]);
+                        }, { lane: "outbox" });
+                    }
+                    catch { /* best-effort */ }
                 }
-                catch { /* best-effort */ }
                 // Suppress the banner for transient network errors. ETIMEDOUT
                 // on a Dovecot send is the server being slow / a TCP idle
                 // drop, NOT a user-actionable failure — the next outbox tick

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.108",
+  "version": "0.1.110",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",