@bobfrankston/iflow-direct 0.1.10 → 0.1.12

package/imap-compat.d.ts

@@ -49,10 +49,20 @@ export declare class CompatImapClient {
     getMessagesCount(mailbox: string): Promise<number>;
     /** Get all UIDs in a mailbox */
     getUids(mailbox: string): Promise<number[]>;
-    /** Fetch messages by UID range string (e.g. "100,200,300" or "100:200") */
+    /** Fetch messages — supports two calling conventions for compatibility:
+     *
+     *    New:  fetchMessages(mailbox, "100:200")           — UID range string
+     *    Old:  fetchMessages(mailbox, endSeq, count)       — sequence-number range (iflow compat)
+     *
+     *  The old form computes UID range "start:end" from (end - count + 1) : end,
+     *  matching the legacy iflow/imapflow fetchMessages(mailbox, end, count) API
+     *  used by the puller. */
     fetchMessages(mailbox: string, uidRange: string, options?: {
         source?: boolean;
     }): Promise<any[]>;
+    fetchMessages(mailbox: string, end: number, count: number, options?: {
+        source?: boolean;
+    }): Promise<any[]>;
     /** Search messages in a mailbox */
     searchMessages(mailbox: string, criteria: any): Promise<number[]>;
     /** Search by header value — returns matching UIDs */

package/imap-compat.js

@@ -160,11 +160,25 @@ export class CompatImapClient {
         await this.native.closeMailbox();
         return uids;
     }
-    /** Fetch messages by UID range string (e.g. "100,200,300" or "100:200") */
-    async fetchMessages(mailbox, uidRange, options) {
+    async fetchMessages(mailbox, rangeOrEnd, countOrOptions, maybeOptions) {
+        let range;
+        let options;
+        if (typeof rangeOrEnd === "number") {
+            // Legacy (iflow) calling convention: (mailbox, endSeq, count, options?)
+            const end = rangeOrEnd;
+            const count = typeof countOrOptions === "number" ? countOrOptions : 1;
+            const start = Math.max(1, end - count + 1);
+            range = `${start}:${end}`;
+            options = maybeOptions;
+        }
+        else {
+            // New calling convention: (mailbox, uidRange, options?)
+            range = rangeOrEnd;
+            options = typeof countOrOptions === "object" ? countOrOptions : undefined;
+        }
         await this.ensureConnected();
         await this.native.select(mailbox);
-        const msgs = await this.native.fetchMessages(uidRange, options);
+        const msgs = await this.native.fetchMessages(range, options);
         await this.native.closeMailbox();
         return msgs.map(toCompatMessage);
     }

package/imap-native.d.ts

@@ -54,6 +54,7 @@ export declare class NativeImapClient {
     private _connected;
     private idleTag;
     private idleCallback;
+    private idleRefreshTimer;
     private verbose;
     private selectedMailbox;
     private mailboxInfo;
@@ -114,6 +115,8 @@ export declare class NativeImapClient {
     /** Append a message to a mailbox */
     appendMessage(mailbox: string, message: string | Uint8Array, flags?: string[]): Promise<number | null>;
     startIdle(onNewMail: (count: number) => void): Promise<() => Promise<void>>;
+    /** Send DONE + re-IDLE. Called by the 28-minute refresh timer. */
+    private refreshIdle;
     getMessageCount(mailbox: string): Promise<number>;
     /** Inactivity timeout — how long to wait with NO data before declaring the connection dead.
      *  This is NOT a wall-clock timeout. Timer resets every time data arrives from the server.

package/imap-native.js

@@ -17,6 +17,7 @@ export class NativeImapClient {
     _connected = false;
     idleTag = null;
     idleCallback = null;
+    idleRefreshTimer = null;
     verbose;
     selectedMailbox = null;
     mailboxInfo = { exists: 0, recent: 0, uidNext: 0, uidValidity: 0, flags: [], permanentFlags: [] };
@@ -439,18 +440,74 @@ export class NativeImapClient {
     // ── IDLE ──
     async startIdle(onNewMail) {
         this.idleCallback = onNewMail;
-        const tag = proto.nextTag();
-        this.idleTag = tag;
-        await this.transport.write(proto.idleCommand(tag));
-        // Wait for "+" continuation
-        await this.waitForContinuation(tag);
+        let stopped = false;
+        const beginIdleCycle = async () => {
+            const tag = proto.nextTag();
+            this.idleTag = tag;
+            await this.transport.write(proto.idleCommand(tag));
+            await this.waitForContinuation(tag);
+            // RFC 2177: re-IDLE every ~28 minutes to avoid servers that terminate
+            // idle sessions at the 29-minute mark, and to give us a steady
+            // application-level keepalive that detects silently-dropped sockets.
+            this.idleRefreshTimer = setTimeout(() => {
+                if (stopped)
+                    return;
+                this.refreshIdle().catch(err => {
+                    if (this.verbose)
+                        console.error(`  [imap] IDLE refresh failed: ${err.message}`);
+                });
+            }, 28 * 60 * 1000);
+        };
+        await beginIdleCycle();
         return async () => {
+            stopped = true;
+            if (this.idleRefreshTimer) {
+                clearTimeout(this.idleRefreshTimer);
+                this.idleRefreshTimer = null;
+            }
+            const tag = this.idleTag;
             this.idleTag = null;
             this.idleCallback = null;
-            await this.transport.write(proto.doneCommand());
-            await this.waitForTagged(tag);
+            try {
+                await this.transport.write(proto.doneCommand());
+            }
+            catch { /* ignore */ }
+            if (tag) {
+                try {
+                    await this.waitForTagged(tag);
+                }
+                catch { /* ignore */ }
+            }
         };
     }
+    /** Send DONE + re-IDLE. Called by the 28-minute refresh timer. */
+    async refreshIdle() {
+        const oldTag = this.idleTag;
+        if (!oldTag || !this.idleCallback)
+            return;
+        const cb = this.idleCallback;
+        // DONE the current IDLE
+        await this.transport.write(proto.doneCommand());
+        try {
+            await this.waitForTagged(oldTag);
+        }
+        catch { /* best-effort */ }
+        // Re-IDLE with a new tag
+        this.idleCallback = cb; // waitForTagged resolved pendingCommand, reinstall callback
+        const newTag = proto.nextTag();
+        this.idleTag = newTag;
+        await this.transport.write(proto.idleCommand(newTag));
+        await this.waitForContinuation(newTag);
+        if (this.verbose)
+            console.log(`  [imap] IDLE refreshed (${newTag})`);
+        // Schedule the next refresh
+        this.idleRefreshTimer = setTimeout(() => {
+            this.refreshIdle().catch(err => {
+                if (this.verbose)
+                    console.error(`  [imap] IDLE refresh failed: ${err.message}`);
+            });
+        }, 28 * 60 * 1000);
+    }
     // ── Message count (lightweight STATUS) ──
     async getMessageCount(mailbox) {
         const status = await this.getStatus(mailbox);

package/package.json

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