@bobfrankston/iflow-direct 0.1.18 → 0.1.20

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). Checks both the native client's connected
+     * flag AND the transport's connected state. The transport flag catches cases
+     * where the socket died without a close/error event reaching NativeImapClient
+     * (common on Android where the bridge may not relay all TCP events).
+     */
     private ensureConnected;
     logout(): Promise<void>;
     /** Get folder list */

package/imap-compat.js

@@ -11,22 +11,27 @@ 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). Checks both the native client's connected
+     * flag AND the transport's connected state. The transport flag catches cases
+     * where the socket died without a close/error event reaching NativeImapClient
+     * (common on Android where the bridge may not relay all TCP events).
+     */
     async ensureConnected() {
-        if (!this._connected)
+        if (!this.native.connected || !this.native.transportConnected) {
+            // Force a fresh transport — the old one may be in a bad state.
+            this.native.resetTransport();
             await this.connect();
+        }
     }
     async logout() {
-        this._connected = false;
         await this.native.logout();
     }
     /** Get folder list */

package/imap-native.d.ts

@@ -65,6 +65,11 @@ export declare class NativeImapClient {
     private continuationResolve;
     constructor(config: ImapClientConfig, transportFactory: TransportFactory);
     get connected(): boolean;
+    /** Check the underlying transport's connected state — catches silently dead sockets. */
+    get transportConnected(): boolean;
+    /** Replace the transport with a fresh one from the factory. Call before reconnect
+     *  when the old transport is in a bad state (dead socket, stale bridge stream). */
+    resetTransport(): void;
     connect(): Promise<void>;
     private readGreeting;
     private authenticate;

package/imap-native.js

@@ -36,13 +36,35 @@ export class NativeImapClient {
         this.fetchChunkSizeMax = config.fetchChunkSizeMax ?? 500;
     }
     get connected() { return this._connected; }
+    /** Check the underlying transport's connected state — catches silently dead sockets. */
+    get transportConnected() { return this.transport?.connected ?? false; }
+    /** Replace the transport with a fresh one from the factory. Call before reconnect
+     *  when the old transport is in a bad state (dead socket, stale bridge stream). */
+    resetTransport() {
+        try {
+            this.transport?.close?.();
+        }
+        catch { /* ignore */ }
+        this.transport = this.transportFactory();
+        this._connected = false;
+        this.buffer = "";
+        this.pendingCommand = null;
+        this.selectedMailbox = null;
+    }
     // ── Connection ──
     async connect() {
         const useTls = this.config.port === 993;
         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 +74,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 +707,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 +723,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 +764,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.20",
   "description": "Direct IMAP client — transport-agnostic, no Node.js dependencies, browser-ready",
   "main": "index.js",
   "types": "index.ts",