@bobfrankston/iflow-direct 0.1.68 → 0.1.71

package/imap-compat.d.ts

@@ -65,6 +65,13 @@ export declare class CompatImapClient {
     }): Promise<FetchedMessage | null>;
     /** Get message count via STATUS (does not require SELECT) */
     getMessagesCount(mailbox: string): Promise<number>;
+    /** Mailbox size in octets + message count. STATUS=SIZE when the server has it, else a
+     *  size-only UID FETCH. See NativeImapClient.getFolderSize. (2026-09-16, Claude Code) */
+    getFolderSize(mailbox: string): Promise<{
+        messages: number;
+        bytes: number;
+        method: "status" | "fetch";
+    }>;
     /** Get all UIDs in a mailbox */
     getUids(mailbox: string): Promise<number[]>;
     /** Get UIDs whose INTERNALDATE is on/after `since`. Bounded version of
@@ -98,6 +105,9 @@ export declare class CompatImapClient {
     searchByHeader(mailbox: string, headerName: string, headerValue: string): Promise<number[]>;
     /** Delete a message by UID */
     deleteMessageByUid(mailbox: string, uid: number): Promise<void>;
+    /** Delete many messages by UID in one mailbox — chunked STORE + one
+     *  EXPUNGE (see ImapNative.deleteMessages). 2026-09-16 Claude Code. */
+    deleteMessagesByUid(mailbox: string, uids: number[]): Promise<void>;
     /** Move a message between mailboxes (same server) */
     moveMessage(msg: any, fromMailbox: string, toMailbox: string): Promise<void>;
     /** Add flags to a message */

package/imap-compat.js

@@ -160,6 +160,12 @@ export class CompatImapClient {
         await this.ensureConnected();
         return this.native.getMessageCount(mailbox);
     }
+    /** Mailbox size in octets + message count. STATUS=SIZE when the server has it, else a
+     *  size-only UID FETCH. See NativeImapClient.getFolderSize. (2026-09-16, Claude Code) */
+    async getFolderSize(mailbox) {
+        await this.ensureConnected();
+        return this.native.getFolderSize(mailbox);
+    }
     /** Get all UIDs in a mailbox */
     async getUids(mailbox) {
         await this.ensureConnected();
@@ -233,6 +239,20 @@ export class CompatImapClient {
         await this.native.deleteMessage(uid);
         await this.native.closeMailbox();
     }
+    /** Delete many messages by UID in one mailbox — chunked STORE + one
+     *  EXPUNGE (see ImapNative.deleteMessages). 2026-09-16 Claude Code. */
+    async deleteMessagesByUid(mailbox, uids) {
+        if (!uids.length)
+            return;
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        try {
+            await this.native.deleteMessages(uids);
+        }
+        finally {
+            await this.native.closeMailbox();
+        }
+    }
     /** Move a message between mailboxes (same server) */
     async moveMessage(msg, fromMailbox, toMailbox) {
         await this.ensureConnected();

package/imap-native.d.ts

@@ -192,7 +192,24 @@ export declare class NativeImapClient {
     /** Close the currently selected mailbox */
     closeMailbox(): Promise<void>;
     listFolders(): Promise<NativeFolder[]>;
-    getStatus(mailbox: string): Promise<proto.StatusData>;
+    getStatus(mailbox: string, items?: string[]): Promise<proto.StatusData>;
+    /**
+     * Total size of a mailbox in octets plus its message count (for imail -sizes; added
+     * 2026-09-16 by Claude Code, Fable 5.1, at Bob's direction).
+     *
+     * Fast path: RFC 8438 `STATUS (MESSAGES SIZE)` — one round trip, no message traffic —
+     * when the server advertises STATUS=SIZE (Dovecot, Gmail do).
+     * Fallback: EXAMINE (read-only) + `UID FETCH 1:* (UID RFC822.SIZE)` summed here. That
+     * is one FETCH line per message but no envelopes or headers, so it stays cheap even
+     * on a folder of tens of thousands of messages.
+     *
+     * `method` says which path produced the number so a log can show it.
+     */
+    getFolderSize(mailbox: string): Promise<{
+        messages: number;
+        bytes: number;
+        method: "status" | "fetch";
+    }>;
     createMailbox(mailbox: string): Promise<void>;
     deleteMailbox(mailbox: string): Promise<void>;
     renameMailbox(from: string, to: string): Promise<void>;
@@ -256,6 +273,14 @@ export declare class NativeImapClient {
     moveMessage(uid: number, destination: string): Promise<void>;
     /** Delete a message by UID (flag + expunge) */
     deleteMessage(uid: number): Promise<void>;
+    /** Delete many messages in the selected mailbox: one `UID STORE <set>
+     *  +FLAGS.SILENT (\Deleted)` per chunk, then a single EXPUNGE.
+     *  2026-09-16 — Claude Code (Fable 5.1), at Bob's direction. Emptying
+     *  Trash looped deleteMessage() per UID — a STORE and an EXPUNGE round
+     *  trip for every message — so a large Trash took minutes and the
+     *  caller's IPC timed out ("mailxapi timeout: emptyFolder"). Chunked so a
+     *  ten-thousand-UID set never produces a command line the server rejects. */
+    deleteMessages(uids: number[], chunkSize?: number): Promise<void>;
     /** Expunge deleted messages */
     expunge(): Promise<void>;
     /** Append a message to a mailbox */

package/imap-native.js

@@ -469,9 +469,11 @@ export class NativeImapClient {
             console.error(`  [imap] ${unparsed} LIST responses could not be parsed (${responses.length} total responses)`);
         return folders;
     }
-    async getStatus(mailbox) {
+    // 2026-09-16 — Claude Code (Fable 5.1), at Bob's direction: `items` parameter added so a
+    // caller can ask for RFC 8438 SIZE. Default unchanged, so existing callers see no difference.
+    async getStatus(mailbox, items = ["MESSAGES", "UIDNEXT", "UNSEEN"]) {
         const tag = proto.nextTag();
-        const responses = await this.sendCommand(tag, proto.statusCommand(tag, mailbox, ["MESSAGES", "UIDNEXT", "UNSEEN"]));
+        const responses = await this.sendCommand(tag, proto.statusCommand(tag, mailbox, items));
         for (const r of responses) {
             if (r.tag === "*" && r.type === "STATUS") {
                 const data = proto.parseStatusResponse(r.text);
@@ -481,6 +483,46 @@ export class NativeImapClient {
         }
         return {};
     }
+    /**
+     * Total size of a mailbox in octets plus its message count (for imail -sizes; added
+     * 2026-09-16 by Claude Code, Fable 5.1, at Bob's direction).
+     *
+     * Fast path: RFC 8438 `STATUS (MESSAGES SIZE)` — one round trip, no message traffic —
+     * when the server advertises STATUS=SIZE (Dovecot, Gmail do).
+     * Fallback: EXAMINE (read-only) + `UID FETCH 1:* (UID RFC822.SIZE)` summed here. That
+     * is one FETCH line per message but no envelopes or headers, so it stays cheap even
+     * on a folder of tens of thousands of messages.
+     *
+     * `method` says which path produced the number so a log can show it.
+     */
+    async getFolderSize(mailbox) {
+        if (this.capabilities.has("STATUS=SIZE")) {
+            const st = await this.getStatus(mailbox, ["MESSAGES", "SIZE"]);
+            if (typeof st.size === "number")
+                return { messages: st.messages || 0, bytes: st.size, method: "status" };
+            // Server claimed STATUS=SIZE but answered without SIZE — fall through to counting.
+        }
+        const info = await this.examine(mailbox);
+        try {
+            if (!info.exists)
+                return { messages: 0, bytes: 0, method: "fetch" };
+            let messages = 0, bytes = 0;
+            const tag = proto.nextTag();
+            await this.sendCommand(tag, proto.fetchCommand(tag, "1:*", ["UID", "RFC822.SIZE"]), (r) => {
+                if (r.tag !== "*" || r.type !== "FETCH")
+                    return;
+                const m = r.text.match(/RFC822\.SIZE\s+(\d+)/);
+                if (!m)
+                    return;
+                messages++;
+                bytes += parseInt(m[1]);
+            });
+            return { messages, bytes, method: "fetch" };
+        }
+        finally {
+            await this.closeMailbox();
+        }
+    }
     async createMailbox(mailbox) {
         const tag = proto.nextTag();
         const responses = await this.sendCommand(tag, proto.createCommand(tag, mailbox));
@@ -786,6 +828,26 @@ export class NativeImapClient {
         await this.addFlags(uid, ["\\Deleted"]);
         await this.expunge();
     }
+    /** Delete many messages in the selected mailbox: one `UID STORE <set>
+     *  +FLAGS.SILENT (\Deleted)` per chunk, then a single EXPUNGE.
+     *  2026-09-16 — Claude Code (Fable 5.1), at Bob's direction. Emptying
+     *  Trash looped deleteMessage() per UID — a STORE and an EXPUNGE round
+     *  trip for every message — so a large Trash took minutes and the
+     *  caller's IPC timed out ("mailxapi timeout: emptyFolder"). Chunked so a
+     *  ten-thousand-UID set never produces a command line the server rejects. */
+    async deleteMessages(uids, chunkSize = 1000) {
+        if (!uids.length)
+            return;
+        for (let i = 0; i < uids.length; i += chunkSize) {
+            const set = proto.uidSequenceSet(uids.slice(i, i + chunkSize));
+            const tag = proto.nextTag();
+            const responses = await this.sendCommand(tag, proto.storeCommand(tag, set, "+FLAGS.SILENT", ["\\Deleted"]));
+            const tagged = responses.find(r => r.tag === tag);
+            if (!tagged || tagged.type !== "OK")
+                throw new Error(`STORE +FLAGS \\Deleted (${uids.length} uids) failed: ${tagged?.text || "unknown"}`);
+        }
+        await this.expunge();
+    }
     /** Expunge deleted messages */
     async expunge() {
         const tag = proto.nextTag();

package/imap-protocol.d.ts

@@ -58,6 +58,9 @@ export interface StatusData {
     uidNext?: number;
     uidValidity?: number;
     unseen?: number;
+    /** Total mailbox size in octets — RFC 8438 `STATUS (SIZE)`, only when the
+     *  server advertises STATUS=SIZE and the caller asked for it. */
+    size?: number;
 }
 /** Generate a unique command tag */
 export declare function nextTag(): string;
@@ -104,7 +107,12 @@ export declare function seqFetchCommand(tag: string, range: string, items: strin
 /** Build UID SEARCH command */
 export declare function searchCommand(tag: string, criteria: string): string;
 /** Build UID STORE command (set/add/remove flags) */
-export declare function storeCommand(tag: string, uid: number, action: string, flags: string[]): string;
+/** `uid` may be a single UID or an RFC 3501 sequence set ("1:500,502") —
+ *  2026-09-16 Claude Code (Fable 5.1): needed so one STORE can flag a whole
+ *  folder for deletion instead of one round trip per message. */
+export declare function storeCommand(tag: string, uid: number | string, action: string, flags: string[]): string;
+/** Compress sorted UIDs into an RFC 3501 sequence set: [1,2,3,7,9,10] → "1:3,7,9:10". */
+export declare function uidSequenceSet(uids: number[]): string;
 /** Build UID COPY command */
 export declare function copyCommand(tag: string, uid: number, destination: string): string;
 /** Build UID MOVE command */

package/imap-protocol.js

@@ -110,9 +110,25 @@ export function searchCommand(tag, criteria) {
     return buildCommand(tag, `UID SEARCH ${criteria}`);
 }
 /** Build UID STORE command (set/add/remove flags) */
+/** `uid` may be a single UID or an RFC 3501 sequence set ("1:500,502") —
+ *  2026-09-16 Claude Code (Fable 5.1): needed so one STORE can flag a whole
+ *  folder for deletion instead of one round trip per message. */
 export function storeCommand(tag, uid, action, flags) {
     return buildCommand(tag, `UID STORE ${uid} ${action} (${flags.join(" ")})`);
 }
+/** Compress sorted UIDs into an RFC 3501 sequence set: [1,2,3,7,9,10] → "1:3,7,9:10". */
+export function uidSequenceSet(uids) {
+    const sorted = Array.from(new Set(uids)).sort((a, b) => a - b);
+    const parts = [];
+    for (let i = 0; i < sorted.length;) {
+        let j = i;
+        while (j + 1 < sorted.length && sorted[j + 1] === sorted[j] + 1)
+            j++;
+        parts.push(j > i ? `${sorted[i]}:${sorted[j]}` : String(sorted[i]));
+        i = j + 1;
+    }
+    return parts.join(",");
+}
 /** Build UID COPY command */
 export function copyCommand(tag, uid, destination) {
     return buildCommand(tag, `UID COPY ${uid} ${quoteMailbox(destination)}`);
@@ -239,6 +255,9 @@ export function parseStatusResponse(text) {
             data.uidValidity = val;
         else if (key === "UNSEEN")
             data.unseen = val;
+        // 2026-09-16 — Claude Code (Fable 5.1), at Bob's direction: RFC 8438 SIZE, for imail -sizes.
+        else if (key === "SIZE")
+            data.size = val;
     }
     return data;
 }
@@ -267,6 +286,8 @@ export function parseStatusResponseFull(text) {
             data.uidValidity = val;
         else if (key === "UNSEEN")
             data.unseen = val;
+        else if (key === "SIZE")
+            data.size = val; // RFC 8438 (2026-09-16)
     }
     return { mailbox, data };
 }

package/package.json

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