@bobfrankston/iflow-direct 0.1.54 → 0.1.56

package/fetched-message.d.ts

@@ -19,6 +19,7 @@ export declare class FetchedMessage implements NativeFetchedMessage {
     uid: number;
     flags: Set<string>;
     date: Date | null;
+    sentDate?: Date;
     subject: string;
     messageId: string;
     from: AddressData[];

package/fetched-message.js

@@ -24,6 +24,7 @@ export class FetchedMessage {
     uid;
     flags;
     date;
+    sentDate;
     subject;
     messageId;
     from;

package/imap-native.d.ts

@@ -14,6 +14,7 @@ export interface NativeFetchedMessage {
     uid: number;
     flags: Set<string>;
     date: Date | null;
+    sentDate?: Date;
     subject: string;
     messageId: string;
     from: proto.AddressData[];

package/imap-native.js

@@ -553,10 +553,25 @@ export class NativeImapClient {
             return;
         if (this.selectedMailbox !== folderPath)
             await this.select(folderPath);
-        await this.fetchMessagesStream(uids.join(","), { source: true, headers: false }, (msg) => {
-            if (msg.uid && msg.source)
+        // headers default (was `headers: false`): the single-message body fetch
+        // path (fetchMessage → fetchMessagesStream, headers DEFAULT) extracts
+        // BODY[] correctly, but this batch path passed `headers: false` and
+        // returned 0 bodies 100% of the time — so prefetch never cached anything
+        // and bodies only landed when the user opened a message (Bob 2026-06-17
+        // "predownloading still broken"). The only difference between the two
+        // paths was this flag; matching the working path. Diagnostic counters
+        // confirm extraction so a regression is visible in the log.
+        let got = 0, sawResp = 0;
+        await this.fetchMessagesStream(uids.join(","), { source: true }, (msg) => {
+            sawResp++;
+            if (msg.uid && msg.source) {
+                got++;
                 onBody(msg.uid, msg.source);
+            }
         });
+        if (got === 0 && uids.length > 0) {
+            console.error(`  [imap] fetchBodiesBatch ${folderPath}: 0/${uids.length} bodies (saw ${sawResp} FETCH responses) — body literal not extracted`);
+        }
     }
     /** Fetch messages since a UID */
     async fetchSinceUid(sinceUid, options = {}, onChunk) {
@@ -691,6 +706,17 @@ export class NativeImapClient {
                 return proto.parseSearchResponse(r.text);
             }
         }
+        // No untagged * SEARCH seen. If the tagged status is anything but OK,
+        // the search FAILED — throw so callers can tell "failed" from "no
+        // matches". Silently returning [] here let a failed HEADER search read
+        // as "message missing from server", and mailx's sent-sweep then
+        // re-APPENDed a copy every 5-minute tick — 3,704 duplicates of one
+        // message over ~13 days (2026-07-02). Empty-but-OK still returns []
+        // (some servers omit the * SEARCH line when there are zero hits).
+        const tagged = responses.find(r => r.tag === tag);
+        if (!tagged || tagged.type !== "OK") {
+            throw new Error(`SEARCH failed: ${tagged ? `${tagged.type} ${tagged.text || ""}` : "no tagged response"}`);
+        }
         return [];
     }
     /** Set flags on a message */
@@ -1498,6 +1524,11 @@ export class NativeImapClient {
             if (envMatch) {
                 const env = proto.parseEnvelope(envMatch[1]);
                 msg.date = msg.date || env.date;
+                // Expose the ENVELOPE Date: header (the SENT time) separately
+                // from msg.date (INTERNALDATE = server-received time). Callers
+                // that want messages to cluster by when they were sent — not by
+                // per-account delivery time — use sentDate. Additive/optional.
+                msg.sentDate = env.date || undefined;
                 msg.subject = env.subject;
                 msg.messageId = env.messageId;
                 msg.from = env.from;

package/imap-protocol.js

@@ -302,8 +302,16 @@ export function parseEnvelope(envStr) {
             result.to = parseAddressList(tokens[5]);
             result.cc = parseAddressList(tokens[6]);
             result.bcc = parseAddressList(tokens[7]);
-            result.inReplyTo = unquote(tokens[8]);
-            result.messageId = unquote(tokens[9]);
+            // Trim fold whitespace. Servers hand back the ENVELOPE msg-id /
+            // in-reply-to with the original header's folding intact when the
+            // Message-ID sat on a continuation line ("Message-ID:\r\n\t<...>")
+            // — the value arrives as "\t<...>". Stored untrimmed, that tab
+            // poisoned every later HEADER search ("missing on server") and
+            // fueled mailx's sent-sweep re-APPEND loop: 3,707 duplicates of
+            // one Outlook-composed reply (2026-07-02). Trim here so no
+            // consumer ever sees the fold whitespace.
+            result.inReplyTo = unquote(tokens[8]).trim();
+            result.messageId = unquote(tokens[9]).trim();
         }
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/iflow-direct",
-  "version": "0.1.54",
+  "version": "0.1.56",
   "description": "Direct IMAP client — transport-agnostic, no Node.js dependencies, browser-ready",
   "main": "index.js",
   "types": "index.ts",