@bobfrankston/iflow-direct 0.1.1

package/imap-native.js

@@ -0,0 +1,733 @@
+/**
+ * Native IMAP client — transport-agnostic.
+ * Uses ImapTransport for I/O, imap-protocol for parsing.
+ * Works with NodeTransport (desktop) or BridgeTransport (Android).
+ *
+ * This is a NEW client alongside the existing ImapClient (which wraps imapflow).
+ * Existing callers are not affected.
+ */
+import * as proto from "./imap-protocol.js";
+export class NativeImapClient {
+    transport;
+    transportFactory;
+    config;
+    buffer = "";
+    pendingCommand = null;
+    capabilities = new Set();
+    _connected = false;
+    idleTag = null;
+    idleCallback = null;
+    verbose;
+    selectedMailbox = null;
+    mailboxInfo = { exists: 0, recent: 0, uidNext: 0, uidValidity: 0, flags: [], permanentFlags: [] };
+    greetingResolve = null;
+    /** Callback for waitForContinuation — set when waiting for "+" response */
+    continuationResolve = null;
+    constructor(config, transportFactory) {
+        this.config = config;
+        this.transportFactory = transportFactory;
+        this.transport = transportFactory();
+        this.verbose = config.verbose || false;
+    }
+    get connected() { return this._connected; }
+    // ── 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
+            if (this.pendingCommand) {
+                const { reject } = this.pendingCommand;
+                this.pendingCommand = null;
+                reject(new Error("Connection closed"));
+            }
+        });
+        this.transport.onError((err) => {
+            if (this.verbose)
+                console.error(`  [imap] Transport error: ${err.message}`);
+            // Reject any pending command on transport error
+            if (this.pendingCommand) {
+                const { reject } = this.pendingCommand;
+                this.pendingCommand = null;
+                reject(err);
+            }
+        });
+        await this.transport.connect(this.config.server, this.config.port, useTls, this.config.server);
+        // Read server greeting
+        const greeting = await this.readGreeting();
+        if (this.verbose)
+            console.log(`  [imap] Greeting: ${greeting.raw}`);
+        // Parse capabilities from greeting
+        if (greeting.text.includes("CAPABILITY")) {
+            this.parseCapabilities(greeting.text);
+        }
+        else {
+            await this.capability();
+        }
+        // STARTTLS if needed
+        if (!useTls && this.capabilities.has("STARTTLS")) {
+            await this.starttls();
+        }
+        this._connected = true;
+        // Authenticate
+        await this.authenticate();
+    }
+    async readGreeting() {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.greetingResolve = null;
+                reject(new Error("Greeting timeout (10s)"));
+            }, 10000);
+            this.greetingResolve = (resp) => {
+                clearTimeout(timeout);
+                resolve(resp);
+            };
+        });
+    }
+    async authenticate() {
+        if (this.config.tokenProvider) {
+            const token = await this.config.tokenProvider();
+            const tag = proto.nextTag();
+            const cmd = proto.xoauth2Command(tag, this.config.username, token);
+            if (this.verbose)
+                console.log(`  [imap] > AUTHENTICATE XOAUTH2 ...`);
+            const responses = await this.sendCommand(tag, cmd);
+            const tagged = responses.find(r => r.tag === tag);
+            if (!tagged || tagged.type !== "OK") {
+                const errText = tagged?.text || responses.map(r => r.raw).join("; ");
+                throw new Error(`Authentication failed: ${errText}`);
+            }
+        }
+        else if (this.config.password) {
+            const tag = proto.nextTag();
+            const cmd = proto.loginCommand(tag, this.config.username, this.config.password);
+            if (this.verbose)
+                console.log(`  [imap] > LOGIN ${this.config.username} ***`);
+            const responses = await this.sendCommand(tag, cmd);
+            const tagged = responses.find(r => r.tag === tag);
+            if (!tagged || tagged.type !== "OK") {
+                const errText = tagged?.text || responses.map(r => r.raw).join("; ");
+                throw new Error(`Login failed: ${errText}`);
+            }
+        }
+        else {
+            throw new Error("No password or token provider configured");
+        }
+        // Re-read capabilities after auth (they may change)
+        await this.capability();
+    }
+    async starttls() {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.starttlsCommand(tag));
+        const tagged = responses.find(r => r.tag === tag);
+        if (!tagged || tagged.type !== "OK")
+            throw new Error("STARTTLS failed");
+        await this.transport.upgradeTLS(this.config.server);
+        await this.capability();
+    }
+    async capability() {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.capabilityCommand(tag));
+        for (const r of responses) {
+            if (r.tag === "*" && r.type === "CAPABILITY") {
+                this.parseCapabilities(r.text);
+            }
+        }
+        return this.capabilities;
+    }
+    parseCapabilities(text) {
+        const caps = text.replace(/^CAPABILITY\s*/i, "").split(/\s+/);
+        this.capabilities.clear();
+        for (const c of caps)
+            this.capabilities.add(c.toUpperCase());
+    }
+    async logout() {
+        // Force-close the transport immediately. The LOGOUT command is a courtesy —
+        // the server cleans up the session when the socket closes.
+        // Sending LOGOUT and waiting caused hangs and connection leaks.
+        this.pendingCommand = null;
+        this.transport.close();
+        this._connected = false;
+    }
+    // ── Mailbox Operations ──
+    async select(mailbox) {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.selectCommand(tag, mailbox));
+        const tagged = responses.find(r => r.tag === tag);
+        if (!tagged || tagged.type !== "OK") {
+            throw new Error(`SELECT ${mailbox} failed: ${tagged?.text || "unknown"}`);
+        }
+        // Parse mailbox info from untagged responses
+        for (const r of responses) {
+            if (r.tag !== "*")
+                continue;
+            if (r.type === "EXISTS") {
+                this.mailboxInfo.exists = parseInt(r.text);
+            }
+            else if (r.type === "RECENT") {
+                this.mailboxInfo.recent = parseInt(r.text);
+            }
+            else if (r.type === "FLAGS") {
+                this.mailboxInfo.flags = [...proto.parseFlags(r.text)];
+            }
+            else if (r.type === "OK") {
+                const uidNextMatch = r.text.match(/UIDNEXT\s+(\d+)/i);
+                if (uidNextMatch)
+                    this.mailboxInfo.uidNext = parseInt(uidNextMatch[1]);
+                const uidValMatch = r.text.match(/UIDVALIDITY\s+(\d+)/i);
+                if (uidValMatch)
+                    this.mailboxInfo.uidValidity = parseInt(uidValMatch[1]);
+                const permMatch = r.text.match(/PERMANENTFLAGS\s+\(([^)]*)\)/i);
+                if (permMatch)
+                    this.mailboxInfo.permanentFlags = permMatch[1].split(/\s+/).filter(Boolean);
+            }
+        }
+        this.selectedMailbox = mailbox;
+        return { ...this.mailboxInfo };
+    }
+    async examine(mailbox) {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.examineCommand(tag, mailbox));
+        const tagged = responses.find(r => r.tag === tag);
+        if (!tagged || tagged.type !== "OK") {
+            throw new Error(`EXAMINE ${mailbox} failed: ${tagged?.text || "unknown"}`);
+        }
+        for (const r of responses) {
+            if (r.tag !== "*")
+                continue;
+            if (r.type === "EXISTS")
+                this.mailboxInfo.exists = parseInt(r.text);
+            else if (r.type === "RECENT")
+                this.mailboxInfo.recent = parseInt(r.text);
+        }
+        this.selectedMailbox = mailbox;
+        return { ...this.mailboxInfo };
+    }
+    /** Close the currently selected mailbox */
+    async closeMailbox() {
+        if (!this.selectedMailbox)
+            return;
+        const tag = proto.nextTag();
+        await this.sendCommand(tag, proto.buildCommand(tag, "CLOSE"));
+        this.selectedMailbox = null;
+    }
+    // ── Folder Operations ──
+    async listFolders() {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.listCommand(tag));
+        const folders = [];
+        let unparsed = 0;
+        const listResponses = responses.filter(r => r.tag === "*" && r.type === "LIST");
+        if (listResponses.length === 0 && responses.length > 0) {
+            console.error(`  [imap] LIST returned ${responses.length} responses but none were LIST type. Types: ${responses.map(r => `${r.tag}:${r.type}`).join(", ")}`);
+            if (responses.length <= 5) {
+                for (const r of responses)
+                    console.error(`  [imap]   raw: ${JSON.stringify(r.text.substring(0, 200))}`);
+            }
+        }
+        for (const r of responses) {
+            if (r.tag === "*" && r.type === "LIST") {
+                const parsed = proto.parseListResponse(r.text);
+                if (parsed) {
+                    folders.push(parsed);
+                }
+                else {
+                    unparsed++;
+                    if (unparsed <= 3)
+                        console.error(`  [imap] Unparsed LIST response: ${JSON.stringify(r.text.substring(0, 200))}`);
+                }
+            }
+        }
+        if (unparsed > 0)
+            console.error(`  [imap] ${unparsed} LIST responses could not be parsed (${responses.length} total responses)`);
+        return folders;
+    }
+    async getStatus(mailbox) {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.statusCommand(tag, mailbox, ["MESSAGES", "UIDNEXT", "UNSEEN"]));
+        for (const r of responses) {
+            if (r.tag === "*" && r.type === "STATUS") {
+                const data = proto.parseStatusResponse(r.text);
+                if (data)
+                    return data;
+            }
+        }
+        return {};
+    }
+    async createMailbox(mailbox) {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.createCommand(tag, mailbox));
+        const tagged = responses.find(r => r.tag === tag);
+        if (!tagged || tagged.type !== "OK")
+            throw new Error(`CREATE failed: ${tagged?.text || "unknown"}`);
+    }
+    async deleteMailbox(mailbox) {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.deleteMailboxCommand(tag, mailbox));
+        const tagged = responses.find(r => r.tag === tag);
+        if (!tagged || tagged.type !== "OK")
+            throw new Error(`DELETE failed: ${tagged?.text || "unknown"}`);
+    }
+    async renameMailbox(from, to) {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.renameCommand(tag, from, to));
+        const tagged = responses.find(r => r.tag === tag);
+        if (!tagged || tagged.type !== "OK")
+            throw new Error(`RENAME failed: ${tagged?.text || "unknown"}`);
+    }
+    // ── Message Operations ──
+    /** Fetch messages by UID range */
+    async fetchMessages(range, options = {}) {
+        const items = ["UID", "FLAGS", "ENVELOPE", "RFC822.SIZE", "INTERNALDATE"];
+        if (options.headers !== false)
+            items.push("BODY.PEEK[HEADER]");
+        if (options.source)
+            items.push("BODY.PEEK[]");
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.fetchCommand(tag, range, items));
+        return this.parseFetchResponses(responses);
+    }
+    /** Fetch messages since a UID */
+    async fetchSinceUid(sinceUid, options = {}, onChunk) {
+        const uids = await this.search(`UID ${sinceUid + 1}:*`);
+        if (uids.length === 0)
+            return [];
+        uids.reverse(); // Newest first
+        console.log(`  [fetch] ${uids.length} UIDs since ${sinceUid} (newest first)`);
+        if (uids.length <= NativeImapClient.INITIAL_CHUNK_SIZE) {
+            const msgs = await this.fetchMessages(uids.join(","), options);
+            if (onChunk)
+                onChunk(msgs);
+            return msgs;
+        }
+        const allMessages = [];
+        let chunkSize = NativeImapClient.INITIAL_CHUNK_SIZE;
+        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})`);
+            if (onChunk)
+                onChunk(msgs);
+            if (chunkSize < NativeImapClient.MAX_CHUNK_SIZE)
+                chunkSize = Math.min(chunkSize * 4, NativeImapClient.MAX_CHUNK_SIZE);
+        }
+        return allMessages;
+    }
+    /** Fetch messages by date range. Optional onChunk callback receives each batch as it arrives. */
+    async fetchByDate(since, before, options = {}, onChunk) {
+        const criteria = proto.buildSearchCriteria({
+            since,
+            before: before || undefined,
+        });
+        const uids = await this.search(criteria);
+        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 = NativeImapClient.INITIAL_CHUNK_SIZE;
+        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})`);
+            if (onChunk)
+                onChunk(msgs);
+            if (chunkSize < NativeImapClient.MAX_CHUNK_SIZE)
+                chunkSize = Math.min(chunkSize * 4, NativeImapClient.MAX_CHUNK_SIZE);
+        }
+        return allMessages;
+    }
+    /** Fetch a single message by UID */
+    async fetchMessage(uid, options = {}) {
+        const msgs = await this.fetchMessages(String(uid), options);
+        return msgs.find(m => m.uid === uid) || null;
+    }
+    /** Get all UIDs in the current mailbox */
+    async getUids() {
+        return this.search("ALL");
+    }
+    /** UID SEARCH */
+    async search(criteria) {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.searchCommand(tag, criteria));
+        for (const r of responses) {
+            if (r.tag === "*" && r.type === "SEARCH") {
+                return proto.parseSearchResponse(r.text);
+            }
+        }
+        return [];
+    }
+    /** Set flags on a message */
+    async addFlags(uid, flags) {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.storeCommand(tag, uid, "+FLAGS.SILENT", flags));
+        const tagged = responses.find(r => r.tag === tag);
+        if (!tagged || tagged.type !== "OK")
+            throw new Error(`STORE +FLAGS failed: ${tagged?.text || "unknown"}`);
+    }
+    /** Remove flags from a message */
+    async removeFlags(uid, flags) {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.storeCommand(tag, uid, "-FLAGS.SILENT", flags));
+        const tagged = responses.find(r => r.tag === tag);
+        if (!tagged || tagged.type !== "OK")
+            throw new Error(`STORE -FLAGS failed: ${tagged?.text || "unknown"}`);
+    }
+    /** Copy a message to another mailbox */
+    async copyMessage(uid, destination) {
+        const tag = proto.nextTag();
+        const responses = await this.sendCommand(tag, proto.copyCommand(tag, uid, destination));
+        const tagged = responses.find(r => r.tag === tag);
+        if (!tagged || tagged.type !== "OK")
+            throw new Error(`COPY failed: ${tagged?.text || "unknown"}`);
+    }
+    /** Move a message to another mailbox (MOVE or COPY+DELETE) */
+    async moveMessage(uid, destination) {
+        if (this.capabilities.has("MOVE")) {
+            const tag = proto.nextTag();
+            const responses = await this.sendCommand(tag, proto.moveCommand(tag, uid, destination));
+            const tagged = responses.find(r => r.tag === tag);
+            if (!tagged || tagged.type !== "OK")
+                throw new Error(`MOVE failed: ${tagged?.text || "unknown"}`);
+        }
+        else {
+            await this.copyMessage(uid, destination);
+            await this.addFlags(uid, ["\\Deleted"]);
+            await this.expunge();
+        }
+    }
+    /** Delete a message by UID (flag + expunge) */
+    async deleteMessage(uid) {
+        await this.addFlags(uid, ["\\Deleted"]);
+        await this.expunge();
+    }
+    /** Expunge deleted messages */
+    async expunge() {
+        const tag = proto.nextTag();
+        await this.sendCommand(tag, proto.buildCommand(tag, "EXPUNGE"));
+    }
+    /** Append a message to a mailbox */
+    async appendMessage(mailbox, message, flags = []) {
+        const data = typeof message === "string" ? message : new TextDecoder().decode(message);
+        const size = new TextEncoder().encode(data).length;
+        const tag = proto.nextTag();
+        const cmd = proto.appendCommand(tag, mailbox, flags, size);
+        // Send command, wait for continuation
+        await this.transport.write(cmd);
+        // Wait for "+" continuation
+        const contResp = await this.waitForContinuation(tag);
+        if (!contResp)
+            throw new Error("APPEND: server did not send continuation");
+        // Send the message data + CRLF
+        await this.transport.write(data + "\r\n");
+        // Wait for tagged response
+        const responses = await this.waitForTagged(tag);
+        const tagged = responses.find(r => r.tag === tag);
+        if (!tagged || tagged.type !== "OK")
+            throw new Error(`APPEND failed: ${tagged?.text || "unknown"}`);
+        // Try to extract APPENDUID
+        const uidMatch = tagged.text.match(/APPENDUID\s+\d+\s+(\d+)/i);
+        return uidMatch ? parseInt(uidMatch[1]) : null;
+    }
+    // ── IDLE ──
+    async startIdle(onNewMail) {
+        this.idleCallback = onNewMail;
+        const tag = proto.nextTag();
+        this.idleTag = tag;
+        await this.transport.write(proto.idleCommand(tag));
+        // Wait for "+" continuation
+        await this.waitForContinuation(tag);
+        return async () => {
+            this.idleTag = null;
+            this.idleCallback = null;
+            await this.transport.write(proto.doneCommand());
+            await this.waitForTagged(tag);
+        };
+    }
+    // ── Message count (lightweight STATUS) ──
+    async getMessageCount(mailbox) {
+        const status = await this.getStatus(mailbox);
+        return status.messages || 0;
+    }
+    // ── Low-level command handling ──
+    /** Inactivity timeout — how long to wait with NO data before declaring the connection dead.
+     *  This is NOT a wall-clock timeout. Timer resets every time data arrives from the server.
+     *  A large FETCH returning data continuously will never timeout. */
+    inactivityTimeout = 30000;
+    /** Fetch chunk sizes — start small for quick first paint, ramp up for throughput */
+    static INITIAL_CHUNK_SIZE = 25;
+    static MAX_CHUNK_SIZE = 500;
+    /** Active command timer — reset by handleData on every data arrival */
+    commandTimer = null;
+    sendCommand(tag, command) {
+        return new Promise((resolve, reject) => {
+            if (this.verbose && !command.includes("LOGIN") && !command.includes("AUTHENTICATE")) {
+                console.log(`  [imap] > ${command.trimEnd()}`);
+            }
+            const onTimeout = () => {
+                this.commandTimer = null;
+                this.pendingCommand = null;
+                // Kill the connection — a timed-out connection has stale data in the pipe
+                this.transport.close?.();
+                reject(new Error(`IMAP inactivity timeout (${this.inactivityTimeout / 1000}s): ${command.split("\r")[0].substring(0, 80)}`));
+            };
+            this.commandTimer = setTimeout(onTimeout, this.inactivityTimeout);
+            this.pendingCommand = {
+                tag, responses: [],
+                resolve: (responses) => { if (this.commandTimer)
+                    clearTimeout(this.commandTimer); this.commandTimer = null; resolve(responses); },
+                reject: (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; reject(err); });
+        });
+    }
+    waitForContinuation(tag) {
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                this.continuationResolve = null;
+                resolve(null);
+            }, 30000);
+            this.continuationResolve = (resp) => {
+                clearTimeout(timeout);
+                this.continuationResolve = null;
+                resolve(resp);
+            };
+        });
+    }
+    waitForTagged(tag) {
+        return new Promise((resolve, reject) => {
+            this.pendingCommand = { tag, resolve, reject, responses: [] };
+        });
+    }
+    handleData(data) {
+        // Reset inactivity timer — data is flowing, connection is alive
+        if (this.commandTimer) {
+            clearTimeout(this.commandTimer);
+            this.commandTimer = setTimeout(() => {
+                this.commandTimer = null;
+                if (this.pendingCommand) {
+                    const cmd = this.pendingCommand;
+                    this.pendingCommand = null;
+                    this.transport.close?.();
+                    cmd.reject(new Error(`IMAP inactivity timeout (${this.inactivityTimeout / 1000}s)`));
+                }
+            }, this.inactivityTimeout);
+        }
+        this.buffer += data;
+        this.processBuffer();
+    }
+    processBuffer() {
+        while (true) {
+            // Check for literal {size}\r\n — reading exact BYTE count of literal data
+            // CRITICAL: literalBytes is in octets (from IMAP {N}), but this.buffer is a
+            // JavaScript string where multi-byte UTF-8 characters count as 1 character.
+            // We must use byte-accurate extraction (TextEncoder for browser, Buffer for Node).
+            if (this.pendingCommand?.literalBytes != null) {
+                const neededBytes = this.pendingCommand.literalBytes;
+                const encoded = new TextEncoder().encode(this.buffer);
+                const bufferBytes = encoded.byteLength;
+                if (bufferBytes >= neededBytes) {
+                    const literal_bytes = encoded.subarray(0, neededBytes);
+                    const rest_bytes = encoded.subarray(neededBytes);
+                    let literal = new TextDecoder().decode(literal_bytes);
+                    this.buffer = new TextDecoder().decode(rest_bytes);
+                    // For non-BODY literals (e.g. display names in ENVELOPE), wrap in quotes
+                    // so tokenizeParenList treats them as a single token
+                    if (!this.pendingCommand.currentLiteralKey) {
+                        literal = `"${literal.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r?\n/g, "")}"`;
+                    }
+                    this.pendingCommand.literalBuffer = (this.pendingCommand.literalBuffer || "") + literal;
+                    this.pendingCommand.literalBytes = undefined;
+                    // Store the literal data by its BODY key for parseFetchResponses
+                    if (this.pendingCommand.currentLiteralKey) {
+                        if (!this.pendingCommand.literals)
+                            this.pendingCommand.literals = new Map();
+                        this.pendingCommand.literals.set(this.pendingCommand.currentLiteralKey, literal);
+                        this.pendingCommand.currentLiteralKey = undefined;
+                        this.pendingCommand.currentLiteralSize = undefined;
+                    }
+                    if (this.verbose)
+                        console.log(`  [imap] literal consumed, ${literal.length} bytes, buffer remaining: ${this.buffer.length}`);
+                    // After consuming literal, check if the NEXT part has another literal
+                    // (e.g., BODY[HEADER] {500}\r\n<data>BODY[] {2000}\r\n<data>)\r\n)
+                    // Continue to process the next line/literal from the buffer
+                    continue;
+                }
+                if (this.verbose && this.pendingCommand.literalBytes > 0) {
+                    console.log(`  [imap] waiting for literal: need ${neededBytes} bytes, have ${bufferBytes} bytes`);
+                }
+                break; // Wait for more data
+            }
+            const lineEnd = this.buffer.indexOf("\r\n");
+            if (lineEnd < 0)
+                break;
+            const line = this.buffer.substring(0, lineEnd + 2);
+            this.buffer = this.buffer.substring(lineEnd + 2);
+            // Check for literal announcement {size}\r\n at end of line
+            const literalMatch = line.match(/\{(\d+)\}\r\n$/);
+            if (literalMatch && this.pendingCommand) {
+                const size = parseInt(literalMatch[1]);
+                // Store the line prefix before {size} — will be prepended after literal is consumed
+                const linePrefix = line.substring(0, literalMatch.index);
+                if (this.pendingCommand.literalBuffer) {
+                    // Already have buffered data from a previous literal — append this prefix
+                    this.pendingCommand.literalBuffer += linePrefix;
+                }
+                else {
+                    this.pendingCommand.literalBuffer = linePrefix;
+                }
+                this.pendingCommand.literalBytes = size;
+                // Extract the BODY section key from the prefix (e.g. BODY[], BODY[HEADER], BODY.PEEK[])
+                const keyMatch = linePrefix.match(/BODY(?:\.PEEK)?\[([^\]]*)\]\s*$/i);
+                if (keyMatch) {
+                    this.pendingCommand.currentLiteralKey = `BODY[${keyMatch[1]}]`;
+                    this.pendingCommand.currentLiteralSize = size;
+                }
+                if (this.verbose)
+                    console.log(`  [imap] literal announced: ${size} bytes, prefix: ${linePrefix.length} chars, key: ${this.pendingCommand.currentLiteralKey || "none"}`);
+                continue;
+            }
+            // If we have buffered literal data, prepend it to this line (the closing part after the literal)
+            let fullLine = line;
+            if (this.pendingCommand?.literalBuffer) {
+                fullLine = this.pendingCommand.literalBuffer + line;
+                this.pendingCommand.literalBuffer = undefined;
+            }
+            const resp = proto.parseResponseLine(fullLine);
+            // Attach accumulated literals to the response and reset for next response
+            if (this.pendingCommand?.literals?.size) {
+                resp.literals = this.pendingCommand.literals;
+                this.pendingCommand.literals = undefined;
+            }
+            if (this.verbose) {
+                const display = resp.raw.length > 200 ? resp.raw.substring(0, 200) + `... (${resp.raw.length} bytes)` : resp.raw;
+                console.log(`  [imap] < [tag=${resp.tag} type=${resp.type}] ${display}`);
+            }
+            // Server greeting — resolve readGreeting() promise
+            if (this.greetingResolve && resp.tag === "*" && (resp.type === "OK" || resp.type === "PREAUTH")) {
+                const resolve = this.greetingResolve;
+                this.greetingResolve = null;
+                resolve(resp);
+                continue;
+            }
+            // During IDLE, handle EXISTS notifications
+            if (this.idleTag && resp.tag === "*" && resp.type === "EXISTS") {
+                const count = parseInt(resp.text);
+                if (this.idleCallback && count > this.mailboxInfo.exists) {
+                    const newCount = count - this.mailboxInfo.exists;
+                    this.mailboxInfo.exists = count;
+                    this.idleCallback(newCount);
+                }
+                continue;
+            }
+            // Collect untagged responses for the pending command
+            if (resp.tag === "*" && this.pendingCommand) {
+                this.pendingCommand.responses.push(resp);
+                continue;
+            }
+            // Continuation response
+            if (resp.tag === "+") {
+                if (this.continuationResolve) {
+                    // APPEND or other command waiting for continuation
+                    this.continuationResolve(resp);
+                }
+                else if (!this.idleTag && this.pendingCommand) {
+                    // Unexpected continuation (e.g. AUTHENTICATE challenge) — cancel
+                    this.transport.write("\r\n").catch(() => { });
+                }
+                continue;
+            }
+            // Tagged response — command complete
+            if (this.pendingCommand && resp.tag === this.pendingCommand.tag) {
+                this.pendingCommand.responses.push(resp);
+                const { resolve, responses } = this.pendingCommand;
+                this.pendingCommand = null;
+                resolve(responses);
+                continue;
+            }
+            // Unhandled
+            this.handleUntaggedResponse(resp);
+        }
+    }
+    handleUntaggedResponse(resp) {
+        if (resp.type === "EXISTS") {
+            this.mailboxInfo.exists = parseInt(resp.text);
+        }
+        else if (resp.type === "EXPUNGE") {
+            this.mailboxInfo.exists = Math.max(0, this.mailboxInfo.exists - 1);
+        }
+    }
+    // ── FETCH Response Parser ──
+    parseFetchResponses(responses) {
+        const messages = [];
+        for (const r of responses) {
+            if (r.tag !== "*" || r.type !== "FETCH")
+                continue;
+            const msg = {
+                seq: 0, uid: 0, flags: new Set(), date: null,
+                subject: "", messageId: "", from: [], to: [], cc: [], bcc: [],
+                sender: [], replyTo: [], inReplyTo: "", size: 0,
+                source: "", headers: "", seen: false, flagged: false,
+                answered: false, draft: false,
+            };
+            // Extract sequence number from "5 FETCH (...)"
+            const seqMatch = r.text.match(/^(\d+)\s+FETCH/);
+            if (seqMatch)
+                msg.seq = parseInt(seqMatch[1]);
+            // Extract UID
+            const uidMatch = r.text.match(/UID\s+(\d+)/);
+            if (uidMatch)
+                msg.uid = parseInt(uidMatch[1]);
+            // Extract FLAGS
+            const flagsMatch = r.text.match(/FLAGS\s+\(([^)]*)\)/);
+            if (flagsMatch) {
+                msg.flags = new Set(flagsMatch[1].split(/\s+/).filter(Boolean));
+                msg.seen = msg.flags.has("\\Seen");
+                msg.flagged = msg.flags.has("\\Flagged");
+                msg.answered = msg.flags.has("\\Answered");
+                msg.draft = msg.flags.has("\\Draft");
+            }
+            // Extract RFC822.SIZE
+            const sizeMatch = r.text.match(/RFC822\.SIZE\s+(\d+)/);
+            if (sizeMatch)
+                msg.size = parseInt(sizeMatch[1]);
+            // Extract INTERNALDATE
+            const dateMatch = r.text.match(/INTERNALDATE\s+"([^"]+)"/);
+            if (dateMatch)
+                msg.date = new Date(dateMatch[1]);
+            // Extract ENVELOPE
+            const envMatch = r.text.match(/ENVELOPE\s+(\(.*\))/);
+            if (envMatch) {
+                const env = proto.parseEnvelope(envMatch[1]);
+                msg.date = msg.date || env.date;
+                msg.subject = env.subject;
+                msg.messageId = env.messageId;
+                msg.from = env.from;
+                msg.to = env.to;
+                msg.cc = env.cc;
+                msg.bcc = env.bcc;
+                msg.sender = env.sender;
+                msg.replyTo = env.replyTo;
+                msg.inReplyTo = env.inReplyTo;
+            }
+            // Extract body source and headers from literals tracked by processBuffer
+            if (r.literals) {
+                const source = r.literals.get("BODY[]");
+                if (source)
+                    msg.source = source;
+                const headers = r.literals.get("BODY[HEADER]");
+                if (headers)
+                    msg.headers = headers;
+            }
+            messages.push(msg);
+        }
+        return messages;
+    }
+}
+//# sourceMappingURL=imap-native.js.map