@bobfrankston/iflow-direct 0.1.9 → 0.1.11

package/gmail.d.ts

@@ -10,6 +10,8 @@ export interface GmailOAuthConfig {
     verbose?: boolean;
     rejectUnauthorized?: boolean;
     inactivityTimeout?: number;
+    fetchChunkSize?: number;
+    fetchChunkSizeMax?: number;
 }
 /**
  * Check if email address is Gmail
@@ -37,5 +39,7 @@ export declare function createAutoImapConfig(config: {
     verbose?: boolean;
     rejectUnauthorized?: boolean;
     inactivityTimeout?: number;
+    fetchChunkSize?: number;
+    fetchChunkSizeMax?: number;
 }): ImapClientConfig;
 //# sourceMappingURL=gmail.d.ts.map

package/gmail.js

@@ -34,6 +34,8 @@ export function createGmailConfig(config) {
         verbose: config.verbose,
         rejectUnauthorized: config.rejectUnauthorized,
         inactivityTimeout: config.inactivityTimeout,
+        fetchChunkSize: config.fetchChunkSize,
+        fetchChunkSizeMax: config.fetchChunkSizeMax,
     };
 }
 /**
@@ -52,6 +54,8 @@ export function createAutoImapConfig(config) {
             verbose: config.verbose,
             rejectUnauthorized: config.rejectUnauthorized,
             inactivityTimeout: config.inactivityTimeout,
+            fetchChunkSize: config.fetchChunkSize,
+            fetchChunkSizeMax: config.fetchChunkSizeMax,
         });
     }
     else {
@@ -63,6 +67,8 @@ export function createAutoImapConfig(config) {
             verbose: config.verbose,
             rejectUnauthorized: config.rejectUnauthorized,
             inactivityTimeout: config.inactivityTimeout,
+            fetchChunkSize: config.fetchChunkSize,
+            fetchChunkSizeMax: config.fetchChunkSizeMax,
         };
     }
 }

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.
@@ -121,9 +124,11 @@ export declare class NativeImapClient {
      *  60s accommodates Gmail which is slow on SEARCH for large folders.
      *  Overridable via ImapClientConfig.inactivityTimeout — slow Dovecot servers need 180s+. */
     private inactivityTimeout;
-    /** Fetch chunk sizes — start small for quick first paint, ramp up for throughput */
-    private static INITIAL_CHUNK_SIZE;
-    private static MAX_CHUNK_SIZE;
+    /** Fetch chunk sizes — start small for quick first paint, ramp up for throughput.
+     *  Default 25 initial → 500 max. Overridable via ImapClientConfig.fetchChunkSize /
+     *  fetchChunkSizeMax. Slow servers benefit from smaller chunks (fewer timeouts). */
+    private fetchChunkSize;
+    private fetchChunkSizeMax;
     /** Active command timer — reset by handleData on every data arrival */
     private commandTimer;
     private sendCommand;

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: [] };
@@ -29,6 +30,8 @@ export class NativeImapClient {
         this.transport = transportFactory();
         this.verbose = config.verbose || false;
         this.inactivityTimeout = config.inactivityTimeout ?? 60000;
+        this.fetchChunkSize = config.fetchChunkSize ?? 25;
+        this.fetchChunkSizeMax = config.fetchChunkSizeMax ?? 500;
     }
     get connected() { return this._connected; }
     // ── Connection ──
@@ -296,14 +299,14 @@ export class NativeImapClient {
             return [];
         uids.reverse(); // Newest first
         console.log(`  [fetch] ${uids.length} UIDs since ${sinceUid} (newest first)`);
-        if (uids.length <= NativeImapClient.INITIAL_CHUNK_SIZE) {
+        if (uids.length <= this.fetchChunkSize) {
             const msgs = await this.fetchMessages(uids.join(","), options);
             if (onChunk)
                 onChunk(msgs);
             return msgs;
         }
         const allMessages = [];
-        let chunkSize = NativeImapClient.INITIAL_CHUNK_SIZE;
+        let chunkSize = this.fetchChunkSize;
         for (let i = 0; i < uids.length; i += chunkSize) {
             const chunk = uids.slice(i, i + chunkSize);
             const msgs = await this.fetchMessages(chunk.join(","), options);
@@ -311,8 +314,8 @@ export class NativeImapClient {
             console.log(`  [fetch] ${allMessages.length}/${uids.length} (chunk of ${chunk.length})`);
             if (onChunk)
                 onChunk(msgs);
-            if (chunkSize < NativeImapClient.MAX_CHUNK_SIZE)
-                chunkSize = Math.min(chunkSize * 4, NativeImapClient.MAX_CHUNK_SIZE);
+            if (chunkSize < this.fetchChunkSizeMax)
+                chunkSize = Math.min(chunkSize * 4, this.fetchChunkSizeMax);
         }
         return allMessages;
     }
@@ -329,7 +332,7 @@ export class NativeImapClient {
         uids.reverse();
         console.log(`  [fetch] ${uids.length} UIDs to fetch (newest first)`);
         const allMessages = [];
-        let chunkSize = NativeImapClient.INITIAL_CHUNK_SIZE;
+        let chunkSize = this.fetchChunkSize;
         for (let i = 0; i < uids.length; i += chunkSize) {
             const chunk = uids.slice(i, i + chunkSize);
             const msgs = await this.fetchMessages(chunk.join(","), options);
@@ -337,8 +340,8 @@ export class NativeImapClient {
             console.log(`  [fetch] ${allMessages.length}/${uids.length} (chunk of ${chunk.length})`);
             if (onChunk)
                 onChunk(msgs);
-            if (chunkSize < NativeImapClient.MAX_CHUNK_SIZE)
-                chunkSize = Math.min(chunkSize * 4, NativeImapClient.MAX_CHUNK_SIZE);
+            if (chunkSize < this.fetchChunkSizeMax)
+                chunkSize = Math.min(chunkSize * 4, this.fetchChunkSizeMax);
         }
         return allMessages;
     }
@@ -437,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);
@@ -461,9 +520,11 @@ export class NativeImapClient {
      *  60s accommodates Gmail which is slow on SEARCH for large folders.
      *  Overridable via ImapClientConfig.inactivityTimeout — slow Dovecot servers need 180s+. */
     inactivityTimeout;
-    /** Fetch chunk sizes — start small for quick first paint, ramp up for throughput */
-    static INITIAL_CHUNK_SIZE = 25;
-    static MAX_CHUNK_SIZE = 500;
+    /** Fetch chunk sizes — start small for quick first paint, ramp up for throughput.
+     *  Default 25 initial → 500 max. Overridable via ImapClientConfig.fetchChunkSize /
+     *  fetchChunkSizeMax. Slow servers benefit from smaller chunks (fewer timeouts). */
+    fetchChunkSize;
+    fetchChunkSizeMax;
     /** Active command timer — reset by handleData on every data arrival */
     commandTimer = null;
     sendCommand(tag, command) {

package/package.json

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

package/types.d.ts

@@ -11,5 +11,7 @@ export interface ImapClientConfig {
     verbose?: boolean;
     rejectUnauthorized?: boolean;
     inactivityTimeout?: number;
+    fetchChunkSize?: number;
+    fetchChunkSizeMax?: number;
 }
 //# sourceMappingURL=types.d.ts.map