@bobfrankston/iflow 1.0.52 → 1.0.54

package/imaplib/imap-native.d.ts

@@ -115,8 +115,12 @@ export declare class NativeImapClient {
     appendMessage(mailbox: string, message: string | Uint8Array, flags?: string[]): Promise<number | null>;
     startIdle(onNewMail: (count: number) => void): Promise<() => Promise<void>>;
     getMessageCount(mailbox: string): Promise<number>;
-    /** Default timeout for IMAP commands (30s). Prevents hanging connections. */
-    private commandTimeout;
+    /** 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.
+     *  A large FETCH returning data continuously will never timeout. */
+    private inactivityTimeout;
+    /** Active command timer — reset by handleData on every data arrival */
+    private commandTimer;
     private sendCommand;
     private waitForContinuation;
     private waitForTagged;

package/imaplib/imap-native.js

@@ -290,7 +290,21 @@ export class NativeImapClient {
     }
     /** Fetch messages since a UID */
     async fetchSinceUid(sinceUid, options = {}) {
-        return this.fetchMessages(`${sinceUid + 1}:*`, options);
+        // Search for UIDs first, then fetch in chunks (avoids unbounded single command)
+        const uids = await this.search(`UID ${sinceUid + 1}:*`);
+        if (uids.length === 0)
+            return [];
+        if (uids.length <= 500) {
+            return this.fetchMessages(uids.join(","), options);
+        }
+        // Chunk large fetches
+        const allMessages = [];
+        for (let i = 0; i < uids.length; i += 500) {
+            const chunk = uids.slice(i, i + 500);
+            const msgs = await this.fetchMessages(chunk.join(","), options);
+            allMessages.push(...msgs);
+        }
+        return allMessages;
     }
     /** Fetch messages by date range */
     async fetchByDate(since, before, options = {}) {
@@ -426,23 +440,34 @@ export class NativeImapClient {
         return status.messages || 0;
     }
     // ── Low-level command handling ──
-    /** Default timeout for IMAP commands (30s). Prevents hanging connections. */
-    commandTimeout = 30000;
+    /** 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.
+     *  A large FETCH returning data continuously will never timeout. */
+    inactivityTimeout = 30000;
+    /** Active command timer — reset by handleData on every data arrival */
+    commandTimer = null;
     sendCommand(tag, command) {
         return new Promise((resolve, reject) => {
             if (this.verbose && !command.includes("LOGIN") && !command.includes("AUTHENTICATE")) {
                 console.log(`  [imap] > ${command.trimEnd()}`);
             }
-            const timer = setTimeout(() => {
+            const onTimeout = () => {
+                this.commandTimer = null;
                 this.pendingCommand = null;
-                reject(new Error(`IMAP command timeout (${this.commandTimeout / 1000}s): ${command.split("\r")[0].substring(0, 50)}`));
-            }, this.commandTimeout);
+                // Kill the connection — a timed-out connection has stale data in the pipe
+                this.transport.close?.();
+                reject(new Error(`IMAP inactivity timeout (${this.inactivityTimeout / 1000}s): ${command.split("\r")[0].substring(0, 80)}`));
+            };
+            this.commandTimer = setTimeout(onTimeout, this.inactivityTimeout);
             this.pendingCommand = {
                 tag, responses: [],
-                resolve: (responses) => { clearTimeout(timer); resolve(responses); },
-                reject: (err) => { clearTimeout(timer); reject(err); },
+                resolve: (responses) => { if (this.commandTimer)
+                    clearTimeout(this.commandTimer); this.commandTimer = null; resolve(responses); },
+                reject: (err) => { if (this.commandTimer)
+                    clearTimeout(this.commandTimer); this.commandTimer = null; reject(err); },
             };
-            this.transport.write(command).catch((err) => { clearTimeout(timer); reject(err); });
+            this.transport.write(command).catch((err) => { if (this.commandTimer)
+                clearTimeout(this.commandTimer); this.commandTimer = null; reject(err); });
         });
     }
     waitForContinuation(tag) {
@@ -464,6 +489,19 @@ export class NativeImapClient {
         });
     }
     handleData(data) {
+        // Reset inactivity timer — data is flowing, connection is alive
+        if (this.commandTimer) {
+            clearTimeout(this.commandTimer);
+            this.commandTimer = setTimeout(() => {
+                this.commandTimer = null;
+                if (this.pendingCommand) {
+                    const cmd = this.pendingCommand;
+                    this.pendingCommand = null;
+                    this.transport.close?.();
+                    cmd.reject(new Error(`IMAP inactivity timeout (${this.inactivityTimeout / 1000}s)`));
+                }
+            }, this.inactivityTimeout);
+        }
         this.buffer += data;
         this.processBuffer();
     }

package/imaplib/node-transport.d.ts

@@ -5,6 +5,7 @@
 import type { ImapTransport } from "./transport.js";
 export declare class NodeTransport implements ImapTransport {
     private socket;
+    private decoder;
     private dataHandler;
     private closeHandler;
     private errorHandler;

package/imaplib/node-transport.js

@@ -4,8 +4,10 @@
  */
 import * as net from "node:net";
 import * as tls from "node:tls";
+import { StringDecoder } from "node:string_decoder";
 export class NodeTransport {
     socket = null;
+    decoder = new StringDecoder("utf-8");
     dataHandler = null;
     closeHandler = null;
     errorHandler = null;
@@ -40,7 +42,7 @@ export class NodeTransport {
             // Wire up persistent handlers after connect
             this.socket.on("data", (chunk) => {
                 if (this.dataHandler)
-                    this.dataHandler(chunk.toString("utf-8"));
+                    this.dataHandler(this.decoder.write(chunk));
             });
             this.socket.on("close", (hadError) => {
                 this._connected = false;
@@ -64,10 +66,11 @@ export class NodeTransport {
                 rejectUnauthorized: this.rejectUnauthorized,
             }, () => {
                 this.socket = tlsSocket;
+                this.decoder = new StringDecoder("utf-8");
                 // Re-wire data handler to new socket
                 tlsSocket.on("data", (chunk) => {
                     if (this.dataHandler)
-                        this.dataHandler(chunk.toString("utf-8"));
+                        this.dataHandler(this.decoder.write(chunk));
                 });
                 tlsSocket.on("close", (hadError) => {
                     this._connected = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/iflow",
-  "version": "1.0.52",
+  "version": "1.0.54",
   "description": "IMAP client wrapper library",
   "main": "index.js",
   "types": "index.ts",