@diskd-ai/email-mcp 0.3.0

package/dist/services/imap.service.js

@@ -0,0 +1,1393 @@
+/**
+ * IMAP service — pure business logic for email read operations.
+ *
+ * No MCP dependency — fully unit-testable.
+ */
+import { sanitizeMailboxName, sanitizeSearchQuery } from '../safety/validation.js';
+import { detectLabelStrategy } from './label-strategy.js';
+// ---------------------------------------------------------------------------
+// Helpers (must be defined before ImapService)
+// ---------------------------------------------------------------------------
+function parseAddress(addr) {
+    return {
+        name: addr?.name ?? undefined,
+        address: addr?.address ?? 'unknown',
+    };
+}
+function parseAddresses(addrs) {
+    if (!addrs)
+        return [];
+    return addrs.map(parseAddress);
+}
+function hasAttachments(bodyStructure) {
+    if (!bodyStructure || typeof bodyStructure !== 'object')
+        return false;
+    const bs = bodyStructure;
+    if (bs.disposition === 'attachment')
+        return true;
+    if (Array.isArray(bs.childNodes)) {
+        return bs.childNodes.some((child) => hasAttachments(child));
+    }
+    return false;
+}
+function extractAttachments(bodyStructure) {
+    const attachments = [];
+    if (!bodyStructure || typeof bodyStructure !== 'object')
+        return attachments;
+    const bs = bodyStructure;
+    if (bs.disposition === 'attachment') {
+        const params = (bs.dispositionParameters ?? bs.parameters ?? {});
+        attachments.push({
+            filename: params.filename ?? params.name ?? 'unnamed',
+            mimeType: `${bs.type ?? 'application'}/${bs.subtype ?? 'octet-stream'}`,
+            size: bs.size ?? 0,
+        });
+    }
+    if (Array.isArray(bs.childNodes)) {
+        bs.childNodes.forEach((child) => {
+            attachments.push(...extractAttachments(child));
+        });
+    }
+    return attachments;
+}
+/** Find the MIME part number for an attachment by filename. */
+function findMimePartByFilename(bodyStructure, targetFilename, partPath = '') {
+    if (!bodyStructure || typeof bodyStructure !== 'object')
+        return undefined;
+    const bs = bodyStructure;
+    const currentPart = bs.part;
+    const effectivePath = currentPart ?? partPath;
+    if (bs.disposition === 'attachment') {
+        const params = (bs.dispositionParameters ?? bs.parameters ?? {});
+        const filename = params.filename ?? params.name ?? 'unnamed';
+        if (filename === targetFilename)
+            return effectivePath;
+    }
+    if (Array.isArray(bs.childNodes)) {
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < bs.childNodes.length; i++) {
+            const childPart = effectivePath ? `${effectivePath}.${i + 1}` : String(i + 1);
+            const found = findMimePartByFilename(bs.childNodes[i], targetFilename, childPart);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+function messageToEmailMeta(msg) {
+    const envelope = (msg.envelope ?? {});
+    const flags = new Set((msg.flags ?? []));
+    // Extract non-system flags as labels (IMAP keywords)
+    const labels = [...flags].filter((f) => !f.startsWith('\\'));
+    // Extract preview from source buffer
+    let preview;
+    if (msg.source && Buffer.isBuffer(msg.source)) {
+        const rawText = msg.source.toString('utf-8');
+        // Try to extract body text after the header blank line
+        const bodyStart = rawText.indexOf('\r\n\r\n');
+        if (bodyStart >= 0) {
+            preview = rawText
+                .slice(bodyStart + 4, bodyStart + 204)
+                .replace(/\s+/g, ' ')
+                .trim();
+        }
+    }
+    return {
+        id: String(msg.uid ?? msg.seq),
+        subject: envelope.subject ?? '(no subject)',
+        from: parseAddress(envelope.from?.[0]),
+        to: parseAddresses(envelope.to),
+        date: envelope.date
+            ? new Date(envelope.date).toISOString()
+            : new Date().toISOString(),
+        seen: flags.has('\\Seen'),
+        flagged: flags.has('\\Flagged'),
+        answered: flags.has('\\Answered'),
+        hasAttachments: hasAttachments(msg.bodyStructure),
+        labels,
+        preview,
+    };
+}
+async function messageToEmail(msg, client, uid) {
+    const meta = messageToEmailMeta(msg);
+    const envelope = (msg.envelope ?? {});
+    // Parse full source for body content
+    let bodyText;
+    let bodyHtml;
+    const headers = {};
+    if (msg.source && Buffer.isBuffer(msg.source)) {
+        const raw = msg.source.toString('utf-8');
+        const headerEnd = raw.indexOf('\r\n\r\n');
+        if (headerEnd >= 0) {
+            // Parse headers
+            const headerSection = raw.slice(0, headerEnd);
+            headerSection.split('\r\n').forEach((line) => {
+                const colonIdx = line.indexOf(':');
+                if (colonIdx > 0 && !line.startsWith(' ') && !line.startsWith('\t')) {
+                    const key = line.slice(0, colonIdx).trim().toLowerCase();
+                    const value = line.slice(colonIdx + 1).trim();
+                    headers[key] = value;
+                }
+            });
+            const body = raw.slice(headerEnd + 4);
+            // Simple content type detection
+            const contentType = headers['content-type'] ?? '';
+            if (contentType.includes('text/html')) {
+                bodyHtml = body;
+            }
+            else {
+                bodyText = body;
+            }
+        }
+    }
+    // Try to get text/html parts via download if body parsing was simple
+    try {
+        const textPart = await client.download(String(uid), '1', { uid: true });
+        if (textPart?.content) {
+            const chunks = [];
+            // eslint-disable-next-line no-restricted-syntax
+            for await (const chunk of textPart.content) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            bodyText = Buffer.concat(chunks).toString('utf-8');
+        }
+    }
+    catch {
+        // Part may not exist
+    }
+    return {
+        ...meta,
+        cc: parseAddresses(envelope.cc),
+        bcc: parseAddresses(envelope.bcc),
+        bodyText,
+        bodyHtml,
+        messageId: envelope.messageId ?? '',
+        inReplyTo: envelope.inReplyTo ?? undefined,
+        references: headers.references?.split(/\s+/).filter(Boolean),
+        attachments: extractAttachments(msg.bodyStructure),
+        headers,
+    };
+}
+// ---------------------------------------------------------------------------
+// Service
+// ---------------------------------------------------------------------------
+export default class ImapService {
+    connections;
+    labelStrategies = new Map();
+    labelStrategyPending = new Map();
+    constructor(connections) {
+        this.connections = connections;
+    }
+    async getLabelStrategy(accountName) {
+        const cached = this.labelStrategies.get(accountName);
+        if (cached)
+            return cached;
+        // Deduplicate concurrent detection for the same account
+        const pending = this.labelStrategyPending.get(accountName);
+        if (pending)
+            return pending;
+        const promise = (async () => {
+            const client = await this.connections.getImapClient(accountName);
+            const strategy = await detectLabelStrategy(client);
+            this.labelStrategies.set(accountName, strategy);
+            this.labelStrategyPending.delete(accountName);
+            return strategy;
+        })();
+        this.labelStrategyPending.set(accountName, promise);
+        return promise;
+    }
+    // -------------------------------------------------------------------------
+    // Mailboxes
+    // -------------------------------------------------------------------------
+    async listMailboxes(accountName) {
+        const client = await this.connections.getImapClient(accountName);
+        const mailboxes = await client.list();
+        const statusResults = await Promise.allSettled(mailboxes.map(async (mb) => {
+            const status = await client.status(mb.path, {
+                messages: true,
+                unseen: true,
+            });
+            return {
+                name: mb.name,
+                path: mb.path,
+                specialUse: mb.specialUse ?? undefined,
+                totalMessages: status.messages ?? 0,
+                unseenMessages: status.unseen ?? 0,
+            };
+        }));
+        return statusResults.map((result, idx) => {
+            if (result.status === 'fulfilled') {
+                return result.value;
+            }
+            // Fallback for folders that don't support STATUS (e.g. \Noselect)
+            const mb = mailboxes[idx];
+            return {
+                name: mb.name,
+                path: mb.path,
+                specialUse: mb.specialUse ?? undefined,
+                totalMessages: 0,
+                unseenMessages: 0,
+            };
+        });
+    }
+    // -------------------------------------------------------------------------
+    // List emails
+    // -------------------------------------------------------------------------
+    async listEmails(accountName, options = {}) {
+        const client = await this.connections.getImapClient(accountName);
+        const mailbox = sanitizeMailboxName(options.mailbox ?? 'INBOX');
+        const page = options.page ?? 1;
+        const pageSize = options.pageSize ?? 20;
+        const lock = await client.getMailboxLock(mailbox);
+        try {
+            // Build search criteria
+            const search = {};
+            if (options.since)
+                search.since = new Date(options.since);
+            if (options.before)
+                search.before = new Date(options.before);
+            if (options.from)
+                search.from = options.from;
+            if (options.subject)
+                search.subject = options.subject;
+            if (options.seen !== undefined)
+                search.seen = options.seen;
+            if (options.flagged !== undefined)
+                search.flagged = options.flagged;
+            if (options.answered !== undefined)
+                search.answered = options.answered;
+            // Search for matching UIDs
+            const searchResult = await client.search(search, { uid: true });
+            let uids = Array.isArray(searchResult) ? searchResult : [];
+            // Post-filter for hasAttachment (IMAP has no native attachment search)
+            if (options.hasAttachment !== undefined && uids.length > 0) {
+                const filteredUids = [];
+                // eslint-disable-next-line no-restricted-syntax
+                for await (const msg of client.fetch(uids.join(','), { uid: true, bodyStructure: true }, { uid: true })) {
+                    const raw = msg;
+                    if (options.hasAttachment === hasAttachments(raw.bodyStructure)) {
+                        filteredUids.push(raw.uid);
+                    }
+                }
+                uids = filteredUids;
+            }
+            if (uids.length === 0) {
+                return {
+                    items: [],
+                    total: 0,
+                    page,
+                    pageSize,
+                    hasMore: false,
+                };
+            }
+            // Sort descending (newest first) and paginate
+            uids.sort((a, b) => b - a);
+            const total = uids.length;
+            const start = (page - 1) * pageSize;
+            const pageUids = uids.slice(start, start + pageSize);
+            if (pageUids.length === 0) {
+                return {
+                    items: [],
+                    total,
+                    page,
+                    pageSize,
+                    hasMore: false,
+                };
+            }
+            const items = [];
+            const range = pageUids.join(',');
+            // eslint-disable-next-line no-restricted-syntax
+            for await (const msg of client.fetch(range, {
+                uid: true,
+                envelope: true,
+                flags: true,
+                bodyStructure: true,
+                source: { start: 0, maxLength: 256 },
+            }, { uid: true })) {
+                items.push(messageToEmailMeta(msg));
+            }
+            // Sort by date descending
+            items.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+            return {
+                items,
+                total,
+                page,
+                pageSize,
+                hasMore: start + pageSize < total,
+            };
+        }
+        finally {
+            lock.release();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Get single email
+    // -------------------------------------------------------------------------
+    async getEmail(accountName, emailId, mailbox = 'INBOX') {
+        const client = await this.connections.getImapClient(accountName);
+        const uid = parseInt(emailId, 10);
+        const safeMailbox = sanitizeMailboxName(mailbox);
+        const lock = await client.getMailboxLock(safeMailbox);
+        try {
+            const msg = await client.fetchOne(String(uid), {
+                uid: true,
+                envelope: true,
+                flags: true,
+                bodyStructure: true,
+                source: true,
+            }, { uid: true });
+            if (!msg) {
+                throw new Error(`Email ${emailId} not found in ${mailbox}`);
+            }
+            return await messageToEmail(msg, client, uid);
+        }
+        finally {
+            lock.release();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Get email flags (lightweight — no body fetch, no \Seen change)
+    // -------------------------------------------------------------------------
+    async getEmailFlags(accountName, emailId, mailbox = 'INBOX') {
+        const client = await this.connections.getImapClient(accountName);
+        const uid = parseInt(emailId, 10);
+        const lock = await client.getMailboxLock(mailbox);
+        try {
+            const msg = await client.fetchOne(String(uid), { uid: true, envelope: true, flags: true }, { uid: true });
+            if (!msg) {
+                throw new Error(`Email ${emailId} not found in ${mailbox}`);
+            }
+            const raw = msg;
+            const flags = new Set((raw.flags ?? []));
+            const labels = [...flags].filter((f) => !f.startsWith('\\'));
+            const envelope = (raw.envelope ?? {});
+            const fromEntry = envelope.from?.[0];
+            let from = '';
+            if (fromEntry) {
+                from = fromEntry.name
+                    ? `${fromEntry.name} <${fromEntry.address}>`
+                    : (fromEntry.address ?? '');
+            }
+            return {
+                seen: flags.has('\\Seen'),
+                flagged: flags.has('\\Flagged'),
+                answered: flags.has('\\Answered'),
+                labels,
+                subject: envelope.subject ?? '(no subject)',
+                from,
+                date: envelope.date ? new Date(envelope.date).toISOString() : '',
+            };
+        }
+        finally {
+            lock.release();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Search emails
+    // -------------------------------------------------------------------------
+    async searchEmails(accountName, query, options = {}) {
+        const client = await this.connections.getImapClient(accountName);
+        const mailbox = sanitizeMailboxName(options.mailbox ?? 'INBOX');
+        const page = options.page ?? 1;
+        const pageSize = options.pageSize ?? 20;
+        const sanitizedQuery = query ? sanitizeSearchQuery(query) : '';
+        const lock = await client.getMailboxLock(mailbox);
+        try {
+            // Build search criteria — base query OR across subject/from/body
+            const baseCriteria = sanitizedQuery
+                ? { or: [{ subject: sanitizedQuery }, { from: sanitizedQuery }, { body: sanitizedQuery }] }
+                : {};
+            // Build additional filters as AND conditions
+            const andConditions = [baseCriteria];
+            if (options.to) {
+                andConditions.push({ to: options.to });
+            }
+            if (options.largerThan !== undefined) {
+                andConditions.push({ larger: options.largerThan * 1024 });
+            }
+            if (options.smallerThan !== undefined) {
+                andConditions.push({ smaller: options.smallerThan * 1024 });
+            }
+            if (options.answered === true) {
+                andConditions.push({ answered: true });
+            }
+            else if (options.answered === false) {
+                andConditions.push({ answered: false });
+            }
+            // Use the combined criteria or just the base
+            const searchCriteria = andConditions.length === 1 ? baseCriteria : Object.assign({}, ...andConditions);
+            const searchResult = await client.search(searchCriteria, { uid: true });
+            let uids = Array.isArray(searchResult) ? searchResult : [];
+            // Post-filter for has_attachment if requested (IMAP doesn't have native support)
+            if (options.hasAttachment !== undefined && uids.length > 0) {
+                const filteredUids = [];
+                const checkRange = uids.join(',');
+                // eslint-disable-next-line no-restricted-syntax
+                for await (const msg of client.fetch(checkRange, { uid: true, bodyStructure: true }, { uid: true })) {
+                    const raw = msg;
+                    const msgHasAtt = hasAttachments(raw.bodyStructure);
+                    if (options.hasAttachment === msgHasAtt) {
+                        filteredUids.push(raw.uid);
+                    }
+                }
+                uids = filteredUids;
+            }
+            if (uids.length === 0) {
+                return {
+                    items: [],
+                    total: 0,
+                    page,
+                    pageSize,
+                    hasMore: false,
+                };
+            }
+            uids.sort((a, b) => b - a);
+            const total = uids.length;
+            const start = (page - 1) * pageSize;
+            const pageUids = uids.slice(start, start + pageSize);
+            if (pageUids.length === 0) {
+                return {
+                    items: [],
+                    total,
+                    page,
+                    pageSize,
+                    hasMore: false,
+                };
+            }
+            const items = [];
+            const range = pageUids.join(',');
+            // eslint-disable-next-line no-restricted-syntax
+            for await (const msg of client.fetch(range, {
+                uid: true,
+                envelope: true,
+                flags: true,
+                bodyStructure: true,
+                source: { start: 0, maxLength: 256 },
+            }, { uid: true })) {
+                items.push(messageToEmailMeta(msg));
+            }
+            items.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+            return {
+                items,
+                total,
+                page,
+                pageSize,
+                hasMore: start + pageSize < total,
+            };
+        }
+        finally {
+            lock.release();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Labels
+    // -------------------------------------------------------------------------
+    async listLabels(accountName) {
+        const strategy = await this.getLabelStrategy(accountName);
+        const client = await this.connections.getImapClient(accountName);
+        return strategy.listLabels(client);
+    }
+    async addLabel(accountName, emailId, mailbox, label) {
+        const strategy = await this.getLabelStrategy(accountName);
+        const client = await this.connections.getImapClient(accountName);
+        await strategy.addLabel(client, emailId, mailbox, label);
+    }
+    async removeLabel(accountName, emailId, mailbox, label) {
+        const strategy = await this.getLabelStrategy(accountName);
+        const client = await this.connections.getImapClient(accountName);
+        await strategy.removeLabel(client, emailId, mailbox, label);
+    }
+    async createLabel(accountName, name) {
+        const strategy = await this.getLabelStrategy(accountName);
+        const client = await this.connections.getImapClient(accountName);
+        await strategy.createLabel(client, name);
+    }
+    async deleteLabel(accountName, name) {
+        const strategy = await this.getLabelStrategy(accountName);
+        const client = await this.connections.getImapClient(accountName);
+        await strategy.deleteLabel(client, name);
+    }
+    // -------------------------------------------------------------------------
+    // Virtual-folder detection
+    // -------------------------------------------------------------------------
+    static VIRTUAL_SPECIAL_USE = new Set(['\\All', '\\Flagged']);
+    static async assertRealMailbox(client, mailboxPath) {
+        const mailboxes = await client.list();
+        const mb = mailboxes.find((m) => m.path === mailboxPath);
+        if (!mb)
+            return; // unknown — let the server reject if invalid
+        const virtualFlag = [...ImapService.VIRTUAL_SPECIAL_USE].find((f) => mb.specialUse === f || mb.flags?.has(f));
+        if (virtualFlag) {
+            throw new Error(`"${mailboxPath}" is a virtual folder (${virtualFlag}). ` +
+                'Use find_email_folder to locate the real folder first.');
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Find real folder for an email
+    // -------------------------------------------------------------------------
+    async findEmailFolder(accountName, emailId, sourceMailbox) {
+        const client = await this.connections.getImapClient(accountName);
+        // 1. Fetch Message-ID from the source mailbox
+        let messageId;
+        const srcLock = await client.getMailboxLock(sourceMailbox);
+        try {
+            const msg = await client.fetchOne(emailId, { headers: true }, { uid: true });
+            // biome-ignore lint/complexity/useOptionalChain: optional chain breaks TS type narrowing for union with false
+            if (msg && msg.headers && Buffer.isBuffer(msg.headers)) {
+                const headerText = msg.headers.toString('utf-8');
+                const match = /^message-id:\s*(.+)$/im.exec(headerText);
+                if (match) {
+                    messageId = match[1].trim();
+                }
+            }
+        }
+        finally {
+            srcLock.release();
+        }
+        if (!messageId) {
+            throw new Error('Could not retrieve Message-ID for this email.');
+        }
+        // 2. List all real mailboxes (exclude virtual and non-selectable)
+        const allMailboxes = await client.list();
+        const realMailboxes = allMailboxes.filter((mb) => {
+            if (!mb.listed)
+                return false;
+            if (mb.flags?.has('\\Noselect'))
+                return false;
+            const isVirtual = [...ImapService.VIRTUAL_SPECIAL_USE].some((f) => mb.specialUse === f || mb.flags?.has(f));
+            if (isVirtual)
+                return false;
+            return true;
+        });
+        // 3. Search each real mailbox for the Message-ID (sequential — each needs its own lock)
+        const folders = [];
+        const searchMailbox = async (mbPath) => {
+            try {
+                const lock = await client.getMailboxLock(mbPath);
+                try {
+                    const results = await client.search({ header: { 'message-id': messageId } }, { uid: true });
+                    if (results && Array.isArray(results) && results.length > 0) {
+                        folders.push(mbPath);
+                    }
+                }
+                finally {
+                    lock.release();
+                }
+            }
+            catch {
+                // Skip folders that can't be selected or searched (e.g. \Noselect, INBOX on some providers)
+            }
+        };
+        // eslint-disable-next-line no-restricted-syntax
+        for (const mb of realMailboxes) {
+            // eslint-disable-next-line no-await-in-loop
+            await searchMailbox(mb.path);
+        }
+        return { folders, messageId };
+    }
+    // -------------------------------------------------------------------------
+    // Move / Delete
+    // -------------------------------------------------------------------------
+    async moveEmail(accountName, emailId, sourceMailbox, destinationMailbox) {
+        const client = await this.connections.getImapClient(accountName);
+        const safeSource = sanitizeMailboxName(sourceMailbox);
+        const safeDest = sanitizeMailboxName(destinationMailbox);
+        await ImapService.assertRealMailbox(client, safeSource);
+        const lock = await client.getMailboxLock(safeSource);
+        try {
+            const ok = await client.messageMove(emailId, safeDest, { uid: true });
+            if (!ok) {
+                throw new Error(`IMAP server rejected the move from "${safeSource}" to "${safeDest}".`);
+            }
+        }
+        finally {
+            lock.release();
+        }
+    }
+    async deleteEmail(accountName, emailId, mailbox = 'INBOX', permanent = false) {
+        const client = await this.connections.getImapClient(accountName);
+        const safeMailbox = sanitizeMailboxName(mailbox);
+        if (permanent) {
+            const lock = await client.getMailboxLock(safeMailbox);
+            try {
+                const ok = await client.messageDelete(emailId, { uid: true });
+                if (!ok) {
+                    throw new Error('IMAP server rejected the delete operation.');
+                }
+            }
+            finally {
+                lock.release();
+            }
+        }
+        else {
+            await ImapService.assertRealMailbox(client, safeMailbox);
+            const mailboxes = await client.list();
+            const trash = mailboxes.find((mb) => mb.specialUse === '\\Trash');
+            const trashPath = trash?.path ?? 'Trash';
+            const lock = await client.getMailboxLock(safeMailbox);
+            try {
+                const ok = await client.messageMove(emailId, trashPath, { uid: true });
+                if (!ok) {
+                    throw new Error('IMAP server rejected the move to Trash.');
+                }
+            }
+            finally {
+                lock.release();
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Flag management
+    // -------------------------------------------------------------------------
+    async setFlags(accountName, emailId, mailbox, action) {
+        const client = await this.connections.getImapClient(accountName);
+        const safeMailbox = sanitizeMailboxName(mailbox);
+        const lock = await client.getMailboxLock(safeMailbox);
+        try {
+            const flagMap = {
+                read: { flags: ['\\Seen'], add: true },
+                unread: { flags: ['\\Seen'], add: false },
+                flag: { flags: ['\\Flagged'], add: true },
+                unflag: { flags: ['\\Flagged'], add: false },
+            };
+            const { flags, add } = flagMap[action];
+            let ok;
+            if (add) {
+                ok = await client.messageFlagsAdd(emailId, flags, { uid: true });
+            }
+            else {
+                ok = await client.messageFlagsRemove(emailId, flags, { uid: true });
+            }
+            if (!ok) {
+                throw new Error(`IMAP server rejected the ${action} flag operation.`);
+            }
+        }
+        finally {
+            lock.release();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Bulk operations
+    // -------------------------------------------------------------------------
+    async bulkSetFlags(accountName, ids, mailbox, action) {
+        const client = await this.connections.getImapClient(accountName);
+        const lock = await client.getMailboxLock(mailbox);
+        const result = {
+            total: ids.length,
+            succeeded: 0,
+            failed: 0,
+            errors: [],
+        };
+        try {
+            const flagMap = {
+                mark_read: { flags: ['\\Seen'], add: true },
+                mark_unread: { flags: ['\\Seen'], add: false },
+                flag: { flags: ['\\Flagged'], add: true },
+                unflag: { flags: ['\\Flagged'], add: false },
+            };
+            const { flags, add } = flagMap[action];
+            const range = ids.join(',');
+            let ok;
+            if (add) {
+                ok = await client.messageFlagsAdd(range, flags, { uid: true });
+            }
+            else {
+                ok = await client.messageFlagsRemove(range, flags, { uid: true });
+            }
+            if (ok) {
+                result.succeeded = ids.length;
+            }
+            else {
+                result.failed = ids.length;
+                result.errors = ['IMAP server rejected the flag operation.'];
+            }
+        }
+        catch (err) {
+            result.failed = ids.length;
+            result.errors = [err instanceof Error ? err.message : String(err)];
+        }
+        finally {
+            lock.release();
+        }
+        if (result.errors?.length === 0)
+            delete result.errors;
+        return result;
+    }
+    async bulkMove(accountName, ids, mailbox, destination) {
+        const client = await this.connections.getImapClient(accountName);
+        await ImapService.assertRealMailbox(client, mailbox);
+        const lock = await client.getMailboxLock(mailbox);
+        const result = {
+            total: ids.length,
+            succeeded: 0,
+            failed: 0,
+            errors: [],
+        };
+        try {
+            const range = ids.join(',');
+            const ok = await client.messageMove(range, destination, { uid: true });
+            if (ok) {
+                result.succeeded = ids.length;
+            }
+            else {
+                result.failed = ids.length;
+                result.errors = ['IMAP server rejected the move operation.'];
+            }
+        }
+        catch (err) {
+            result.failed = ids.length;
+            result.errors = [err instanceof Error ? err.message : String(err)];
+        }
+        finally {
+            lock.release();
+        }
+        if (result.errors?.length === 0)
+            delete result.errors;
+        return result;
+    }
+    async bulkDelete(accountName, ids, mailbox, permanent = false) {
+        const client = await this.connections.getImapClient(accountName);
+        const result = {
+            total: ids.length,
+            succeeded: 0,
+            failed: 0,
+            errors: [],
+        };
+        if (permanent) {
+            const lock = await client.getMailboxLock(mailbox);
+            try {
+                const range = ids.join(',');
+                const ok = await client.messageDelete(range, { uid: true });
+                if (ok) {
+                    result.succeeded = ids.length;
+                }
+                else {
+                    result.failed = ids.length;
+                    result.errors = ['IMAP server rejected the delete operation.'];
+                }
+            }
+            catch (err) {
+                result.failed = ids.length;
+                result.errors = [err instanceof Error ? err.message : String(err)];
+            }
+            finally {
+                lock.release();
+            }
+        }
+        else {
+            await ImapService.assertRealMailbox(client, mailbox);
+            const mailboxes = await client.list();
+            const trash = mailboxes.find((mb) => mb.specialUse === '\\Trash');
+            const trashPath = trash?.path ?? 'Trash';
+            const lock = await client.getMailboxLock(mailbox);
+            try {
+                const range = ids.join(',');
+                const ok = await client.messageMove(range, trashPath, { uid: true });
+                if (ok) {
+                    result.succeeded = ids.length;
+                }
+                else {
+                    result.failed = ids.length;
+                    result.errors = ['IMAP server rejected the move to Trash.'];
+                }
+            }
+            catch (err) {
+                result.failed = ids.length;
+                result.errors = [err instanceof Error ? err.message : String(err)];
+            }
+            finally {
+                lock.release();
+            }
+        }
+        if (result.errors?.length === 0)
+            delete result.errors;
+        return result;
+    }
+    // -------------------------------------------------------------------------
+    // Draft management
+    // -------------------------------------------------------------------------
+    async saveDraft(accountName, options) {
+        const client = await this.connections.getImapClient(accountName);
+        const account = this.connections.getAccount(accountName);
+        // Find the Drafts folder
+        const mailboxes = await client.list();
+        const drafts = mailboxes.find((mb) => mb.specialUse === '\\Drafts');
+        const draftsPath = drafts?.path ?? 'Drafts';
+        // Construct RFC 822 message
+        const headers = [
+            `From: ${account.fullName ? `"${account.fullName}" <${account.email}>` : account.email}`,
+            `To: ${options.to.join(', ')}`,
+            `Subject: ${options.subject}`,
+            `Date: ${new Date().toUTCString()}`,
+            `MIME-Version: 1.0`,
+        ];
+        if (options.cc?.length)
+            headers.push(`Cc: ${options.cc.join(', ')}`);
+        if (options.bcc?.length)
+            headers.push(`Bcc: ${options.bcc.join(', ')}`);
+        if (options.inReplyTo)
+            headers.push(`In-Reply-To: ${options.inReplyTo}`);
+        const contentType = options.html ? 'text/html; charset=utf-8' : 'text/plain; charset=utf-8';
+        headers.push(`Content-Type: ${contentType}`);
+        const rawMessage = `${headers.join('\r\n')}\r\n\r\n${options.body}`;
+        const appendResult = await client.append(draftsPath, Buffer.from(rawMessage), [
+            '\\Draft',
+            '\\Seen',
+        ]);
+        return {
+            id: appendResult.uid ?? 0,
+            mailbox: draftsPath,
+        };
+    }
+    /**
+     * Fetch a draft message for sending.
+     * Returns the parsed draft with recipients and content.
+     */
+    async fetchDraft(accountName, emailId, mailbox) {
+        const client = await this.connections.getImapClient(accountName);
+        // Find drafts folder if not specified
+        let draftsPath = mailbox;
+        if (!draftsPath) {
+            const mailboxes = await client.list();
+            const draftsFolder = mailboxes.find((mb) => mb.specialUse === '\\Drafts');
+            draftsPath = draftsFolder?.path ?? 'Drafts';
+        }
+        const email = await this.getEmail(accountName, String(emailId), draftsPath);
+        return { email, mailbox: draftsPath };
+    }
+    /** Delete a draft after it has been sent. */
+    async deleteDraft(accountName, emailId, mailbox) {
+        const client = await this.connections.getImapClient(accountName);
+        const lock = await client.getMailboxLock(mailbox);
+        try {
+            await client.messageDelete(String(emailId), { uid: true });
+        }
+        finally {
+            lock.release();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Mailbox (folder) CRUD
+    // -------------------------------------------------------------------------
+    async createMailbox(accountName, folderPath) {
+        const client = await this.connections.getImapClient(accountName);
+        await client.mailboxCreate(folderPath);
+    }
+    async renameMailbox(accountName, folderPath, newPath) {
+        const client = await this.connections.getImapClient(accountName);
+        await client.mailboxRename(folderPath, newPath);
+    }
+    async deleteMailbox(accountName, folderPath) {
+        const client = await this.connections.getImapClient(accountName);
+        await client.mailboxDelete(folderPath);
+    }
+    // -------------------------------------------------------------------------
+    // Attachment download
+    // -------------------------------------------------------------------------
+    async downloadAttachment(accountName, emailId, mailbox, filename, maxSizeBytes = 5 * 1024 * 1024) {
+        const client = await this.connections.getImapClient(accountName);
+        const uid = parseInt(emailId, 10);
+        const lock = await client.getMailboxLock(mailbox);
+        try {
+            // Fetch bodyStructure to find the MIME part
+            const msg = await client.fetchOne(String(uid), { uid: true, bodyStructure: true }, { uid: true });
+            if (!msg) {
+                throw new Error(`Email ${emailId} not found in ${mailbox}`);
+            }
+            const attachments = extractAttachments(msg.bodyStructure);
+            const attachment = attachments.find((a) => a.filename === filename);
+            if (!attachment) {
+                throw new Error(`Attachment "${filename}" not found. Available: ${attachments.map((a) => a.filename).join(', ') || 'none'}`);
+            }
+            if (attachment.size > maxSizeBytes) {
+                throw new Error(`Attachment "${filename}" is ${Math.round(attachment.size / 1024 / 1024)}MB, exceeds ${Math.round(maxSizeBytes / 1024 / 1024)}MB limit`);
+            }
+            // Find the MIME part number
+            const partNumber = findMimePartByFilename(msg.bodyStructure, filename);
+            if (!partNumber) {
+                throw new Error(`Could not locate MIME part for "${filename}"`);
+            }
+            // Download the part
+            const downloadResult = await client.download(String(uid), partNumber, {
+                uid: true,
+            });
+            if (!downloadResult?.content) {
+                throw new Error(`Failed to download attachment "${filename}"`);
+            }
+            const chunks = [];
+            // eslint-disable-next-line no-restricted-syntax
+            for await (const chunk of downloadResult.content) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            const content = Buffer.concat(chunks);
+            return {
+                filename: attachment.filename,
+                mimeType: attachment.mimeType,
+                size: content.length,
+                contentBase64: content.toString('base64'),
+            };
+        }
+        finally {
+            lock.release();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Save all email attachments to a local directory
+    // -------------------------------------------------------------------------
+    /**
+     * Download and save all non-ICS attachments from an email to a local directory.
+     * Returns metadata including the saved file paths and file:// URLs.
+     *
+     * Attachments larger than maxSizeBytes (default 25 MB) are skipped.
+     */
+    async saveEmailAttachments(accountName, emailId, mailbox, destDir, maxSizeBytes = 25 * 1024 * 1024) {
+        const client = await this.connections.getImapClient(accountName);
+        const uid = parseInt(emailId, 10);
+        const lock = await client.getMailboxLock(mailbox);
+        let attachmentMetas = [];
+        try {
+            const msg = await client.fetchOne(String(uid), { uid: true, bodyStructure: true }, { uid: true });
+            if (!msg)
+                return [];
+            // biome-ignore format: line too long; eslint implicit-arrow-linebreak prevents multi-line implicit return
+            attachmentMetas = extractAttachments(msg.bodyStructure).filter((a) => a.size <= maxSizeBytes && !a.mimeType.includes('calendar') && !a.filename.toLowerCase().endsWith('.ics'));
+        }
+        finally {
+            lock.release();
+        }
+        if (attachmentMetas.length === 0)
+            return [];
+        const { mkdir } = await import('node:fs/promises');
+        await mkdir(destDir, { recursive: true });
+        const results = await Promise.allSettled(attachmentMetas.map(async (meta) => {
+            const downloaded = await this.downloadAttachment(accountName, emailId, mailbox, meta.filename, maxSizeBytes);
+            const safe = meta.filename.replace(/[/\\?%*:|"<>]/g, '_');
+            const localPath = `${destDir}/${safe}`;
+            const { writeFile } = await import('node:fs/promises');
+            await writeFile(localPath, Buffer.from(downloaded.contentBase64, 'base64'));
+            return {
+                filename: meta.filename,
+                localPath,
+                fileUrl: `file://${localPath}`,
+                mimeType: meta.mimeType,
+                size: downloaded.size,
+            };
+        }));
+        return results
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value);
+    }
+    /**
+     * Reconstruct an email thread by following References / In-Reply-To chains.
+     * Searches by Message-ID header for each reference and returns messages in
+     * chronological order. Caps at MAX_THREAD_MESSAGES to prevent runaway chains.
+     */
+    async getThread(accountName, messageId, mailbox = 'INBOX') {
+        const MAX_THREAD_MESSAGES = 50;
+        const client = await this.connections.getImapClient(accountName);
+        const lock = await client.getMailboxLock(mailbox);
+        try {
+            // Collect all Message-IDs in the thread
+            const targetMsgIds = new Set([messageId]);
+            // First, find the root message to get its References chain
+            const rootSearch = await client.search({ header: { 'Message-ID': messageId } }, { uid: true });
+            const rootUids = Array.isArray(rootSearch) ? rootSearch : [];
+            if (rootUids.length > 0) {
+                const rootMsg = await client.fetchOne(String(rootUids[0]), { uid: true, envelope: true, source: true }, { uid: true });
+                if (rootMsg) {
+                    const raw = rootMsg;
+                    const envelope = (raw.envelope ?? {});
+                    const inReplyTo = envelope.inReplyTo;
+                    if (inReplyTo)
+                        targetMsgIds.add(inReplyTo);
+                    // Parse References header from source
+                    if (raw.source && Buffer.isBuffer(raw.source)) {
+                        const src = raw.source.toString('utf-8');
+                        const refMatch = /^References:\s*(.+?)(?:\r?\n(?!\s))/ms.exec(src);
+                        if (refMatch) {
+                            refMatch[1]
+                                .split(/\s+/)
+                                .filter(Boolean)
+                                .forEach((ref) => {
+                                targetMsgIds.add(ref);
+                            });
+                        }
+                    }
+                }
+            }
+            // Search for all related messages by Message-ID
+            const foundUids = new Set();
+            // eslint-disable-next-line no-restricted-syntax
+            for (const msgId of targetMsgIds) {
+                if (foundUids.size >= MAX_THREAD_MESSAGES)
+                    break;
+                try {
+                    // eslint-disable-next-line no-await-in-loop
+                    const searchResult = await client.search({ header: { 'Message-ID': msgId } }, { uid: true });
+                    if (Array.isArray(searchResult)) {
+                        searchResult.forEach((uid) => {
+                            foundUids.add(uid);
+                        });
+                    }
+                }
+                catch {
+                    // Header search may not be supported for all messages
+                }
+            }
+            // Also search for messages that reference any of our Message-IDs
+            // eslint-disable-next-line no-restricted-syntax
+            for (const msgId of targetMsgIds) {
+                if (foundUids.size >= MAX_THREAD_MESSAGES)
+                    break;
+                try {
+                    // eslint-disable-next-line no-await-in-loop
+                    const refSearch = await client.search({ header: { References: msgId } }, { uid: true });
+                    if (Array.isArray(refSearch)) {
+                        refSearch.forEach((uid) => {
+                            foundUids.add(uid);
+                        });
+                    }
+                    // eslint-disable-next-line no-await-in-loop
+                    const replySearch = await client.search({ header: { 'In-Reply-To': msgId } }, { uid: true });
+                    if (Array.isArray(replySearch)) {
+                        replySearch.forEach((uid) => {
+                            foundUids.add(uid);
+                        });
+                    }
+                }
+                catch {
+                    // Header search may fail on some servers
+                }
+            }
+            if (foundUids.size === 0) {
+                return {
+                    threadId: messageId,
+                    messages: [],
+                    participants: [],
+                    messageCount: 0,
+                };
+            }
+            // Fetch full content for all thread messages
+            const uidList = Array.from(foundUids).slice(0, MAX_THREAD_MESSAGES);
+            const range = uidList.join(',');
+            const messages = [];
+            // eslint-disable-next-line no-restricted-syntax
+            for await (const msg of client.fetch(range, {
+                uid: true,
+                envelope: true,
+                flags: true,
+                bodyStructure: true,
+                source: true,
+            }, { uid: true })) {
+                const raw = msg;
+                const uid = raw.uid;
+                messages.push(await messageToEmail(raw, client, uid));
+            }
+            // Sort chronologically
+            messages.sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
+            // Extract unique participants
+            const participantMap = new Map();
+            messages.forEach((email) => {
+                const addParticipant = (addr) => {
+                    const key = addr.address.toLowerCase();
+                    if (!participantMap.has(key)) {
+                        participantMap.set(key, addr);
+                    }
+                };
+                addParticipant(email.from);
+                email.to.forEach(addParticipant);
+                email.cc?.forEach(addParticipant);
+            });
+            return {
+                threadId: messageId,
+                messages,
+                participants: Array.from(participantMap.values()),
+                messageCount: messages.length,
+            };
+        }
+        finally {
+            lock.release();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Contact extraction
+    // -------------------------------------------------------------------------
+    async extractContacts(accountName, options = {}) {
+        const client = await this.connections.getImapClient(accountName);
+        const mailbox = options.mailbox ?? 'INBOX';
+        const limit = Math.min(options.limit ?? 100, 500);
+        const lock = await client.getMailboxLock(mailbox);
+        try {
+            // Search for all messages, take the latest N
+            const searchResult = await client.search({ all: true }, { uid: true });
+            const uids = Array.isArray(searchResult) ? searchResult : [];
+            if (uids.length === 0)
+                return [];
+            uids.sort((a, b) => b - a);
+            const targetUids = uids.slice(0, limit);
+            const range = targetUids.join(',');
+            const contactMap = new Map();
+            // eslint-disable-next-line no-restricted-syntax
+            for await (const msg of client.fetch(range, { uid: true, envelope: true }, { uid: true })) {
+                const envelope = (msg.envelope ?? {});
+                const date = envelope.date ? new Date(envelope.date) : new Date();
+                const addressLists = [
+                    envelope.from,
+                    envelope.to,
+                    envelope.cc,
+                ];
+                addressLists.forEach((addrs) => {
+                    (addrs ?? []).forEach((addr) => {
+                        if (!addr.address)
+                            return;
+                        const key = addr.address.toLowerCase();
+                        const existing = contactMap.get(key);
+                        if (existing) {
+                            existing.frequency += 1;
+                            if (date > existing.lastSeen) {
+                                existing.lastSeen = date;
+                                if (addr.name)
+                                    existing.name = addr.name;
+                            }
+                        }
+                        else {
+                            contactMap.set(key, {
+                                name: addr.name ?? undefined,
+                                email: addr.address,
+                                frequency: 1,
+                                lastSeen: date,
+                            });
+                        }
+                    });
+                });
+            }
+            // Sort by frequency descending
+            const contacts = Array.from(contactMap.values())
+                .sort((a, b) => b.frequency - a.frequency)
+                .map((c) => ({
+                name: c.name,
+                email: c.email,
+                frequency: c.frequency,
+                lastSeen: c.lastSeen.toISOString(),
+            }));
+            return contacts;
+        }
+        finally {
+            lock.release();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Email analytics
+    // -------------------------------------------------------------------------
+    async getEmailStats(accountName, mailbox, period) {
+        const client = await this.connections.getImapClient(accountName);
+        const now = new Date();
+        const since = new Date(now);
+        if (period === 'day')
+            since.setDate(since.getDate() - 1);
+        else if (period === 'week')
+            since.setDate(since.getDate() - 7);
+        else
+            since.setMonth(since.getMonth() - 1);
+        const lock = await client.getMailboxLock(mailbox);
+        try {
+            // Date-range search
+            const uids = await client
+                .search({ since }, { uid: true })
+                .then((r) => (Array.isArray(r) ? r : []));
+            if (uids.length === 0) {
+                return {
+                    period,
+                    dateRange: {
+                        from: since.toISOString().split('T')[0],
+                        to: now.toISOString().split('T')[0],
+                    },
+                    totalReceived: 0,
+                    unreadCount: 0,
+                    flaggedCount: 0,
+                    topSenders: [],
+                    dailyVolume: [],
+                    hasAttachmentsCount: 0,
+                    avgPerDay: 0,
+                };
+            }
+            const range = uids.join(',');
+            const senderMap = new Map();
+            const dailyMap = new Map();
+            let unread = 0;
+            let flagged = 0;
+            let withAttachments = 0;
+            // eslint-disable-next-line no-restricted-syntax
+            for await (const msg of client.fetch(range, {
+                uid: true,
+                envelope: true,
+                flags: true,
+                bodyStructure: true,
+            }, { uid: true })) {
+                const envelope = (msg.envelope ?? {});
+                const flags = (msg.flags ??
+                    new Set());
+                const { bodyStructure } = msg;
+                // Count flags
+                if (!flags.has('\\Seen'))
+                    unread += 1;
+                if (flags.has('\\Flagged'))
+                    flagged += 1;
+                if (hasAttachments(bodyStructure))
+                    withAttachments += 1;
+                // Track sender
+                const fromList = (envelope.from ?? []);
+                if (fromList.length > 0 && fromList[0].address) {
+                    const key = fromList[0].address.toLowerCase();
+                    const existing = senderMap.get(key);
+                    if (existing) {
+                        existing.count += 1;
+                    }
+                    else {
+                        senderMap.set(key, {
+                            email: fromList[0].address,
+                            name: fromList[0].name,
+                            count: 1,
+                        });
+                    }
+                }
+                // Track daily volume
+                const date = envelope.date ? new Date(envelope.date) : new Date();
+                const dayKey = date.toISOString().split('T')[0];
+                dailyMap.set(dayKey, (dailyMap.get(dayKey) ?? 0) + 1);
+            }
+            const topSenders = Array.from(senderMap.values())
+                .sort((a, b) => b.count - a.count)
+                .slice(0, 10);
+            const dailyVolume = Array.from(dailyMap.entries())
+                .map(([date, count]) => ({ date, count }))
+                .sort((a, b) => a.date.localeCompare(b.date));
+            const days = Math.max(1, dailyVolume.length);
+            return {
+                period,
+                dateRange: {
+                    from: since.toISOString().split('T')[0],
+                    to: now.toISOString().split('T')[0],
+                },
+                totalReceived: uids.length,
+                unreadCount: unread,
+                flaggedCount: flagged,
+                topSenders,
+                dailyVolume,
+                hasAttachmentsCount: withAttachments,
+                avgPerDay: Math.round((uids.length / days) * 10) / 10,
+            };
+        }
+        finally {
+            lock.release();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Quota
+    // -------------------------------------------------------------------------
+    async getQuota(accountName) {
+        const client = await this.connections.getImapClient(accountName);
+        try {
+            const quota = await client.getQuotaForMailbox('INBOX');
+            if (!quota?.storage?.limit)
+                return null;
+            const usedMb = Math.round((quota.storage.usage ?? 0) / 1024);
+            const totalMb = Math.round(quota.storage.limit / 1024);
+            return {
+                usedMb,
+                totalMb,
+                percentage: totalMb > 0 ? Math.round((usedMb / totalMb) * 100) : 0,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Capabilities
+    // -------------------------------------------------------------------------
+    async getCapabilities(accountName) {
+        const client = await this.connections.getImapClient(accountName);
+        try {
+            // ImapFlow exposes capabilities as a Set on the client
+            const caps = client.capabilities;
+            return caps ? Array.from(caps) : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Calendar part extraction
+    // -------------------------------------------------------------------------
+    /* eslint-disable no-await-in-loop, no-restricted-syntax -- Sequential IMAP fetch required */
+    async getCalendarParts(accountName, mailbox, emailId) {
+        const client = await this.connections.getImapClient(accountName);
+        const lock = await client.getMailboxLock(mailbox);
+        try {
+            const icsContents = [];
+            // Fetch body structure
+            for await (const msg of client.fetch(emailId, { uid: true, bodyStructure: true }, { uid: true })) {
+                const structure = msg.bodyStructure;
+                const parts = this.findCalendarParts(structure);
+                // Fetch each calendar part
+                for (const partId of parts) {
+                    for await (const partMsg of client.fetch(emailId, { uid: true, bodyParts: [partId] }, { uid: true })) {
+                        const bodyParts = partMsg.bodyParts;
+                        if (bodyParts) {
+                            bodyParts.forEach((buf) => {
+                                icsContents.push(buf.toString('utf-8'));
+                            });
+                        }
+                    }
+                }
+            }
+            return icsContents;
+        }
+        finally {
+            lock.release();
+        }
+    }
+    /* eslint-enable no-await-in-loop, no-restricted-syntax */
+    /**
+     * Recursively find body parts with text/calendar content type.
+     */
+    findCalendarParts(structure, prefix = '') {
+        if (!structure || typeof structure !== 'object')
+            return [];
+        const s = structure;
+        const parts = [];
+        const type = s.type?.toLowerCase() ?? '';
+        const subtype = s.subtype?.toLowerCase() ?? '';
+        const disposition = s.disposition?.toLowerCase() ?? '';
+        // Check for text/calendar part
+        if (type === 'text' && subtype === 'calendar') {
+            const partId = s.part;
+            if (partId)
+                parts.push(partId);
+            else if (prefix)
+                parts.push(prefix);
+        }
+        // Check for .ics attachment
+        if (disposition === 'attachment' && typeof s.dispositionParameters === 'object') {
+            const params = s.dispositionParameters;
+            const filename = params.filename ?? '';
+            if (filename.toLowerCase().endsWith('.ics')) {
+                const partId = s.part;
+                if (partId)
+                    parts.push(partId);
+                else if (prefix)
+                    parts.push(prefix);
+            }
+        }
+        // Recurse into child nodes
+        if (Array.isArray(s.childNodes)) {
+            s.childNodes.forEach((child, i) => {
+                const childPrefix = prefix ? `${prefix}.${i + 1}` : `${i + 1}`;
+                parts.push(...this.findCalendarParts(child, childPrefix));
+            });
+        }
+        return parts;
+    }
+}
+//# sourceMappingURL=imap.service.js.map