@bobfrankston/iflow-direct 0.1.34 → 0.1.35

package/imap-native.d.ts

@@ -71,6 +71,13 @@ export declare class NativeImapClient {
     private greetingResolve;
     /** Callback for waitForContinuation — set when waiting for "+" response */
     private continuationResolve;
+    /** Per-command heartbeat (30s). Hoisted to instance state so any path
+     *  that swaps pendingCommand can clear it cleanly — closure-scoped
+     *  timers leaked when handleData's inline replacement or IDLE
+     *  suspend/resume bypassed sendCommandCore's resolve/reject closures. */
+    private heartbeatTimer;
+    /** Hard wall-clock cap per command. Same hoist for the same reason. */
+    private wallClockTimer;
     constructor(config: ImapClientConfig, transportFactory: TransportFactory);
     get connected(): boolean;
     /** Check the underlying transport's connected state — catches silently dead sockets. */
@@ -211,6 +218,12 @@ export declare class NativeImapClient {
     private waitForContinuation;
     private waitForTagged;
     private handleData;
+    /** Single canonical "command finished or abandoned" cleanup. Every
+     *  path that ends a command's lifecycle — resolve, reject, timeout,
+     *  socket close, command-replace — calls this. Was a leak source:
+     *  closure-scoped timers in sendCommandCore couldn't be cleared from
+     *  handleData's inline-replacement timer or from IDLE suspend/resume. */
+    private clearAllCommandTimers;
     /** 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

package/imap-native.js

@@ -34,16 +34,29 @@ export class NativeImapClient {
     greetingResolve = null;
     /** Callback for waitForContinuation — set when waiting for "+" response */
     continuationResolve = null;
+    /** Per-command heartbeat (30s). Hoisted to instance state so any path
+     *  that swaps pendingCommand can clear it cleanly — closure-scoped
+     *  timers leaked when handleData's inline replacement or IDLE
+     *  suspend/resume bypassed sendCommandCore's resolve/reject closures. */
+    heartbeatTimer = null;
+    /** Hard wall-clock cap per command. Same hoist for the same reason. */
+    wallClockTimer = null;
     constructor(config, transportFactory) {
         this.config = config;
         this.transportFactory = transportFactory;
         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;
+        // Hard wall-clock deadline per command. Distinct from inactivityTimeout
+        // — that one resets on each data chunk and can be deferred indefinitely
+        // by a slow-trickling server. Default 90s: in production we see
+        // connections silently die with sinceLastRead climbing for 50s+ on
+        // FETCH; 5 min was leaving them wedged for too long, blocking sync /
+        // prefetch / new-mail behind a dead socket. 90s lets a slow but
+        // genuine FETCH complete (Sent in isolation: 26ms; even a 50-message
+        // FETCH was <1s) while killing dead sockets aggressively. Override
+        // via ImapClientConfig.commandWallClockTimeout for known-slow servers.
+        this.commandWallClockTimeout = config.commandWallClockTimeout ?? 90_000;
         this.fetchChunkSize = config.fetchChunkSize ?? 25;
         this.fetchChunkSizeMax = config.fetchChunkSizeMax ?? 500;
         this.greetingTimeout = config.greetingTimeout ?? 10000;
@@ -61,8 +74,13 @@ export class NativeImapClient {
         this.transport = this.transportFactory();
         this._connected = false;
         this.buffer = "";
+        this.bufferOffset = 0;
         this.pendingCommand = null;
         this.selectedMailbox = null;
+        // Old socket is gone — kill any timers still running for the
+        // command that was on it. Without this, a stale heartbeat/wall-clock
+        // continues firing into a transport that no longer exists.
+        this.clearAllCommandTimers();
     }
     // ── Connection ──
     async connect() {
@@ -78,6 +96,10 @@ export class NativeImapClient {
                 clearTimeout(this.idleRefreshTimer);
                 this.idleRefreshTimer = null;
             }
+            // Kill any per-command timers — the connection is gone, no
+            // command on it can ever complete. Otherwise heartbeat keeps
+            // firing for a connection that no longer exists.
+            this.clearAllCommandTimers();
             if (this.pendingCommand) {
                 const { reject } = this.pendingCommand;
                 this.pendingCommand = null;
@@ -801,69 +823,33 @@ export class NativeImapClient {
                     return "";
                 }
             };
-            // HEARTBEAT_INTERVAL_MS — periodic progress log while a command
-            // is pending. Catches wedges in flight rather than only at the
-            // 300s timeout edge. Key signal: if `sinceLastRead` keeps
-            // climbing, the socket is silently dead. If reads are happening
-            // but the tagged OK never arrives, the parser is stuck.
-            const HEARTBEAT_INTERVAL_MS = 30_000;
+            // Always start clean — defends against a prior pendingCommand
+            // having leaked timers (e.g. swap by suspendIdle/resumeIdle that
+            // bypassed resolve/reject).
+            this.clearAllCommandTimers();
             const cmdStart = Date.now();
             const cmdSummary = command.split("\r")[0].substring(0, 80);
-            let heartbeatTimer = setInterval(() => {
-                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 = (kind) => {
-                this.commandTimer = null;
+                this.clearAllCommandTimers();
                 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(`${kind}: ${cmdSummary}${transportDiag()}`));
             };
-            // 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).
+            // Three timers, three responsibilities — all instance-scoped now:
+            //   commandTimer  = inactivity (resets on each data chunk)
+            //   wallClockTimer = hard cap from command start, never resets
+            //   heartbeatTimer = periodic progress log every 30s
             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);
-                    this.commandTimer = null;
-                }
-                if (heartbeatTimer) {
-                    clearInterval(heartbeatTimer);
-                    heartbeatTimer = null;
-                }
-                if (wallClockTimer) {
-                    clearTimeout(wallClockTimer);
-                    wallClockTimer = null;
-                }
-            };
+            this.wallClockTimer = setTimeout(() => onTimeout(`IMAP command wall-clock timeout (${this.commandWallClockTimeout / 1000}s)`), this.commandWallClockTimeout);
+            this.heartbeatTimer = setInterval(() => {
+                const waited = Date.now() - cmdStart;
+                console.log(`  [imap] still waiting for tag ${tag} after ${(waited / 1000).toFixed(1)}s — ${cmdSummary}${transportDiag()}`);
+            }, 30_000);
             this.pendingCommand = {
                 tag, responses: [],
-                resolve: (responses) => { clearTimers(); resolve(responses); },
-                reject: (err) => { clearTimers(); reject(err); },
+                resolve: (responses) => { this.clearAllCommandTimers(); resolve(responses); },
+                reject: (err) => { this.clearAllCommandTimers(); reject(err); },
                 onUntagged,
             };
             // PRE-WRITE HEALTH CHECK — verify the socket is in a writable
@@ -873,7 +859,7 @@ export class NativeImapClient {
             try {
                 const h = this.transport?.socketHealth;
                 if (h && (h.destroyed || h.writableEnded || !h.writable)) {
-                    clearTimers();
+                    this.clearAllCommandTimers();
                     this.pendingCommand = null;
                     this._connected = false;
                     reject(new Error(`IMAP socket dead before write: destroyed=${h.destroyed} writableEnded=${h.writableEnded} writable=${h.writable}${transportDiag()}`));
@@ -882,7 +868,7 @@ export class NativeImapClient {
             }
             catch { /* transport may not expose socketHealth — fall through */ }
             this.transport.write(command).catch((err) => {
-                clearTimers();
+                this.clearAllCommandTimers();
                 // Write failure = dead socket. Clear pendingCommand + disconnect flag
                 // so the next ensureConnected() does a fresh connect instead of
                 // reusing a socket that the OS layer has already declared dead
@@ -912,7 +898,10 @@ export class NativeImapClient {
         });
     }
     handleData(data) {
-        // Reset inactivity timer — data is flowing, connection is alive
+        // Reset inactivity timer ONLY (heartbeat + wall-clock NEVER reset
+        // on data — that was the original bug: wall-clock got reset every
+        // byte, so a slow-trickling server's command never died). Inactivity
+        // is "no data for N seconds"; data IS arriving, so push it out.
         if (this.commandTimer) {
             clearTimeout(this.commandTimer);
             this.commandTimer = setTimeout(() => {
@@ -920,6 +909,11 @@ export class NativeImapClient {
                 if (this.pendingCommand) {
                     const cmd = this.pendingCommand;
                     this.pendingCommand = null;
+                    // Use the canonical clear so heartbeat + wall-clock
+                    // also stop. cmd.reject runs clearAllCommandTimers via
+                    // the closure binding — call it directly here too in
+                    // case cmd.reject was already replaced (defense in depth).
+                    this.clearAllCommandTimers();
                     this._connected = false;
                     this.transport.close?.();
                     cmd.reject(new Error(`IMAP inactivity timeout (${this.inactivityTimeout / 1000}s)`));
@@ -929,6 +923,25 @@ export class NativeImapClient {
         this.buffer += data;
         this.processBuffer();
     }
+    /** Single canonical "command finished or abandoned" cleanup. Every
+     *  path that ends a command's lifecycle — resolve, reject, timeout,
+     *  socket close, command-replace — calls this. Was a leak source:
+     *  closure-scoped timers in sendCommandCore couldn't be cleared from
+     *  handleData's inline-replacement timer or from IDLE suspend/resume. */
+    clearAllCommandTimers() {
+        if (this.commandTimer) {
+            clearTimeout(this.commandTimer);
+            this.commandTimer = null;
+        }
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.wallClockTimer) {
+            clearTimeout(this.wallClockTimer);
+            this.wallClockTimer = null;
+        }
+    }
     /** 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

package/package.json

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