@bobfrankston/iflow-direct 0.1.27 → 0.1.30

package/gmail.d.ts

@@ -12,6 +12,7 @@ export interface GmailOAuthConfig {
     inactivityTimeout?: number;
     fetchChunkSize?: number;
     fetchChunkSizeMax?: number;
+    greetingTimeout?: number;
 }
 /**
  * Check if email address is Gmail
@@ -41,5 +42,6 @@ export declare function createAutoImapConfig(config: {
     inactivityTimeout?: number;
     fetchChunkSize?: number;
     fetchChunkSizeMax?: number;
+    greetingTimeout?: number;
 }): ImapClientConfig;
 //# sourceMappingURL=gmail.d.ts.map

package/gmail.js

@@ -36,6 +36,7 @@ export function createGmailConfig(config) {
         inactivityTimeout: config.inactivityTimeout,
         fetchChunkSize: config.fetchChunkSize,
         fetchChunkSizeMax: config.fetchChunkSizeMax,
+        greetingTimeout: config.greetingTimeout,
     };
 }
 /**
@@ -56,6 +57,7 @@ export function createAutoImapConfig(config) {
             inactivityTimeout: config.inactivityTimeout,
             fetchChunkSize: config.fetchChunkSize,
             fetchChunkSizeMax: config.fetchChunkSizeMax,
+            greetingTimeout: config.greetingTimeout,
         });
     }
     else {
@@ -69,6 +71,7 @@ export function createAutoImapConfig(config) {
             inactivityTimeout: config.inactivityTimeout,
             fetchChunkSize: config.fetchChunkSize,
             fetchChunkSizeMax: config.fetchChunkSizeMax,
+            greetingTimeout: config.greetingTimeout,
         };
     }
 }

package/imap-compat.d.ts

@@ -51,6 +51,13 @@ export declare class CompatImapClient {
     fetchMessageByDate(mailbox: string, start: Date, end?: Date, options?: {
         source?: boolean;
     }, onChunk?: (msgs: FetchedMessage[]) => void): Promise<FetchedMessage[]>;
+    /** Fetch the most recent N messages by sequence number — sidesteps
+     *  SEARCH SINCE which can take minutes on cold Dovecot mailboxes. Used
+     *  by mailx-imap's first-sync path so the user sees something fast even
+     *  on a wide folder tree. The 30-day backfill is a follow-up step. */
+    fetchLatestN(mailbox: string, n: number, options?: {
+        source?: boolean;
+    }, onChunk?: (msgs: FetchedMessage[]) => void): Promise<FetchedMessage[]>;
     /** Fetch a single message by UID */
     fetchMessageByUid(mailbox: string, uid: number, options?: {
         source?: boolean;

package/imap-compat.js

@@ -135,6 +135,18 @@ export class CompatImapClient {
         await this.native.closeMailbox();
         return msgs.map(m => new FetchedMessage(m));
     }
+    /** Fetch the most recent N messages by sequence number — sidesteps
+     *  SEARCH SINCE which can take minutes on cold Dovecot mailboxes. Used
+     *  by mailx-imap's first-sync path so the user sees something fast even
+     *  on a wide folder tree. The 30-day backfill is a follow-up step. */
+    async fetchLatestN(mailbox, n, options, onChunk) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        const chunkCb = onChunk ? (raw) => onChunk(raw.map(m => new FetchedMessage(m))) : undefined;
+        const msgs = await this.native.fetchLatestN(n, options, chunkCb);
+        await this.native.closeMailbox();
+        return msgs.map(m => new FetchedMessage(m));
+    }
     /** Fetch a single message by UID */
     async fetchMessageByUid(mailbox, uid, options) {
         await this.ensureConnected();

package/imap-native.d.ts

@@ -119,6 +119,15 @@ export declare class NativeImapClient {
     fetchByDate(since: Date, before?: Date, options?: {
         source?: boolean;
     }, onChunk?: (msgs: NativeFetchedMessage[]) => void): Promise<NativeFetchedMessage[]>;
+    /** Fetch the most recent N messages by sequence number — avoids
+     *  SEARCH SINCE which can take minutes on cold Dovecot mailboxes. The
+     *  selected mailbox's `EXISTS` count is used to compute the range
+     *  `(EXISTS-N+1):EXISTS`; sequence FETCH is O(1) on the server because
+     *  it just reads message slots, no INTERNALDATE walk. Caller must have
+     *  SELECTed the mailbox first (sequence numbers are session-relative). */
+    fetchLatestN(n: number, options?: {
+        source?: boolean;
+    }, onChunk?: (msgs: NativeFetchedMessage[]) => void): Promise<NativeFetchedMessage[]>;
     /** Fetch a single message by UID */
     fetchMessage(uid: number, options?: {
         source?: boolean;
@@ -164,6 +173,10 @@ export declare class NativeImapClient {
      *  60s accommodates Gmail which is slow on SEARCH for large folders.
      *  Overridable via ImapClientConfig.inactivityTimeout — slow Dovecot servers need 180s+. */
     private inactivityTimeout;
+    /** Server-greeting timeout in ms — how long to wait for the server's
+     *  initial banner after TCP/TLS connects. Default 10s; bumped to 30s
+     *  for slow shared-hosting Dovecot in mailx-imap. */
+    private greetingTimeout;
     /** Fetch chunk sizes — start small for quick first paint, ramp up for throughput.
      *  Default 25 initial → 500 max. Overridable via ImapClientConfig.fetchChunkSize /
      *  fetchChunkSizeMax. Slow servers benefit from smaller chunks (fewer timeouts). */

package/imap-native.js

@@ -34,6 +34,7 @@ export class NativeImapClient {
         this.inactivityTimeout = config.inactivityTimeout ?? 60000;
         this.fetchChunkSize = config.fetchChunkSize ?? 25;
         this.fetchChunkSizeMax = config.fetchChunkSizeMax ?? 500;
+        this.greetingTimeout = config.greetingTimeout ?? 10000;
     }
     get connected() { return this._connected; }
     /** Check the underlying transport's connected state — catches silently dead sockets. */
@@ -116,8 +117,8 @@ export class NativeImapClient {
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 this.greetingResolve = null;
-                reject(new Error("Greeting timeout (10s)"));
-            }, 10000);
+                reject(new Error(`Greeting timeout (${this.greetingTimeout / 1000}s)`));
+            }, this.greetingTimeout);
             this.greetingResolve = (resp) => {
                 clearTimeout(timeout);
                 resolve(resp);
@@ -400,26 +401,88 @@ export class NativeImapClient {
             since,
             before: before || undefined,
         });
+        // SEARCH SINCE on Dovecot can take minutes on a cold mailbox while it
+        // (re)builds its date index. Without a "search starting" log, mailx
+        // shows nothing for the entire SEARCH window — the user thinks
+        // nothing is happening. Bracket the SEARCH with logs so the silence
+        // is at least labeled.
+        const t0 = Date.now();
+        console.log(`  [search] SINCE ${since.toISOString().slice(0, 10)}${before ? ` BEFORE ${before.toISOString().slice(0, 10)}` : ""} — running...`);
         const uids = await this.search(criteria);
+        console.log(`  [search] returned ${uids.length} UIDs in ${Date.now() - t0}ms`);
         if (uids.length === 0)
             return [];
         // Reverse so newest messages (highest UIDs) come first
         uids.reverse();
-        // console.log(`  [fetch] ${uids.length} UIDs to fetch (newest first)`);
         const allMessages = [];
         let chunkSize = this.fetchChunkSize;
+        let chunkIndex = 0;
         for (let i = 0; i < uids.length; i += chunkSize) {
             const chunk = uids.slice(i, i + chunkSize);
             const msgs = await this.fetchMessages(chunk.join(","), options);
             allMessages.push(...msgs);
-            // console.log(`  [fetch] ${allMessages.length}/${uids.length} (chunk of ${chunk.length})`);
+            chunkIndex++;
+            // Log every 5th chunk + the first one — enough to see progress
+            // without spamming. The first-chunk log proves the fetch is alive
+            // even when subsequent chunks are slow.
+            if (chunkIndex === 1 || chunkIndex % 5 === 0) {
+                console.log(`  [fetch] ${allMessages.length}/${uids.length} messages (chunk ${chunkIndex})`);
+            }
             if (onChunk)
                 onChunk(msgs);
             if (chunkSize < this.fetchChunkSizeMax)
                 chunkSize = Math.min(chunkSize * 4, this.fetchChunkSizeMax);
         }
+        console.log(`  [fetch] done — ${allMessages.length} messages in ${Date.now() - t0}ms`);
         return allMessages;
     }
+    /** Fetch the most recent N messages by sequence number — avoids
+     *  SEARCH SINCE which can take minutes on cold Dovecot mailboxes. The
+     *  selected mailbox's `EXISTS` count is used to compute the range
+     *  `(EXISTS-N+1):EXISTS`; sequence FETCH is O(1) on the server because
+     *  it just reads message slots, no INTERNALDATE walk. Caller must have
+     *  SELECTed the mailbox first (sequence numbers are session-relative). */
+    async fetchLatestN(n, options = {}, onChunk) {
+        const exists = this.mailboxInfo.exists;
+        if (!exists || exists < 1)
+            return [];
+        const start = Math.max(1, exists - n + 1);
+        const range = `${start}:${exists}`;
+        const t0 = Date.now();
+        console.log(`  [fetch-latest] ${this.selectedMailbox || "?"}: sequence ${range} (${Math.min(n, exists)} most recent of ${exists})`);
+        const items = ["UID", "FLAGS", "ENVELOPE", "RFC822.SIZE", "INTERNALDATE", "BODY.PEEK[HEADER]"];
+        if (options.source)
+            items.push("BODY.PEEK[]");
+        const tag = proto.nextTag();
+        const streamed = [];
+        const seenChunks = new Set();
+        const cb = (resp) => {
+            if (resp.tag !== "*" || resp.type !== "FETCH")
+                return;
+            const parsed = this.parseFetchResponses([resp]);
+            for (const msg of parsed)
+                streamed.push(msg);
+            // Flush onChunk every ~50 messages without buffering the whole
+            // response in memory — same shape as fetchByDate's chunk emit.
+            const bucket = Math.floor(streamed.length / 50);
+            if (onChunk && !seenChunks.has(bucket)) {
+                seenChunks.add(bucket);
+                onChunk(parsed);
+            }
+        };
+        await this.sendCommand(tag, proto.seqFetchCommand(tag, range, items), cb);
+        if (onChunk && streamed.length > 0) {
+            // Final flush in case last bucket didn't trip the threshold.
+            const lastBucket = Math.floor(streamed.length / 50);
+            if (!seenChunks.has(lastBucket))
+                onChunk([]);
+        }
+        // Reverse so newest-first matches fetchByDate ordering — caller code
+        // (mailx) expects that ordering when computing highestUid windows.
+        streamed.reverse();
+        console.log(`  [fetch-latest] done — ${streamed.length} messages in ${Date.now() - t0}ms`);
+        return streamed;
+    }
     /** Fetch a single message by UID */
     async fetchMessage(uid, options = {}) {
         const msgs = await this.fetchMessages(String(uid), options);
@@ -666,6 +729,10 @@ export class NativeImapClient {
      *  60s accommodates Gmail which is slow on SEARCH for large folders.
      *  Overridable via ImapClientConfig.inactivityTimeout — slow Dovecot servers need 180s+. */
     inactivityTimeout;
+    /** Server-greeting timeout in ms — how long to wait for the server's
+     *  initial banner after TCP/TLS connects. Default 10s; bumped to 30s
+     *  for slow shared-hosting Dovecot in mailx-imap. */
+    greetingTimeout;
     /** Fetch chunk sizes — start small for quick first paint, ramp up for throughput.
      *  Default 25 initial → 500 max. Overridable via ImapClientConfig.fetchChunkSize /
      *  fetchChunkSizeMax. Slow servers benefit from smaller chunks (fewer timeouts). */

package/imap-protocol.d.ts

@@ -79,6 +79,10 @@ export declare function examineCommand(tag: string, mailbox: string): string;
 export declare function statusCommand(tag: string, mailbox: string, items?: string[]): string;
 /** Build UID FETCH command */
 export declare function fetchCommand(tag: string, range: string, items: string[]): string;
+/** Build sequence-number FETCH command (no UID prefix). Used by fetchLatestN
+ *  to avoid SEARCH SINCE on a cold mailbox — sequence ranges are O(1) on the
+ *  server because they're just message numbers in the current mailbox. */
+export declare function seqFetchCommand(tag: string, range: string, items: string[]): string;
 /** Build UID SEARCH command */
 export declare function searchCommand(tag: string, criteria: string): string;
 /** Build UID STORE command (set/add/remove flags) */

package/imap-protocol.js

@@ -48,6 +48,12 @@ export function statusCommand(tag, mailbox, items = ["MESSAGES", "UIDNEXT"]) {
 export function fetchCommand(tag, range, items) {
     return buildCommand(tag, `UID FETCH ${range} (${items.join(" ")})`);
 }
+/** Build sequence-number FETCH command (no UID prefix). Used by fetchLatestN
+ *  to avoid SEARCH SINCE on a cold mailbox — sequence ranges are O(1) on the
+ *  server because they're just message numbers in the current mailbox. */
+export function seqFetchCommand(tag, range, items) {
+    return buildCommand(tag, `FETCH ${range} (${items.join(" ")})`);
+}
 /** Build UID SEARCH command */
 export function searchCommand(tag, criteria) {
     return buildCommand(tag, `UID SEARCH ${criteria}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/iflow-direct",
-  "version": "0.1.27",
+  "version": "0.1.30",
   "description": "Direct IMAP client — transport-agnostic, no Node.js dependencies, browser-ready",
   "main": "index.js",
   "types": "index.ts",
@@ -19,7 +19,7 @@
   "author": "Bob Frankston",
   "license": "ISC",
   "dependencies": {
-    "@bobfrankston/tcp-transport": "^0.1.4"
+    "@bobfrankston/tcp-transport": "^0.1.5"
   },
   "exports": {
     ".": {
@@ -50,7 +50,7 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/tcp-transport": "^0.1.4"
+      "@bobfrankston/tcp-transport": "^0.1.5"
     }
   }
 }

package/types.d.ts

@@ -13,5 +13,6 @@ export interface ImapClientConfig {
     inactivityTimeout?: number;
     fetchChunkSize?: number;
     fetchChunkSizeMax?: number;
+    greetingTimeout?: number;
 }
 //# sourceMappingURL=types.d.ts.map