@bobfrankston/iflow 1.0.34 → 1.0.38

package/imaplib/imap-native.js

@@ -0,0 +1,586 @@
+/**
+ * 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: [] };
+    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; });
+        this.transport.onError((err) => {
+            if (this.verbose)
+                console.error(`  [imap] Transport error: ${err.message}`);
+        });
+        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) => {
+            const check = () => {
+                const lineEnd = this.buffer.indexOf("\r\n");
+                if (lineEnd >= 0) {
+                    const line = this.buffer.substring(0, lineEnd + 2);
+                    this.buffer = this.buffer.substring(lineEnd + 2);
+                    resolve(proto.parseResponseLine(line));
+                }
+                else {
+                    setTimeout(check, 10);
+                }
+            };
+            check();
+        });
+    }
+    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() {
+        try {
+            if (this._connected) {
+                const tag = proto.nextTag();
+                await this.sendCommand(tag, proto.logoutCommand(tag));
+            }
+        }
+        catch { /* ignore */ }
+        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 = [];
+        for (const r of responses) {
+            if (r.tag === "*" && r.type === "LIST") {
+                const parsed = proto.parseListResponse(r.text);
+                if (parsed)
+                    folders.push(parsed);
+            }
+        }
+        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 = {}) {
+        return this.fetchMessages(`${sinceUid + 1}:*`, options);
+    }
+    /** Fetch messages by date range */
+    async fetchByDate(since, before, options = {}) {
+        // First search for UIDs in date range, then fetch
+        const criteria = proto.buildSearchCriteria({
+            since,
+            before: before || undefined,
+        });
+        const uids = await this.search(criteria);
+        if (uids.length === 0)
+            return [];
+        // Fetch in chunks to avoid very long command lines
+        const chunkSize = 500;
+        const allMessages = [];
+        for (let i = 0; i < uids.length; i += chunkSize) {
+            const chunk = uids.slice(i, i + chunkSize);
+            const range = chunk.join(",");
+            const msgs = await this.fetchMessages(range, options);
+            allMessages.push(...msgs);
+        }
+        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 ──
+    sendCommand(tag, command) {
+        return new Promise((resolve, reject) => {
+            if (this.verbose && !command.includes("LOGIN") && !command.includes("AUTHENTICATE")) {
+                console.log(`  [imap] > ${command.trimEnd()}`);
+            }
+            this.pendingCommand = { tag, resolve, reject, responses: [] };
+            this.transport.write(command).catch(reject);
+        });
+    }
+    waitForContinuation(tag) {
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => resolve(null), 30000);
+            const check = () => {
+                const lineEnd = this.buffer.indexOf("\r\n");
+                if (lineEnd >= 0) {
+                    const line = this.buffer.substring(0, lineEnd + 2);
+                    const resp = proto.parseResponseLine(line);
+                    if (resp.tag === "+") {
+                        this.buffer = this.buffer.substring(lineEnd + 2);
+                        clearTimeout(timeout);
+                        resolve(resp);
+                        return;
+                    }
+                    // Not continuation — process and keep waiting
+                    this.buffer = this.buffer.substring(lineEnd + 2);
+                    this.handleUntaggedResponse(resp);
+                }
+                if (this.transport.connected)
+                    setTimeout(check, 5);
+                else {
+                    clearTimeout(timeout);
+                    resolve(null);
+                }
+            };
+            check();
+        });
+    }
+    waitForTagged(tag) {
+        return new Promise((resolve, reject) => {
+            this.pendingCommand = { tag, resolve, reject, responses: [] };
+        });
+    }
+    handleData(data) {
+        this.buffer += data;
+        this.processBuffer();
+    }
+    processBuffer() {
+        while (true) {
+            // Check for literal {size}\r\n
+            if (this.pendingCommand?.literalBytes != null) {
+                if (this.buffer.length >= this.pendingCommand.literalBytes) {
+                    const literal = this.buffer.substring(0, this.pendingCommand.literalBytes);
+                    this.buffer = this.buffer.substring(this.pendingCommand.literalBytes);
+                    this.pendingCommand.literalBuffer = (this.pendingCommand.literalBuffer || "") + literal;
+                    this.pendingCommand.literalBytes = undefined;
+                    continue;
+                }
+                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}
+            const literalMatch = line.match(/\{(\d+)\}\r\n$/);
+            if (literalMatch && this.pendingCommand) {
+                this.pendingCommand.literalBytes = parseInt(literalMatch[1]);
+                // Store the line prefix before the literal
+                const linePrefix = line.substring(0, line.indexOf(`{${literalMatch[1]}}`));
+                this.pendingCommand.literalBuffer = linePrefix;
+                continue;
+            }
+            // If we have buffered literal data, prepend it
+            let fullLine = line;
+            if (this.pendingCommand?.literalBuffer) {
+                fullLine = this.pendingCommand.literalBuffer + line;
+                this.pendingCommand.literalBuffer = undefined;
+            }
+            const resp = proto.parseResponseLine(fullLine);
+            if (this.verbose && resp.raw.length < 200) {
+                console.log(`  [imap] < ${resp.raw}`);
+            }
+            // 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 — resolve if waiting
+            if (resp.tag === "+") {
+                // Handled by waitForContinuation
+                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;
+            }
+            // Source body is in literal data (handled by literal buffering in processBuffer)
+            // For now, simplified — the literal handling needs more work for production
+            // TODO: improve literal parsing for BODY[] and BODY[HEADER]
+            messages.push(msg);
+        }
+        return messages;
+    }
+}
+//# sourceMappingURL=imap-native.js.map