@bobfrankston/rmfmail 1.2.295 → 1.2.296

package/.commitmsg

@@ -1,18 +1,29 @@
-A cloud read must not cache over a local write that beat it home
+A star set on the phone now reaches the desktop in seconds, not minutes
 
-Untrusting a sender wrote correctly to Drive — a clean restart pulled the right
-list — while the LOCAL copy still had the entry, mtime stamped at the moment of
-the write. A cloud read that started before the write finished after it, and
-its caching step put the pre-change content back on disk. Everything read
-through the sync loadAllowlist() then saw the value the user had just removed,
-until the next poll happened to overwrite it with the truth.
+Bob 2026-08-29: "how long should it take for a * on the phone to get to my
+desktop?" Measured, on his own log: a median of 5 minutes and up to 20.
 
-cloudRead now stamps each shared file's last local write and skips its cache
-step when the file changed while the read was in flight — the content it holds
-is older than what is on disk, and the local write has already gone to the
-cloud. The stamp is taken BEFORE the write, so a race resolves in favour of the
-local copy.
+Why: gal.iecc.com does not advertise NOTIFY, so the desktop watches INBOX with
+plain IDLE. The server DOES push a flag change there as an unsolicited
+`* 1234 FETCH (FLAGS (\Seen \Flagged))` — iflow-direct dropped it (fixed in
+0.1.67), and mailx had nothing to receive it with. The 5-minute quick check
+could not help either: it is a STATUS poll, and MESSAGES / UNSEEN / UIDNEXT do
+not move when a message is starred. So the only path was the periodic full
+sync's QRESYNC pass — which is why the numbers above are the sync cadence
+rather than any property of flags.
 
-Same shape as the contacts.jsonc flush clobber, and the same lesson: the local
-file is not a cache to be overwritten, it is a copy someone may have just
-edited.
+The IDLE watcher now takes `onFlagChange` and, debounced 1.5 s, runs the
+folder's normal QRESYNC pass — the same one that already reconciles flags and
+took 53 ms in that log. Marking ten messages read on the phone arrives as ten
+pushes and costs one pass. Our own STOREs bounce back as flag pushes too, so
+the handler skips while this account has sync actions draining; the local store
+already has those.
+
+INBOX only, because IDLE watches one mailbox per connection. Flags changed in
+other folders still wait for that folder's turn in the sync cycle.
+
+Also in this build: the log noise behind it. `[search]` / `[fetch]` per-command
+lines moved behind iflow's existing `verbose` flag, and the repeated
+per-folder reconcile lines now go through `logIfChanged` — first occurrence,
+every change, and an hourly restatement — instead of once per folder per cycle
+forever. On Android each of those lines was an HTTP request to the log server.

package/client/android-bootstrap.bundle.js

@@ -2640,6 +2640,28 @@ var init_trust = __esm({
   }
 });
 
+// packages/mailx-types/log-changes.js
+function logIfChanged(key, line, emit = console.log) {
+  const now = Date.now();
+  const prev = lastSeen.get(key);
+  if (prev && prev.line === line && now - prev.at < RESTATE_AFTER_MS)
+    return false;
+  lastSeen.set(key, { line, at: now });
+  emit(prev && prev.line === line ? `${line} (unchanged for an hour)` : line);
+  return true;
+}
+function clearLogState(key) {
+  lastSeen.delete(key);
+}
+var RESTATE_AFTER_MS, lastSeen;
+var init_log_changes = __esm({
+  "packages/mailx-types/log-changes.js"() {
+    "use strict";
+    RESTATE_AFTER_MS = 60 * 60 * 1e3;
+    lastSeen = /* @__PURE__ */ new Map();
+  }
+});
+
 // packages/mailx-types/contacts-config.js
 function parseContactsConfig(raw) {
   if (!raw)
@@ -3013,6 +3035,7 @@ __export(mailx_types_exports, {
   answeredOf: () => answeredOf,
   assessMessageTrust: () => assessMessageTrust,
   buildMimeMessage: () => buildMimeMessage,
+  clearLogState: () => clearLogState,
   deletedOf: () => deletedOf,
   displayNameClaimsOtherAddress: () => displayNameClaimsOtherAddress,
   draftOf: () => draftOf,
@@ -3028,6 +3051,7 @@ __export(mailx_types_exports, {
   inviteHasGoogleRsvp: () => inviteHasGoogleRsvp,
   isAddressToken: () => isAddressToken,
   isJunkPreviewText: () => isJunkPreviewText,
+  logIfChanged: () => logIfChanged,
   mergeReminderStates: () => mergeReminderStates,
   normalizeReminderState: () => normalizeReminderState,
   parseInvite: () => parseInvite,
@@ -3507,6 +3531,7 @@ var init_mailx_types = __esm({
     "use strict";
     init_contact_rules();
     init_trust();
+    init_log_changes();
     init_contacts_config();
     init_groups();
     init_reminder_state();
@@ -8855,6 +8880,10 @@ var NativeImapClient = class {
    *  a server-side deletion in real time instead of waiting for the next
    *  periodic poll. Distinct from `idleCallback` (new mail only). */
   idleExpungeCallback = null;
+  /** Fired for an unsolicited FETCH carrying FLAGS while parked in IDLE —
+   *  another client (a phone, Thunderbird, webmail) changed a flag on a
+   *  message in the selected mailbox. */
+  idleFlagCallback = null;
   idleRefreshTimer = null;
   /** RFC 5465 NOTIFY: fires on unsolicited STATUS responses for non-selected
    *  mailboxes (the server pushes these when the client has issued NOTIFY
@@ -9302,7 +9331,8 @@ var NativeImapClient = class {
     if (uids.length === 0)
       return [];
     uids.reverse();
-    console.log(`  [fetch] ${uids.length} UIDs since ${sinceUid} (newest first)`);
+    if (this.verbose)
+      console.log(`  [fetch] ${uids.length} UIDs since ${sinceUid} (newest first)`);
     if (uids.length <= this.fetchChunkSize) {
       const msgs = await this.fetchMessages(uids.join(","), options);
       if (onChunk)
@@ -9330,9 +9360,11 @@ var NativeImapClient = class {
       before: before || void 0
     });
     const t0 = Date.now();
-    console.log(`  [search] SINCE ${since.toISOString().slice(0, 10)}${before ? ` BEFORE ${before.toISOString().slice(0, 10)}` : ""} \u2014 running...`);
+    if (this.verbose)
+      console.log(`  [search] SINCE ${since.toISOString().slice(0, 10)}${before ? ` BEFORE ${before.toISOString().slice(0, 10)}` : ""} \u2014 running...`);
     const uids = await this.search(criteria);
-    console.log(`  [search] returned ${uids.length} UIDs in ${Date.now() - t0}ms`);
+    if (this.verbose)
+      console.log(`  [search] returned ${uids.length} UIDs in ${Date.now() - t0}ms`);
     if (uids.length === 0)
       return [];
     uids.reverse();
@@ -9345,7 +9377,8 @@ var NativeImapClient = class {
       allMessages.push(...msgs);
       chunkIndex++;
       if (chunkIndex === 1 || chunkIndex % 5 === 0) {
-        console.log(`  [fetch] ${allMessages.length}/${uids.length} messages (chunk ${chunkIndex})`);
+        if (this.verbose)
+          console.log(`  [fetch] ${allMessages.length}/${uids.length} messages (chunk ${chunkIndex})`);
       }
       if (onChunk)
         onChunk(msgs);
@@ -9353,7 +9386,8 @@ var NativeImapClient = class {
       if (chunkSize < this.fetchChunkSizeMax)
         chunkSize = Math.min(chunkSize * 4, this.fetchChunkSizeMax);
     }
-    console.log(`  [fetch] done \u2014 ${allMessages.length} messages in ${Date.now() - t0}ms`);
+    if (this.verbose)
+      console.log(`  [fetch] done \u2014 ${allMessages.length} messages in ${Date.now() - t0}ms`);
     return allMessages;
   }
   /** Fetch the most recent N messages by sequence number — avoids
@@ -9369,7 +9403,8 @@ var NativeImapClient = class {
     const start = Math.max(1, exists - n + 1);
     const range = `${start}:${exists}`;
     const t0 = Date.now();
-    console.log(`  [fetch-latest] ${this.selectedMailbox || "?"}: sequence ${range} (${Math.min(n, exists)} most recent of ${exists})`);
+    if (this.verbose)
+      console.log(`  [fetch-latest] ${this.selectedMailbox || "?"}: sequence ${range} (${Math.min(n, exists)} most recent of ${exists})`);
     const items = ["UID", "FLAGS", "ENVELOPE", "RFC822.SIZE", "INTERNALDATE", "BODY.PEEK[HEADER]"];
     if (options.source)
       items.push("BODY.PEEK[]");
@@ -9395,7 +9430,8 @@ var NativeImapClient = class {
         onChunk([]);
     }
     streamed.reverse();
-    console.log(`  [fetch-latest] done \u2014 ${streamed.length} messages in ${Date.now() - t0}ms`);
+    if (this.verbose)
+      console.log(`  [fetch-latest] done \u2014 ${streamed.length} messages in ${Date.now() - t0}ms`);
     return streamed;
   }
   /** Fetch a single message by UID */
@@ -9505,9 +9541,10 @@ var NativeImapClient = class {
     }
   }
   // ── IDLE ──
-  async startIdle(onNewMail, onExpunge) {
+  async startIdle(onNewMail, onExpunge, onFlagChange) {
     this.idleCallback = onNewMail;
     this.idleExpungeCallback = onExpunge ?? null;
+    this.idleFlagCallback = onFlagChange ?? null;
     this.idleStopped = false;
     const beginIdleCycle = async () => {
       const tag = nextTag();
@@ -10002,6 +10039,20 @@ var NativeImapClient = class {
           this.idleExpungeCallback();
         continue;
       }
+      if (this.idleTag && resp.tag === "*" && resp.type === "FETCH" && /FLAGS\s*\(/i.test(resp.text)) {
+        if (this.idleFlagCallback) {
+          const seq = parseInt(resp.text, 10);
+          const inner = resp.text.match(/FLAGS\s*\(([^)]*)\)/i)?.[1] || "";
+          const flags = inner.split(/\s+/).filter(Boolean);
+          try {
+            this.idleFlagCallback(Number.isFinite(seq) ? seq : 0, flags);
+          } catch (err) {
+            if (this.verbose)
+              console.error(`  [imap] onFlagChange threw: ${err.message}`);
+          }
+        }
+        continue;
+      }
       if (this.idleTag && resp.tag === "*" && resp.type === "STATUS" && this.onMailboxStatus) {
         const parsed = parseStatusResponseFull(resp.text);
         if (parsed) {
@@ -10515,7 +10566,7 @@ var CompatImapClient = class {
       this.native.onMailboxStatus = opts.onMailboxStatus;
     if (opts?.notifySpec)
       await this.native.notify(opts.notifySpec);
-    return this.native.startIdle(onNew, opts?.onExpunge);
+    return this.native.startIdle(onNew, opts?.onExpunge, opts?.onFlagChange);
   }
   /** Copy a message to another server (cross-account) */
   async moveMessageToServer(msg, fromMailbox, targetClient, toMailbox) {
@@ -11075,6 +11126,7 @@ function b64utf8(s) {
 }
 
 // packages/mailx-store-web/android-bootstrap.ts
+init_mailx_types();
 var db;
 var bodyStore;
 var service;
@@ -11487,12 +11539,18 @@ var AndroidSyncManager = class {
       const serverUids = new Set(serverUidsArr);
       const localUids = this.db.getUidsForFolder(accountId, folderId);
       if (serverUidsArr.length === 0 && localUids.length > 0) {
-        console.log(`[sync] ${folder.path}: reconcile skipped \u2014 server returned empty but local has ${localUids.length}`);
+        logIfChanged(
+          `${accountId}/${folder.path}:reconcile`,
+          `[sync] ${folder.path}: reconcile skipped \u2014 server returned empty but local has ${localUids.length}`
+        );
       } else {
         const toDelete = localUids.filter((uid) => !serverUids.has(uid));
         const RECONCILE_DELETE_THRESHOLD = 0.5;
         if (localUids.length > 0 && toDelete.length / localUids.length > RECONCILE_DELETE_THRESHOLD) {
-          console.log(`[sync] ${folder.path}: reconcile refused \u2014 would delete ${toDelete.length}/${localUids.length} (${Math.round(toDelete.length / localUids.length * 100)}%)`);
+          logIfChanged(
+            `${accountId}/${folder.path}:reconcile`,
+            `[sync] ${folder.path}: reconcile refused \u2014 would delete ${toDelete.length}/${localUids.length} (${Math.round(toDelete.length / localUids.length * 100)}%)`
+          );
         } else {
           for (const uid of toDelete) {
             this.db.deleteMessage(accountId, folderId, uid);