@bobfrankston/iflow-direct 0.1.49 → 0.1.51

package/imap-compat.d.ts

@@ -160,6 +160,7 @@ export declare class CompatImapClient {
     watchMailbox(mailbox: string, onNew: (count: number) => void, opts?: {
         notifySpec?: string;
         onMailboxStatus?: (mailbox: string, data: proto.StatusData) => void;
+        onExpunge?: () => void;
     }): Promise<() => Promise<void>>;
     /** Copy a message to another server (cross-account) */
     moveMessageToServer(msg: any, fromMailbox: string, targetClient: CompatImapClient, toMailbox: string): Promise<void>;

package/imap-compat.js

@@ -349,7 +349,7 @@ export class CompatImapClient {
             this.native.onMailboxStatus = opts.onMailboxStatus;
         if (opts?.notifySpec)
             await this.native.notify(opts.notifySpec);
-        return this.native.startIdle(onNew);
+        return this.native.startIdle(onNew, opts?.onExpunge);
     }
     /** Copy a message to another server (cross-account) */
     async moveMessageToServer(msg, fromMailbox, targetClient, toMailbox) {

package/imap-native.d.ts

@@ -113,6 +113,12 @@ export declare class NativeImapClient {
     private _connected;
     private idleTag;
     private idleCallback;
+    /** Fires when the SELECTED mailbox loses messages while parked in IDLE —
+     *  an EXISTS decrease, or an unsolicited `* EXPUNGE` / `* VANISHED`
+     *  (RFC 5465 NOTIFY SELECTED MessageExpunge). Lets the caller reconcile
+     *  a server-side deletion in real time instead of waiting for the next
+     *  periodic poll. Distinct from `idleCallback` (new mail only). */
+    private idleExpungeCallback;
     private idleRefreshTimer;
     /** RFC 5465 NOTIFY: fires on unsolicited STATUS responses for non-selected
      *  mailboxes (the server pushes these when the client has issued NOTIFY
@@ -257,7 +263,7 @@ export declare class NativeImapClient {
      *  SELECT and BEFORE startIdle — the server holds the spec for the
      *  lifetime of the connection. */
     notify(spec: string): Promise<void>;
-    startIdle(onNewMail: (count: number) => void): Promise<() => Promise<void>>;
+    startIdle(onNewMail: (count: number) => void, onExpunge?: () => void): Promise<() => Promise<void>>;
     /**
      * If IDLE is currently active, send DONE and wait for its tagged OK so the
      * connection is free to accept a new command. Saves the active callback so

package/imap-native.js

@@ -39,6 +39,12 @@ export class NativeImapClient {
     _connected = false;
     idleTag = null;
     idleCallback = null;
+    /** Fires when the SELECTED mailbox loses messages while parked in IDLE —
+     *  an EXISTS decrease, or an unsolicited `* EXPUNGE` / `* VANISHED`
+     *  (RFC 5465 NOTIFY SELECTED MessageExpunge). Lets the caller reconcile
+     *  a server-side deletion in real time instead of waiting for the next
+     *  periodic poll. Distinct from `idleCallback` (new mail only). */
+    idleExpungeCallback = null;
     idleRefreshTimer = null;
     /** RFC 5465 NOTIFY: fires on unsolicited STATUS responses for non-selected
      *  mailboxes (the server pushes these when the client has issued NOTIFY
@@ -126,8 +132,29 @@ export class NativeImapClient {
             }
         });
         this.transport.onError((err) => {
+            // Diagnose transport-level errors fully. Node emits socket errors
+            // with a populated `.message` in normal cases (ECONNRESET, ETIMEDOUT,
+            // etc.) — but TLS-layer errors, abrupt FINs surfaced as errors,
+            // and some wrapper paths produce an Error with empty `.message`
+            // and the useful info on `.code` / `.errno` / `.syscall` instead.
+            // Logging only `.message` left "Transport error: " in the log
+            // with no diagnostic content, which masked why bobma INBOX prefetch
+            // kept dying (2026-05-27). Build a richer description.
+            const errAny = err;
+            const parts = [];
+            if (errAny?.message)
+                parts.push(String(errAny.message));
+            if (errAny?.code)
+                parts.push(`code=${errAny.code}`);
+            if (errAny?.errno !== undefined)
+                parts.push(`errno=${errAny.errno}`);
+            if (errAny?.syscall)
+                parts.push(`syscall=${errAny.syscall}`);
+            const desc = parts.length > 0
+                ? parts.join(" ")
+                : `<no message> ${typeof err} ${err?.constructor?.name || ""}`.trim();
             if (this.verbose)
-                console.error(`  [imap] Transport error: ${err.message}`);
+                console.error(`  [imap] Transport error: ${desc}`);
             // 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
@@ -143,7 +170,17 @@ export class NativeImapClient {
             if (this.pendingCommand) {
                 const { reject } = this.pendingCommand;
                 this.pendingCommand = null;
-                reject(err);
+                // Make sure the error that propagates to upper-layer catches
+                // (prefetch, sync, etc.) has a non-empty message — wrap if
+                // the underlying err has a blank message.
+                if (err instanceof Error && !err.message) {
+                    const wrapped = new Error(desc);
+                    wrapped.cause = err;
+                    reject(wrapped);
+                }
+                else {
+                    reject(err);
+                }
             }
         });
         await this.transport.connect(this.config.server, this.config.port, useTls, this.config.server);
@@ -731,8 +768,9 @@ export class NativeImapClient {
         }
     }
     // ── IDLE ──
-    async startIdle(onNewMail) {
+    async startIdle(onNewMail, onExpunge) {
         this.idleCallback = onNewMail;
+        this.idleExpungeCallback = onExpunge ?? null;
         this.idleStopped = false;
         const beginIdleCycle = async () => {
             const tag = proto.nextTag();
@@ -764,6 +802,7 @@ export class NativeImapClient {
             const tag = this.idleTag;
             this.idleTag = null;
             this.idleCallback = null;
+            this.idleExpungeCallback = null;
             if (tag) {
                 // Arm tagged-wait BEFORE DONE — avoid missing the OK.
                 const waitTag = this.waitForTagged(tag);
@@ -1291,6 +1330,24 @@ export class NativeImapClient {
                     this.mailboxInfo.exists = count;
                     this.idleCallback(newCount);
                 }
+                else if (count < this.mailboxInfo.exists) {
+                    // Count dropped — a message was expunged on the selected
+                    // mailbox (another client / Thunderbird deleted it).
+                    // Signal the caller to reconcile the deletion now.
+                    this.mailboxInfo.exists = count;
+                    if (this.idleExpungeCallback)
+                        this.idleExpungeCallback();
+                }
+                continue;
+            }
+            // During IDLE, an unsolicited `* n EXPUNGE` / `* VANISHED` for the
+            // selected mailbox (RFC 5465 NOTIFY SELECTED MessageExpunge, or a
+            // plain post-EXPUNGE notification). Push a deletion reconcile.
+            if (this.idleTag && resp.tag === "*" && (resp.type === "EXPUNGE" || resp.type === "VANISHED")) {
+                if (this.mailboxInfo.exists > 0)
+                    this.mailboxInfo.exists--;
+                if (this.idleExpungeCallback)
+                    this.idleExpungeCallback();
                 continue;
             }
             // RFC 5465 NOTIFY: unsolicited STATUS responses for non-selected

package/package.json

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