@bobfrankston/iflow-direct 0.1.30 → 0.1.32

package/imap-native.js

@@ -771,29 +771,79 @@ export class NativeImapClient {
             if (this.verbose && !command.includes("LOGIN") && !command.includes("AUTHENTICATE")) {
                 console.log(`  [imap] > ${command.trimEnd()}`);
             }
+            // Snapshot transport diagnostics — used by both heartbeat and timeout.
+            const transportDiag = () => {
+                try {
+                    const d = this.transport?.diagnostics;
+                    if (!d)
+                        return "";
+                    const sinceRead = d.lastReadAt ? Date.now() - d.lastReadAt : -1;
+                    return ` [conn#${d.connId} r=${d.bytesRead}B w=${d.bytesWritten}B writes=${d.writeCount} sinceLastRead=${sinceRead}ms]`;
+                }
+                catch {
+                    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;
+            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 = () => {
                 this.commandTimer = null;
                 this.pendingCommand = null;
+                if (heartbeatTimer) {
+                    clearInterval(heartbeatTimer);
+                    heartbeatTimer = 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): ${command.split("\r")[0].substring(0, 80)}`));
+                reject(new Error(`IMAP inactivity timeout (${this.inactivityTimeout / 1000}s): ${cmdSummary}${transportDiag()}`));
             };
             this.commandTimer = setTimeout(onTimeout, this.inactivityTimeout);
+            const clearTimers = () => {
+                if (this.commandTimer) {
+                    clearTimeout(this.commandTimer);
+                    this.commandTimer = null;
+                }
+                if (heartbeatTimer) {
+                    clearInterval(heartbeatTimer);
+                    heartbeatTimer = null;
+                }
+            };
             this.pendingCommand = {
                 tag, responses: [],
-                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); },
+                resolve: (responses) => { clearTimers(); resolve(responses); },
+                reject: (err) => { clearTimers(); reject(err); },
                 onUntagged,
             };
+            // PRE-WRITE HEALTH CHECK — verify the socket is in a writable
+            // state BEFORE we burn the inactivityTimeout window waiting for
+            // a reply that can't come. socket-half-closed (peer FIN'd) and
+            // destroyed states both fail fast here instead of after 300s.
+            try {
+                const h = this.transport?.socketHealth;
+                if (h && (h.destroyed || h.writableEnded || !h.writable)) {
+                    clearTimers();
+                    this.pendingCommand = null;
+                    this._connected = false;
+                    reject(new Error(`IMAP socket dead before write: destroyed=${h.destroyed} writableEnded=${h.writableEnded} writable=${h.writable}${transportDiag()}`));
+                    return;
+                }
+            }
+            catch { /* transport may not expose socketHealth — fall through */ }
             this.transport.write(command).catch((err) => {
-                if (this.commandTimer)
-                    clearTimeout(this.commandTimer);
-                this.commandTimer = null;
+                clearTimers();
                 // 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

package/package.json

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