@bobfrankston/iflow-direct 0.1.18 → 0.1.19

package/README.md

@@ -106,6 +106,16 @@ the same connection). Suspend sends DONE, awaits the tagged OK, runs the
 command, then re-enters IDLE. If the caller stops IDLE (via the `startIdle`
 stop function) during the command, IDLE is not re-entered.
 
+## Connection liveness
+
+`NativeImapClient.connected` (and `CompatImapClient`'s lazy `ensureConnected`
+path, which now delegates to it) is authoritative: it gets cleared on transport
+error, transport close, inactivity-timeout socket kill, and write failure. Any
+of those paths also drops IDLE state so auto-suspend doesn't try to DONE a dead
+socket. Callers that detect connection-style errors (e.g. DNS "hostname not
+known" from a dead Android socket) can safely retry — the next operation will
+reconnect from scratch rather than reusing the dead socket.
+
 ## Configuration
 
 `ImapClientConfig` fields relevant to throughput/resilience:

package/imap-compat.d.ts

@@ -23,11 +23,15 @@ export interface SpecialFolders {
  */
 export declare class CompatImapClient {
     private native;
-    private _connected;
     constructor(config: ImapClientConfig, transportFactory: TransportFactory);
     /** Connect and authenticate */
     connect(): Promise<void>;
-    /** Ensure connected (lazy connect) */
+    /**
+     * Ensure connected (lazy connect). Delegates to the native client's
+     * `connected` flag, which is cleared by transport close/error, inactivity
+     * timeout, and write failures — so a silently dead socket reconnects on the
+     * next call instead of cascading ENOTFOUND across every folder.
+     */
     private ensureConnected;
     logout(): Promise<void>;
     /** Get folder list */

package/imap-compat.js

@@ -11,22 +11,24 @@ import { FetchedMessage } from "./fetched-message.js";
  */
 export class CompatImapClient {
     native;
-    _connected = false;
     constructor(config, transportFactory) {
         this.native = new NativeImapClient(config, transportFactory);
     }
     /** Connect and authenticate */
     async connect() {
         await this.native.connect();
-        this._connected = true;
     }
-    /** Ensure connected (lazy connect) */
+    /**
+     * Ensure connected (lazy connect). Delegates to the native client's
+     * `connected` flag, which is cleared by transport close/error, inactivity
+     * timeout, and write failures — so a silently dead socket reconnects on the
+     * next call instead of cascading ENOTFOUND across every folder.
+     */
     async ensureConnected() {
-        if (!this._connected)
+        if (!this.native.connected)
             await this.connect();
     }
     async logout() {
-        this._connected = false;
         await this.native.logout();
     }
     /** Get folder list */

package/imap-native.js

@@ -42,7 +42,14 @@ export class NativeImapClient {
         this.transport.onData((data) => this.handleData(data));
         this.transport.onClose(() => {
             this._connected = false;
-            // Reject any pending command so it doesn't hang forever
+            // Drop stale IDLE state — the socket is gone.
+            this.idleTag = null;
+            this.idleCallback = null;
+            this.idleStopped = true;
+            if (this.idleRefreshTimer) {
+                clearTimeout(this.idleRefreshTimer);
+                this.idleRefreshTimer = null;
+            }
             if (this.pendingCommand) {
                 const { reject } = this.pendingCommand;
                 this.pendingCommand = null;
@@ -52,7 +59,18 @@ export class NativeImapClient {
         this.transport.onError((err) => {
             if (this.verbose)
                 console.error(`  [imap] Transport error: ${err.message}`);
-            // Reject any pending command on transport error
+            // Transport errors (DNS failure, ECONNRESET, TLS failure, etc.) mean
+            // the connection is dead — clear the flag so ensureConnected() will
+            // reconnect on the next call, and drop the stale IDLE state so we
+            // don't try to DONE a dead socket during auto-suspend.
+            this._connected = false;
+            this.idleTag = null;
+            this.idleCallback = null;
+            this.idleStopped = true;
+            if (this.idleRefreshTimer) {
+                clearTimeout(this.idleRefreshTimer);
+                this.idleRefreshTimer = null;
+            }
             if (this.pendingCommand) {
                 const { reject } = this.pendingCommand;
                 this.pendingCommand = null;
@@ -674,7 +692,10 @@ export class NativeImapClient {
             const onTimeout = () => {
                 this.commandTimer = null;
                 this.pendingCommand = null;
-                // Kill the connection — a timed-out connection has stale data in the pipe
+                // 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)}`));
             };
@@ -687,8 +708,18 @@ export class NativeImapClient {
                     clearTimeout(this.commandTimer); this.commandTimer = null; reject(err); },
                 onUntagged,
             };
-            this.transport.write(command).catch((err) => { if (this.commandTimer)
-                clearTimeout(this.commandTimer); this.commandTimer = null; reject(err); });
+            this.transport.write(command).catch((err) => {
+                if (this.commandTimer)
+                    clearTimeout(this.commandTimer);
+                this.commandTimer = null;
+                // 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
+                // (the source of the "hostname nor servname provided" cascade).
+                this.pendingCommand = null;
+                this._connected = false;
+                reject(err);
+            });
         });
     }
     waitForContinuation(tag) {
@@ -718,6 +749,7 @@ export class NativeImapClient {
                 if (this.pendingCommand) {
                     const cmd = this.pendingCommand;
                     this.pendingCommand = null;
+                    this._connected = false;
                     this.transport.close?.();
                     cmd.reject(new Error(`IMAP inactivity timeout (${this.inactivityTimeout / 1000}s)`));
                 }

package/package.json

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