@builderbot/provider-email 1.3.15-alpha.8

package/dist/index.cjs

@@ -0,0 +1,871 @@
+'use strict';
+
+var bot = require('@builderbot/bot');
+var promises = require('fs/promises');
+var os = require('os');
+var path = require('path');
+var imapflow = require('imapflow');
+var mailparser = require('mailparser');
+var EventEmitter = require('node:events');
+var nodemailer = require('nodemailer');
+
+/**
+ * Class representing EmailCoreVendor, handles IMAP/SMTP operations.
+ * @extends EventEmitter
+ */
+class EmailCoreVendor extends EventEmitter {
+    constructor(config) {
+        super();
+        this.imapClient = null;
+        this.smtpTransporter = null;
+        this.isConnected = false;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 10;
+        this.reconnectDelay = 5000;
+        this.config = config;
+        this.initializeSmtp();
+    }
+    /**
+     * Initialize SMTP transporter for sending emails
+     */
+    initializeSmtp() {
+        try {
+            this.smtpTransporter = nodemailer.createTransport({
+                host: this.config.smtp.host,
+                port: this.config.smtp.port,
+                secure: this.config.smtp.secure ?? true,
+                auth: {
+                    user: this.config.smtp.auth.user,
+                    pass: this.config.smtp.auth.pass,
+                },
+            });
+            console.log('[EmailProvider] SMTP transporter initialized');
+        }
+        catch (error) {
+            console.error('[EmailProvider] Failed to initialize SMTP:', error);
+            this.emit('auth_failure', error);
+        }
+    }
+    /**
+     * Connect to IMAP server and start listening for new emails
+     */
+    async connect() {
+        try {
+            this.imapClient = new imapflow.ImapFlow({
+                host: this.config.imap.host,
+                port: this.config.imap.port,
+                secure: this.config.imap.secure ?? true,
+                auth: {
+                    user: this.config.imap.auth.user,
+                    pass: this.config.imap.auth.pass,
+                },
+                logger: false,
+            });
+            // Handle connection events
+            this.imapClient.on('error', (err) => {
+                console.error('[EmailProvider] IMAP error:', err);
+                this.emit('error', err);
+                this.handleDisconnect();
+            });
+            this.imapClient.on('close', () => {
+                console.log('[EmailProvider] IMAP connection closed');
+                this.isConnected = false;
+                this.handleDisconnect();
+            });
+            await this.imapClient.connect();
+            this.isConnected = true;
+            this.reconnectAttempts = 0;
+            console.log('[EmailProvider] Connected to IMAP server');
+            const host = {
+                email: this.config.imap.auth.user,
+                phone: this.config.imap.auth.user,
+            };
+            this.emit('host', host);
+            this.emit('ready');
+            // Start listening for new emails
+            await this.startIdleListener();
+        }
+        catch (error) {
+            console.error('[EmailProvider] Failed to connect to IMAP:', error);
+            this.emit('auth_failure', error);
+            throw error;
+        }
+    }
+    /**
+     * Handle disconnection and attempt reconnection
+     */
+    async handleDisconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error('[EmailProvider] Max reconnection attempts reached');
+            this.emit('auth_failure', new Error('Max reconnection attempts reached'));
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * this.reconnectAttempts;
+        console.log(`[EmailProvider] Attempting reconnection ${this.reconnectAttempts}/${this.maxReconnectAttempts} in ${delay}ms`);
+        setTimeout(async () => {
+            try {
+                await this.connect();
+            }
+            catch (error) {
+                console.error('[EmailProvider] Reconnection failed:', error);
+            }
+        }, delay);
+    }
+    /**
+     * Start IMAP IDLE listener for real-time email notifications
+     */
+    async startIdleListener() {
+        if (!this.imapClient || !this.isConnected)
+            return;
+        const mailbox = this.config.mailbox || 'INBOX';
+        try {
+            // Select the mailbox
+            const lock = await this.imapClient.getMailboxLock(mailbox);
+            try {
+                // Listen for new messages using EXISTS event
+                this.imapClient.on('exists', async (data) => {
+                    if (data.count > data.prevCount) {
+                        console.log(`[EmailProvider] New email detected in ${data.path}`);
+                        await this.fetchNewEmails(data.prevCount + 1, data.count);
+                    }
+                });
+                // Start IDLE mode
+                console.log(`[EmailProvider] Starting IDLE mode on ${mailbox}`);
+                // Keep the connection alive with IDLE
+                while (this.isConnected && this.imapClient) {
+                    try {
+                        await this.imapClient.idle();
+                    }
+                    catch (idleError) {
+                        if (this.isConnected) {
+                            console.error('[EmailProvider] IDLE error:', idleError);
+                        }
+                        break;
+                    }
+                }
+            }
+            finally {
+                lock.release();
+            }
+        }
+        catch (error) {
+            console.error('[EmailProvider] Failed to start IDLE listener:', error);
+            this.emit('error', error);
+        }
+    }
+    /**
+     * Fetch new emails from a sequence range
+     */
+    async fetchNewEmails(startSeq, endSeq) {
+        if (!this.imapClient || !this.isConnected)
+            return;
+        const mailbox = this.config.mailbox || 'INBOX';
+        try {
+            const lock = await this.imapClient.getMailboxLock(mailbox);
+            try {
+                for await (const message of this.imapClient.fetch(`${startSeq}:${endSeq}`, {
+                    source: true,
+                    uid: true,
+                })) {
+                    try {
+                        const parsed = await mailparser.simpleParser(message.source);
+                        const emailContext = this.parseEmailToContext(parsed, message.uid);
+                        if (emailContext) {
+                            // Mark as read if configured
+                            if (this.config.markAsRead !== false) {
+                                await this.imapClient.messageFlagsAdd({ uid: message.uid }, ['\\Seen']);
+                            }
+                            this.emit('message', emailContext);
+                        }
+                    }
+                    catch (parseError) {
+                        console.error('[EmailProvider] Failed to parse email:', parseError);
+                    }
+                }
+            }
+            finally {
+                lock.release();
+            }
+        }
+        catch (error) {
+            console.error('[EmailProvider] Failed to fetch new emails:', error);
+        }
+    }
+    /**
+     * Parse a mailparser ParsedMail object to EmailBotContext
+     */
+    parseEmailToContext(parsed, uid) {
+        const fromAddress = this.extractAddress(parsed.from);
+        if (!fromAddress) {
+            console.warn('[EmailProvider] Email has no from address, skipping');
+            return null;
+        }
+        // Extract attachments
+        const attachments = (parsed.attachments || []).map((att) => ({
+            filename: att.filename || 'unnamed',
+            contentType: att.contentType,
+            size: att.size,
+            contentId: att.contentId,
+            content: att.content,
+        }));
+        // Determine if this is a reply
+        const isReply = !!(parsed.inReplyTo || (parsed.references && parsed.references.length > 0));
+        // Get thread ID from references
+        const threadId = parsed.references
+            ? Array.isArray(parsed.references)
+                ? parsed.references[0]
+                : parsed.references
+            : parsed.inReplyTo || parsed.messageId;
+        // Build body - generate special events for attachments
+        let body = parsed.text || '';
+        if (attachments.length > 0 && !body.trim()) {
+            // Email with only attachments
+            const hasMedia = attachments.some((a) => a.contentType.startsWith('image/') || a.contentType.startsWith('video/'));
+            const hasDocument = attachments.some((a) => a.contentType.startsWith('application/') || a.contentType.startsWith('text/'));
+            if (hasMedia) {
+                body = bot.utils.generateRefProvider('_event_media_');
+            }
+            else if (hasDocument) {
+                body = bot.utils.generateRefProvider('_event_document_');
+            }
+        }
+        const context = {
+            from: fromAddress.address,
+            name: fromAddress.name || fromAddress.address,
+            body: body,
+            subject: parsed.subject || '(no subject)',
+            messageId: parsed.messageId || `${uid}@${this.config.imap.host}`,
+            threadId: threadId,
+            inReplyTo: parsed.inReplyTo,
+            attachments: attachments.length > 0 ? attachments : undefined,
+            isReply: isReply,
+            html: parsed.html || undefined,
+            to: this.extractAddresses(parsed.to),
+            cc: parsed.cc ? this.extractAddresses(parsed.cc) : undefined,
+            date: parsed.date,
+            uid: uid,
+        };
+        return context;
+    }
+    /**
+     * Extract single address from AddressObject
+     */
+    extractAddress(addressObj) {
+        if (!addressObj)
+            return null;
+        const obj = Array.isArray(addressObj) ? addressObj[0] : addressObj;
+        if (!obj || !obj.value || obj.value.length === 0)
+            return null;
+        const first = obj.value[0];
+        return {
+            address: first.address || '',
+            name: first.name || '',
+        };
+    }
+    /**
+     * Extract array of addresses from AddressObject
+     */
+    extractAddresses(addressObj) {
+        if (!addressObj)
+            return [];
+        const objects = Array.isArray(addressObj) ? addressObj : [addressObj];
+        const addresses = [];
+        for (const obj of objects) {
+            if (obj && obj.value) {
+                for (const addr of obj.value) {
+                    if (addr.address) {
+                        addresses.push(addr.address);
+                    }
+                }
+            }
+        }
+        return addresses;
+    }
+    /**
+     * Send an email via SMTP
+     */
+    async sendEmail(to, subject, text, options) {
+        if (!this.smtpTransporter) {
+            throw new Error('SMTP transporter not initialized');
+        }
+        const fromEmail = this.config.fromEmail || this.config.smtp.auth.user;
+        const fromName = this.config.fromName || fromEmail;
+        const mailOptions = {
+            from: `"${fromName}" <${fromEmail}>`,
+            to: to,
+            subject: subject,
+            text: text,
+        };
+        // Add optional fields
+        if (options?.html) {
+            mailOptions.html = options.html;
+        }
+        if (options?.cc) {
+            mailOptions.cc = options.cc;
+        }
+        if (options?.bcc) {
+            mailOptions.bcc = options.bcc;
+        }
+        if (options?.replyTo) {
+            mailOptions.replyTo = options.replyTo;
+        }
+        if (options?.inReplyTo) {
+            mailOptions.inReplyTo = options.inReplyTo;
+        }
+        if (options?.references) {
+            mailOptions.references = Array.isArray(options.references)
+                ? options.references.join(' ')
+                : options.references;
+        }
+        if (options?.attachments) {
+            mailOptions.attachments = options.attachments.map((att) => ({
+                filename: att.filename,
+                path: att.path,
+                content: att.content,
+                contentType: att.contentType,
+            }));
+        }
+        try {
+            const info = await this.smtpTransporter.sendMail(mailOptions);
+            console.log(`[EmailProvider] Email sent: ${info.messageId}`);
+            return { messageId: info.messageId };
+        }
+        catch (error) {
+            console.error('[EmailProvider] Failed to send email:', error);
+            throw error;
+        }
+    }
+    /**
+     * Reply to an existing email thread
+     */
+    async replyToEmail(originalContext, text, options) {
+        // Build references chain
+        const references = [];
+        if (originalContext.threadId) {
+            references.push(originalContext.threadId);
+        }
+        if (originalContext.messageId && originalContext.messageId !== originalContext.threadId) {
+            references.push(originalContext.messageId);
+        }
+        // Prepare subject with Re: prefix if not already present
+        let subject = originalContext.subject;
+        if (!subject.toLowerCase().startsWith('re:')) {
+            subject = `Re: ${subject}`;
+        }
+        return this.sendEmail(originalContext.from, subject, text, {
+            ...options,
+            inReplyTo: originalContext.messageId,
+            references: references,
+        });
+    }
+    /**
+     * Download attachment content
+     */
+    async downloadAttachment(ctx, attachmentIndex) {
+        if (!ctx.attachments || attachmentIndex >= ctx.attachments.length) {
+            return null;
+        }
+        const attachment = ctx.attachments[attachmentIndex];
+        if (attachment.content) {
+            return attachment.content;
+        }
+        // Attachment content should already be in memory from parsing
+        console.warn('[EmailProvider] Attachment content not available');
+        return null;
+    }
+    /**
+     * Disconnect from IMAP server
+     */
+    async disconnect() {
+        this.isConnected = false;
+        if (this.imapClient) {
+            try {
+                await this.imapClient.logout();
+            }
+            catch (error) {
+                console.error('[EmailProvider] Error during logout:', error);
+            }
+            this.imapClient = null;
+        }
+        if (this.smtpTransporter) {
+            this.smtpTransporter.close();
+            this.smtpTransporter = null;
+        }
+        console.log('[EmailProvider] Disconnected');
+    }
+    /**
+     * Check if connected to IMAP server
+     */
+    isImapConnected() {
+        return this.isConnected && this.imapClient !== null;
+    }
+    /**
+     * Verify SMTP connection
+     */
+    async verifySmtp() {
+        if (!this.smtpTransporter)
+            return false;
+        try {
+            await this.smtpTransporter.verify();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+/**
+ * Email Provider for BuilderBot
+ * Supports receiving emails via IMAP (with IDLE) and sending via SMTP
+ * @extends ProviderClass
+ */
+class EmailProvider extends bot.ProviderClass {
+    constructor(args) {
+        super();
+        /**
+         * Index home endpoint
+         */
+        this.indexHome = (_, res) => {
+            res.end('Email Provider running');
+        };
+        /**
+         * Webhook handler for external email notifications (optional)
+         */
+        this.webhookHandler = (req, res) => {
+            // This can be used for external email webhook integrations
+            const body = req.body;
+            console.log('[EmailProvider] Webhook received:', body);
+            res.end(JSON.stringify({ status: 'ok' }));
+        };
+        /**
+         * Map vendor events to provider events
+         */
+        this.busEvents = () => [
+            {
+                event: 'auth_failure',
+                func: (payload) => this.emit('auth_failure', payload),
+            },
+            {
+                event: 'ready',
+                func: () => this.emit('ready', true),
+            },
+            {
+                event: 'message',
+                func: (payload) => {
+                    this.emit('message', payload);
+                },
+            },
+            {
+                event: 'host',
+                func: (payload) => {
+                    this.emit('host', payload);
+                },
+            },
+            {
+                event: 'error',
+                func: (payload) => {
+                    console.error('[EmailProvider] Error:', payload);
+                },
+            },
+        ];
+        // Validate required configuration
+        if (!args.imap) {
+            throw new Error('IMAP configuration is required');
+        }
+        if (!args.smtp) {
+            throw new Error('SMTP configuration is required');
+        }
+        if (!args.imap.host || !args.imap.auth?.user || !args.imap.auth?.pass) {
+            throw new Error('IMAP host and authentication are required');
+        }
+        if (!args.smtp.host || !args.smtp.auth?.user || !args.smtp.auth?.pass) {
+            throw new Error('SMTP host and authentication are required');
+        }
+        this.globalVendorArgs = {
+            name: 'email-bot',
+            port: 3000,
+            writeMyself: 'none',
+            mailbox: 'INBOX',
+            markAsRead: true,
+            ...args,
+        };
+    }
+    /**
+     * Initialize the email vendor (IMAP/SMTP connections)
+     */
+    async initVendor() {
+        const vendor = new EmailCoreVendor(this.globalVendorArgs);
+        this.vendor = vendor;
+        // Connect to IMAP server
+        await vendor.connect();
+        return vendor;
+    }
+    /**
+     * Called before HTTP server initialization
+     */
+    beforeHttpServerInit() {
+        this.server = this.server
+            .use((req, _, next) => {
+            req['globalVendorArgs'] = this.globalVendorArgs;
+            return next();
+        })
+            .get('/', this.indexHome)
+            .post('/webhook', this.webhookHandler);
+    }
+    /**
+     * Called after HTTP server initialization
+     */
+    afterHttpServerInit() { }
+    /**
+     * Send an email message
+     * @param to - Recipient email address
+     * @param message - Email body content
+     * @param options - Send options (subject, attachments, etc.)
+     */
+    async sendMessage(to, message, options) {
+        const emailOptions = options;
+        // Default subject if not provided
+        const subject = emailOptions?.subject || 'Message from Bot';
+        // Check if we're replying to an existing thread
+        if (emailOptions?.inReplyTo) {
+            return this.vendor.sendEmail(to, subject, message, emailOptions);
+        }
+        // Check for media/attachments
+        if (options?.media) {
+            return this.sendMedia(to, message, options.media, emailOptions);
+        }
+        return this.vendor.sendEmail(to, subject, message, emailOptions);
+    }
+    /**
+     * Send an email with media attachment
+     * @param to - Recipient email address
+     * @param message - Email body content
+     * @param mediaPath - Path to media file
+     * @param options - Additional email options
+     */
+    async sendMedia(to, message, mediaPath, options) {
+        const subject = options?.subject || 'Message with attachment';
+        const attachments = [
+            {
+                filename: mediaPath.split('/').pop() || 'attachment',
+                path: mediaPath,
+            },
+        ];
+        return this.vendor.sendEmail(to, subject, message, {
+            ...options,
+            attachments: [...(options?.attachments || []), ...attachments],
+        });
+    }
+    /**
+     * Reply to an existing email thread
+     * @param ctx - Original email context
+     * @param message - Reply message content
+     * @param options - Additional email options
+     */
+    async reply(ctx, message, options) {
+        return this.vendor.replyToEmail(ctx, message, options);
+    }
+    /**
+     * Save an attachment from an email to disk
+     * @param ctx - Email context containing attachments
+     * @param options - Save options (path, attachment index)
+     */
+    async saveFile(ctx, options) {
+        try {
+            const emailCtx = ctx;
+            if (!emailCtx.attachments || emailCtx.attachments.length === 0) {
+                throw new Error('No attachments in email');
+            }
+            const attachmentIndex = options?.attachmentIndex ?? 0;
+            const attachment = emailCtx.attachments[attachmentIndex];
+            if (!attachment) {
+                throw new Error(`Attachment at index ${attachmentIndex} not found`);
+            }
+            if (!attachment.content) {
+                throw new Error('Attachment content not available');
+            }
+            const savePath = options?.path ?? os.tmpdir();
+            const fileName = `${Date.now()}-${attachment.filename}`;
+            const filePath = path.join(savePath, fileName);
+            await promises.writeFile(filePath, attachment.content);
+            return path.resolve(filePath);
+        }
+        catch (error) {
+            console.error('[EmailProvider] Error saving file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get all attachments from an email
+     * @param ctx - Email context
+     */
+    getAttachments(ctx) {
+        return ctx.attachments || [];
+    }
+    /**
+     * Check if the email is a reply
+     * @param ctx - Email context
+     */
+    isReply(ctx) {
+        return ctx.isReply;
+    }
+    /**
+     * Get the thread ID from an email
+     * @param ctx - Email context
+     */
+    getThreadId(ctx) {
+        return ctx.threadId;
+    }
+    /**
+     * Disconnect the email provider
+     */
+    async disconnect() {
+        if (this.vendor) {
+            await this.vendor.disconnect();
+        }
+    }
+}
+
+/**
+ * Email parsing utilities
+ */
+/**
+ * Extract email address from a string that might contain name and email
+ * e.g., "John Doe <john@example.com>" -> "john@example.com"
+ */
+function extractEmailAddress(input) {
+    if (!input)
+        return '';
+    // Check if it contains angle brackets
+    const match = input.match(/<([^>]+)>/);
+    if (match) {
+        return match[1].trim().toLowerCase();
+    }
+    // Return as-is if it looks like an email
+    const trimmed = input.trim().toLowerCase();
+    if (isValidEmail(trimmed)) {
+        return trimmed;
+    }
+    return trimmed;
+}
+/**
+ * Extract name from email string
+ * e.g., "John Doe <john@example.com>" -> "John Doe"
+ */
+function extractEmailName(input) {
+    if (!input)
+        return '';
+    // Check if it contains angle brackets
+    const bracketIndex = input.indexOf('<');
+    if (bracketIndex > 0) {
+        return input
+            .substring(0, bracketIndex)
+            .trim()
+            .replace(/^["']|["']$/g, '');
+    }
+    return '';
+}
+/**
+ * Validate email address format
+ */
+function isValidEmail(email) {
+    if (!email)
+        return false;
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+/**
+ * Clean and normalize email address
+ */
+function cleanEmail(email) {
+    return extractEmailAddress(email).toLowerCase().trim();
+}
+/**
+ * Parse email list (comma or semicolon separated)
+ */
+function parseEmailList(input) {
+    if (!input)
+        return [];
+    return input
+        .split(/[,;]/)
+        .map((email) => extractEmailAddress(email))
+        .filter((email) => isValidEmail(email));
+}
+/**
+ * Format email address with optional name
+ */
+function formatEmailAddress(email, name) {
+    if (name) {
+        return `"${name}" <${email}>`;
+    }
+    return email;
+}
+/**
+ * Extract plain text from HTML email content
+ * Basic implementation - strips HTML tags
+ */
+function htmlToText(html) {
+    if (!html)
+        return '';
+    return (html
+        // Remove script and style tags with content
+        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+        // Replace common block elements with newlines
+        .replace(/<\/?(div|p|br|h[1-6]|li|tr)[^>]*>/gi, '\n')
+        // Remove remaining HTML tags
+        .replace(/<[^>]+>/g, '')
+        // Decode common HTML entities
+        .replace(/&nbsp;/gi, ' ')
+        .replace(/&amp;/gi, '&')
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;/gi, "'")
+        // Clean up whitespace
+        .replace(/\n\s*\n/g, '\n\n')
+        .trim());
+}
+/**
+ * Check if content is likely HTML
+ */
+function isHtml(content) {
+    if (!content)
+        return false;
+    return /<[a-z][\s\S]*>/i.test(content);
+}
+/**
+ * Extract thread ID from References or In-Reply-To headers
+ */
+function extractThreadId(references, inReplyTo) {
+    // Try references first (get the first/root message)
+    if (references) {
+        if (Array.isArray(references) && references.length > 0) {
+            return references[0];
+        }
+        if (typeof references === 'string') {
+            const refs = references.split(/\s+/).filter(Boolean);
+            if (refs.length > 0)
+                return refs[0];
+        }
+    }
+    // Fall back to In-Reply-To
+    if (inReplyTo) {
+        return inReplyTo;
+    }
+    return undefined;
+}
+/**
+ * Check if email subject indicates a reply
+ */
+function isReplySubject(subject) {
+    if (!subject)
+        return false;
+    const replyPrefixes = ['re:', 'r:', 'aw:', 'sv:', 'antw:', 'odp:'];
+    const lowerSubject = subject.toLowerCase().trim();
+    return replyPrefixes.some((prefix) => lowerSubject.startsWith(prefix));
+}
+/**
+ * Strip reply prefixes from subject
+ */
+function stripReplyPrefix(subject) {
+    if (!subject)
+        return '';
+    return subject.replace(/^(re:|r:|aw:|sv:|antw:|odp:)\s*/i, '').trim();
+}
+/**
+ * Add reply prefix to subject if not present
+ */
+function addReplyPrefix(subject) {
+    if (!subject)
+        return 'Re:';
+    if (isReplySubject(subject))
+        return subject;
+    return `Re: ${subject}`;
+}
+/**
+ * Generate a unique message ID
+ */
+function generateMessageId(domain) {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 10);
+    return `<${timestamp}.${random}@${domain}>`;
+}
+/**
+ * Parse MIME content type
+ */
+function parseMimeType(contentType) {
+    if (!contentType) {
+        return { type: 'text', subtype: 'plain', parameters: {} };
+    }
+    const parts = contentType.split(';');
+    const [type, subtype] = (parts[0] || 'text/plain').split('/');
+    const parameters = {};
+    for (let i = 1; i < parts.length; i++) {
+        const param = parts[i].trim();
+        const eqIndex = param.indexOf('=');
+        if (eqIndex > 0) {
+            const key = param.substring(0, eqIndex).trim().toLowerCase();
+            let value = param.substring(eqIndex + 1).trim();
+            // Remove quotes
+            if (value.startsWith('"') && value.endsWith('"')) {
+                value = value.slice(1, -1);
+            }
+            parameters[key] = value;
+        }
+    }
+    return {
+        type: type?.toLowerCase() || 'text',
+        subtype: subtype?.toLowerCase() || 'plain',
+        parameters,
+    };
+}
+/**
+ * Get file extension from MIME type
+ */
+function mimeToExtension(mimeType) {
+    const mimeMap = {
+        'text/plain': 'txt',
+        'text/html': 'html',
+        'text/css': 'css',
+        'text/javascript': 'js',
+        'application/json': 'json',
+        'application/pdf': 'pdf',
+        'application/zip': 'zip',
+        'application/xml': 'xml',
+        'image/jpeg': 'jpg',
+        'image/png': 'png',
+        'image/gif': 'gif',
+        'image/webp': 'webp',
+        'image/svg+xml': 'svg',
+        'audio/mpeg': 'mp3',
+        'audio/wav': 'wav',
+        'audio/ogg': 'ogg',
+        'video/mp4': 'mp4',
+        'video/webm': 'webm',
+        'video/quicktime': 'mov',
+    };
+    const { type, subtype } = parseMimeType(mimeType);
+    const fullType = `${type}/${subtype}`;
+    return mimeMap[fullType] || subtype || 'bin';
+}
+
+exports.EmailCoreVendor = EmailCoreVendor;
+exports.EmailProvider = EmailProvider;
+exports.addReplyPrefix = addReplyPrefix;
+exports.cleanEmail = cleanEmail;
+exports.extractEmailAddress = extractEmailAddress;
+exports.extractEmailName = extractEmailName;
+exports.extractThreadId = extractThreadId;
+exports.formatEmailAddress = formatEmailAddress;
+exports.generateMessageId = generateMessageId;
+exports.htmlToText = htmlToText;
+exports.isHtml = isHtml;
+exports.isReplySubject = isReplySubject;
+exports.isValidEmail = isValidEmail;
+exports.mimeToExtension = mimeToExtension;
+exports.parseEmailList = parseEmailList;
+exports.parseMimeType = parseMimeType;
+exports.stripReplyPrefix = stripReplyPrefix;