@bobfrankston/iflow-direct 0.1.32 → 0.1.34

package/imap-native.d.ts

@@ -48,7 +48,15 @@ export declare class NativeImapClient {
     private transport;
     private transportFactory;
     private config;
+    /** Receive buffer + read offset. CRITICAL: never reassign with
+     *  `this.buffer = this.buffer.substring(N)` — that copies the whole
+     *  remainder per line and is O(n²) over a multi-line response (a 457KB
+     *  LIST response actually blocked the daemon's event loop for 10 minutes
+     *  in production). Use bufferOffset to advance the read cursor; only
+     *  compact the buffer string when the consumed portion is >= half its
+     *  length, keeping per-line work O(1). */
     private buffer;
+    private bufferOffset;
     private pendingCommand;
     private capabilities;
     private _connected;
@@ -173,6 +181,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;
+    /** Hard wall-clock cap per command (independent of inactivityTimeout).
+     *  A pathological server that returns one byte every (inactivityTimeout-1)
+     *  seconds would otherwise defer the inactivity timer forever; this is
+     *  the absolute deadline that always fires. Default 5 minutes. */
+    private commandWallClockTimeout;
     /** Server-greeting timeout in ms — how long to wait for the server's
      *  initial banner after TCP/TLS connects. Default 10s; bumped to 30s
      *  for slow shared-hosting Dovecot in mailx-imap. */
@@ -198,6 +211,11 @@ export declare class NativeImapClient {
     private waitForContinuation;
     private waitForTagged;
     private handleData;
+    /** Compact the buffer when bufferOffset has advanced past half. Cheap
+     *  amortized cost; eliminates the O(n²) substring-each-line antipattern
+     *  that synchronously blocked the daemon for 10 minutes on a large LIST
+     *  response. */
+    private compactBufferIfNeeded;
     private processBuffer;
     private handleUntaggedResponse;
     private parseFetchResponses;

package/imap-native.js

@@ -11,7 +11,15 @@ export class NativeImapClient {
     transport;
     transportFactory;
     config;
+    /** Receive buffer + read offset. CRITICAL: never reassign with
+     *  `this.buffer = this.buffer.substring(N)` — that copies the whole
+     *  remainder per line and is O(n²) over a multi-line response (a 457KB
+     *  LIST response actually blocked the daemon's event loop for 10 minutes
+     *  in production). Use bufferOffset to advance the read cursor; only
+     *  compact the buffer string when the consumed portion is >= half its
+     *  length, keeping per-line work O(1). */
     buffer = "";
+    bufferOffset = 0;
     pendingCommand = null;
     capabilities = new Set();
     _connected = false;
@@ -32,6 +40,10 @@ export class NativeImapClient {
         this.transport = transportFactory();
         this.verbose = config.verbose || false;
         this.inactivityTimeout = config.inactivityTimeout ?? 60000;
+        // Hard wall-clock deadline per command (default 5 min). Distinct
+        // from inactivityTimeout — that one resets on each data chunk and
+        // can be deferred indefinitely by a slow-trickling server.
+        this.commandWallClockTimeout = config.commandWallClockTimeout ?? 300_000;
         this.fetchChunkSize = config.fetchChunkSize ?? 25;
         this.fetchChunkSizeMax = config.fetchChunkSizeMax ?? 500;
         this.greetingTimeout = config.greetingTimeout ?? 10000;
@@ -729,6 +741,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;
+    /** Hard wall-clock cap per command (independent of inactivityTimeout).
+     *  A pathological server that returns one byte every (inactivityTimeout-1)
+     *  seconds would otherwise defer the inactivity timer forever; this is
+     *  the absolute deadline that always fires. Default 5 minutes. */
+    commandWallClockTimeout;
     /** Server-greeting timeout in ms — how long to wait for the server's
      *  initial banner after TCP/TLS connects. Default 10s; bumped to 30s
      *  for slow shared-hosting Dovecot in mailx-imap. */
@@ -796,21 +813,39 @@ export class NativeImapClient {
                 const waited = Date.now() - cmdStart;
                 console.log(`  [imap] still waiting for tag ${tag} after ${(waited / 1000).toFixed(1)}s — ${cmdSummary}${transportDiag()}`);
             }, HEARTBEAT_INTERVAL_MS);
-            const onTimeout = () => {
+            const onTimeout = (kind) => {
                 this.commandTimer = null;
                 this.pendingCommand = null;
                 if (heartbeatTimer) {
                     clearInterval(heartbeatTimer);
                     heartbeatTimer = null;
                 }
+                if (wallClockTimer) {
+                    clearTimeout(wallClockTimer);
+                    wallClockTimer = null;
+                }
                 // Kill the connection — a timed-out connection has stale data in the pipe.
                 // Mark disconnected so ensureConnected() reconnects on the next call —
                 // transport.close() may or may not fire onClose synchronously.
                 this._connected = false;
                 this.transport.close?.();
-                reject(new Error(`IMAP inactivity timeout (${this.inactivityTimeout / 1000}s): ${cmdSummary}${transportDiag()}`));
+                reject(new Error(`${kind}: ${cmdSummary}${transportDiag()}`));
             };
-            this.commandTimer = setTimeout(onTimeout, this.inactivityTimeout);
+            // Two timers, two responsibilities:
+            //   commandTimer = "no bytes for N seconds" — handleData resets it
+            //                  on every chunk so a steadily-streaming FETCH
+            //                  doesn't get killed mid-flight.
+            //   wallClockTimer = "this command has been pending too long
+            //                  total" — fires regardless of trickling bytes.
+            //                  Catches the pathological case where a server
+            //                  drips one byte every <inactivityTimeout> seconds
+            //                  for hours (real bobma bug we hit overnight:
+            //                  3 connections wedged 2-3 hours each because
+            //                  the inactivity reset kept deferring the only
+            //                  timer in play).
+            this.commandTimer = setTimeout(() => onTimeout(`IMAP inactivity timeout (${this.inactivityTimeout / 1000}s)`), this.inactivityTimeout);
+            const COMMAND_WALL_CLOCK_TIMEOUT_MS = this.commandWallClockTimeout;
+            let wallClockTimer = setTimeout(() => onTimeout(`IMAP command wall-clock timeout (${COMMAND_WALL_CLOCK_TIMEOUT_MS / 1000}s)`), COMMAND_WALL_CLOCK_TIMEOUT_MS);
             const clearTimers = () => {
                 if (this.commandTimer) {
                     clearTimeout(this.commandTimer);
@@ -820,6 +855,10 @@ export class NativeImapClient {
                     clearInterval(heartbeatTimer);
                     heartbeatTimer = null;
                 }
+                if (wallClockTimer) {
+                    clearTimeout(wallClockTimer);
+                    wallClockTimer = null;
+                }
             };
             this.pendingCommand = {
                 tag, responses: [],
@@ -890,6 +929,16 @@ export class NativeImapClient {
         this.buffer += data;
         this.processBuffer();
     }
+    /** Compact the buffer when bufferOffset has advanced past half. Cheap
+     *  amortized cost; eliminates the O(n²) substring-each-line antipattern
+     *  that synchronously blocked the daemon for 10 minutes on a large LIST
+     *  response. */
+    compactBufferIfNeeded() {
+        if (this.bufferOffset > 0 && this.bufferOffset >= this.buffer.length / 2) {
+            this.buffer = this.buffer.substring(this.bufferOffset);
+            this.bufferOffset = 0;
+        }
+    }
     processBuffer() {
         while (true) {
             // Check for literal {size}\r\n — reading exact BYTE count of literal data
@@ -898,16 +947,20 @@ export class NativeImapClient {
             // We must use byte-accurate extraction (TextEncoder for browser, Buffer for Node).
             if (this.pendingCommand?.literalBytes != null) {
                 const neededBytes = this.pendingCommand.literalBytes;
-                const encoded = new TextEncoder().encode(this.buffer);
+                // Encode only the unread portion — was encoding the whole
+                // buffer (including already-consumed bytes) on every literal,
+                // which on a multi-MB buffer is a non-trivial chunk of work.
+                const unread = this.bufferOffset === 0 ? this.buffer : this.buffer.substring(this.bufferOffset);
+                const encoded = new TextEncoder().encode(unread);
                 const bufferBytes = encoded.byteLength;
                 if (bufferBytes >= neededBytes) {
                     const literal_bytes = encoded.subarray(0, neededBytes);
                     const rest_bytes = encoded.subarray(neededBytes);
                     let literal = new TextDecoder().decode(literal_bytes);
+                    // Reset buffer to just the rest — bufferOffset goes back
+                    // to 0 since we replaced the buffer content.
                     this.buffer = new TextDecoder().decode(rest_bytes);
-                    // if (neededBytes !== literal.length) {
-                    //     console.log(`iflow-direct:  [imap] literal: ${neededBytes} bytes → ${literal.length} chars (multi-byte corrected)`);
-                    // }
+                    this.bufferOffset = 0;
                     // For non-BODY literals (e.g. display names in ENVELOPE), wrap in quotes
                     // so tokenizeParenList treats them as a single token
                     if (!this.pendingCommand.currentLiteralKey) {
@@ -935,11 +988,23 @@ export class NativeImapClient {
                 }
                 break; // Wait for more data
             }
-            const lineEnd = this.buffer.indexOf("\r\n");
-            if (lineEnd < 0)
+            // Find next CRLF starting from the read offset (NOT from 0 —
+            // the bytes before bufferOffset are already consumed and
+            // searching them is dead work that scales with response size).
+            const lineEnd = this.buffer.indexOf("\r\n", this.bufferOffset);
+            if (lineEnd < 0) {
+                // No complete line yet. Compact the buffer if we've advanced
+                // far enough that the unconsumed-prefix is dragging.
+                this.compactBufferIfNeeded();
                 break;
-            const line = this.buffer.substring(0, lineEnd + 2);
-            this.buffer = this.buffer.substring(lineEnd + 2);
+            }
+            // Extract the line and advance the read cursor — no substring
+            // copy of the remainder, no buffer reallocation.
+            const line = this.buffer.substring(this.bufferOffset, lineEnd + 2);
+            this.bufferOffset = lineEnd + 2;
+            // Periodic compaction so the consumed prefix doesn't keep
+            // growing forever in long-running connections (IDLE, big sync).
+            this.compactBufferIfNeeded();
             // Check for literal announcement {size}\r\n at end of line
             const literalMatch = line.match(/\{(\d+)\}\r\n$/);
             if (literalMatch && this.pendingCommand) {

package/package.json

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

package/types.d.ts

@@ -11,6 +11,7 @@ export interface ImapClientConfig {
     verbose?: boolean;
     rejectUnauthorized?: boolean;
     inactivityTimeout?: number;
+    commandWallClockTimeout?: number;
     fetchChunkSize?: number;
     fetchChunkSizeMax?: number;
     greetingTimeout?: number;