@ha-bits/bit-email 1.0.0

package/dist/index.js

@@ -0,0 +1,575 @@
+"use strict";
+/**
+ * @ha-bits/bit-email
+ *
+ * Email integration bit for IMAP fetching and SMTP sending.
+ * Provides triggers for new emails and actions for sending emails.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.email = void 0;
+const imapflow_1 = require("imapflow");
+/**
+ * Fetch emails from IMAP server using imapflow
+ */
+async function fetchImapEmails(host, port, user, password, folder = 'INBOX', limit = 10, unreadOnly = true) {
+    console.log(`📧 IMAP: Connecting to ${host}:${port} as ${user}...`);
+    console.log(`📧 IMAP: Fetching from ${folder}, limit: ${limit}, unreadOnly: ${unreadOnly}`);
+    const client = new imapflow_1.ImapFlow({
+        host,
+        port,
+        secure: port === 993,
+        auth: {
+            user,
+            pass: password,
+        },
+        logger: false,
+    });
+    const emails = [];
+    try {
+        await client.connect();
+        console.log(`📧 IMAP: Connected successfully`);
+        const lock = await client.getMailboxLock(folder);
+        try {
+            // Build search query
+            const searchQuery = unreadOnly ? { seen: false } : 'all';
+            // Search for messages
+            const searchResult = await client.search(searchQuery, { uid: true });
+            const messages = Array.isArray(searchResult) ? searchResult : [];
+            if (messages.length === 0) {
+                console.log(`📧 IMAP: No messages found matching criteria`);
+                return emails;
+            }
+            // Get the most recent messages up to limit
+            const messagesToFetch = messages.slice(-limit).reverse();
+            console.log(`📧 IMAP: Found ${messages.length} messages, fetching ${messagesToFetch.length}`);
+            // Fetch message details
+            for await (const message of client.fetch(messagesToFetch, {
+                uid: true,
+                envelope: true,
+                source: true,
+                bodyStructure: true,
+            })) {
+                const envelope = message.envelope;
+                if (!envelope)
+                    continue;
+                // Parse from address
+                const fromAddr = envelope.from?.[0];
+                const from = fromAddr
+                    ? (fromAddr.name ? `${fromAddr.name} <${fromAddr.address}>` : fromAddr.address || '')
+                    : '';
+                // Parse to addresses
+                const toAddrs = envelope.to || [];
+                const to = toAddrs
+                    .map((addr) => addr.name ? `${addr.name} <${addr.address}>` : addr.address || '')
+                    .join(', ');
+                // Extract body from source
+                let body = '';
+                if (message.source) {
+                    const sourceStr = message.source.toString();
+                    // Simple extraction - find body after headers
+                    const bodyMatch = sourceStr.split(/\r?\n\r?\n/);
+                    if (bodyMatch.length > 1) {
+                        body = bodyMatch.slice(1).join('\n\n');
+                    }
+                }
+                // Extract attachments info from bodyStructure
+                const attachments = [];
+                if (message.bodyStructure) {
+                    extractAttachments(message.bodyStructure, attachments);
+                }
+                emails.push({
+                    id: String(message.uid),
+                    from,
+                    to,
+                    subject: envelope.subject || '',
+                    body,
+                    date: envelope.date?.toISOString() || new Date().toISOString(),
+                    attachments: attachments.length > 0 ? attachments : undefined,
+                });
+            }
+        }
+        finally {
+            lock.release();
+        }
+    }
+    finally {
+        await client.logout();
+        console.log(`📧 IMAP: Disconnected`);
+    }
+    console.log(`📧 IMAP: Fetched ${emails.length} email(s)`);
+    return emails;
+}
+/**
+ * Recursively extract attachment info from bodyStructure
+ */
+function extractAttachments(structure, attachments) {
+    if (!structure)
+        return;
+    // Check if this part is an attachment
+    if (structure.disposition === 'attachment' ||
+        (structure.disposition === 'inline' && structure.dispositionParameters?.filename)) {
+        const filename = structure.dispositionParameters?.filename ||
+            structure.parameters?.name ||
+            'attachment';
+        attachments.push({
+            filename,
+            contentType: `${structure.type}/${structure.subtype}`,
+            size: structure.size || 0,
+        });
+    }
+    // Recurse into child parts
+    if (structure.childNodes && Array.isArray(structure.childNodes)) {
+        for (const child of structure.childNodes) {
+            extractAttachments(child, attachments);
+        }
+    }
+}
+/**
+ * Simulate SMTP send (in real implementation, use nodemailer or similar)
+ */
+async function sendSmtpEmail(host, port, user, password, from, to, subject, body, html, attachments) {
+    console.log(`📤 SMTP: Connecting to ${host}:${port} as ${user}...`);
+    console.log(`📤 SMTP: Sending from ${from} to ${to}`);
+    console.log(`📤 SMTP: Subject: ${subject}`);
+    // In production, this would use nodemailer
+    // For now, return mock response
+    const messageId = `<${Date.now()}.${Math.random().toString(36).substring(7)}@habits.local>`;
+    return {
+        messageId,
+        accepted: [to]
+    };
+}
+const emailBit = {
+    displayName: 'Email (IMAP/SMTP)',
+    description: 'Email integration for fetching (IMAP) and sending (SMTP) emails',
+    logoUrl: 'lucide:Mail',
+    auth: {
+        type: 'CUSTOM',
+        displayName: 'Email Credentials',
+        description: 'IMAP and SMTP server credentials',
+        required: false,
+        props: {
+            imapHost: { type: 'SHORT_TEXT', displayName: 'IMAP Host', required: false },
+            imapPort: { type: 'NUMBER', displayName: 'IMAP Port', required: false, defaultValue: 993 },
+            imapUser: { type: 'SHORT_TEXT', displayName: 'IMAP Username', required: false },
+            imapPassword: { type: 'SECRET_TEXT', displayName: 'IMAP Password', required: false },
+            smtpHost: { type: 'SHORT_TEXT', displayName: 'SMTP Host', required: false },
+            smtpPort: { type: 'NUMBER', displayName: 'SMTP Port', required: false, defaultValue: 587 },
+            smtpUser: { type: 'SHORT_TEXT', displayName: 'SMTP Username', required: false },
+            smtpPassword: { type: 'SECRET_TEXT', displayName: 'SMTP Password', required: false },
+        }
+    },
+    triggers: {
+        /**
+         * IMAP trigger - fetch new emails
+         */
+        newEmail: {
+            name: 'newEmail',
+            displayName: 'New Email (IMAP)',
+            description: 'Trigger when new emails arrive in the mailbox',
+            type: 'POLLING',
+            props: {
+                imapHost: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'IMAP Host',
+                    description: 'IMAP server hostname (e.g., imap.gmail.com)',
+                    required: true,
+                },
+                imapPort: {
+                    type: 'NUMBER',
+                    displayName: 'IMAP Port',
+                    description: 'IMAP server port (default: 993 for SSL)',
+                    required: false,
+                    defaultValue: 993,
+                },
+                imapUser: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'Username',
+                    description: 'Email address or username',
+                    required: true,
+                },
+                imapPassword: {
+                    type: 'SECRET_TEXT',
+                    displayName: 'Password',
+                    description: 'Email password or app-specific password',
+                    required: true,
+                },
+                folder: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'Folder',
+                    description: 'Mailbox folder to monitor',
+                    required: false,
+                    defaultValue: 'INBOX',
+                },
+                unreadOnly: {
+                    type: 'CHECKBOX',
+                    displayName: 'Unread Only',
+                    description: 'Only fetch unread emails',
+                    required: false,
+                    defaultValue: true,
+                },
+                limit: {
+                    type: 'NUMBER',
+                    displayName: 'Limit',
+                    description: 'Maximum number of emails to fetch',
+                    required: false,
+                    defaultValue: 10,
+                },
+            },
+            async run(context) {
+                const { imapHost, imapPort = 993, imapUser, imapPassword, folder = 'INBOX', unreadOnly = true, limit = 10 } = context.propsValue;
+                const host = context.auth?.imapHost || imapHost;
+                const port = context.auth?.imapPort || imapPort;
+                const user = context.auth?.imapUser || imapUser;
+                const password = context.auth?.imapPassword || imapPassword;
+                if (!host || !user || !password) {
+                    throw new Error('IMAP credentials are required');
+                }
+                const emails = await fetchImapEmails(host, Number(port), user, password, String(folder), Number(limit), Boolean(unreadOnly));
+                console.log(`📧 IMAP Trigger: Fetched ${emails.length} email(s)`);
+                return {
+                    emails,
+                    count: emails.length,
+                    folder,
+                    timestamp: new Date().toISOString(),
+                };
+            },
+        },
+    },
+    actions: {
+        /**
+         * New Email action (for workflow testing - simulates IMAP trigger as action)
+         */
+        newEmail: {
+            name: 'newEmail',
+            displayName: 'New Email (IMAP)',
+            description: 'Fetch new emails from IMAP mailbox (action version of trigger)',
+            props: {
+                imapHost: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'IMAP Host',
+                    description: 'IMAP server hostname',
+                    required: false,
+                },
+                imapPort: {
+                    type: 'NUMBER',
+                    displayName: 'IMAP Port',
+                    description: 'IMAP server port',
+                    required: false,
+                    defaultValue: 993,
+                },
+                imapUser: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'Username',
+                    description: 'Email address or username',
+                    required: false,
+                },
+                imapPassword: {
+                    type: 'SECRET_TEXT',
+                    displayName: 'Password',
+                    description: 'Email password',
+                    required: false,
+                },
+                folder: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'Folder',
+                    description: 'Mailbox folder',
+                    required: false,
+                    defaultValue: 'INBOX',
+                },
+                unreadOnly: {
+                    type: 'CHECKBOX',
+                    displayName: 'Unread Only',
+                    description: 'Only fetch unread emails',
+                    required: false,
+                    defaultValue: true,
+                },
+                limit: {
+                    type: 'NUMBER',
+                    displayName: 'Limit',
+                    description: 'Maximum number of emails',
+                    required: false,
+                    defaultValue: 10,
+                },
+            },
+            async run(context) {
+                const { folder = 'INBOX' } = context.propsValue;
+                // Return mock test data for workflow testing
+                const mockEmails = [
+                    {
+                        id: `email_${Date.now()}`,
+                        from: 'customer@example.com',
+                        to: 'support@company.com',
+                        subject: 'Help with my order #12345',
+                        body: 'Hi, I placed an order last week and haven\'t received any shipping confirmation. Can you help me track it? Order number is 12345. Thanks!',
+                        date: new Date().toISOString(),
+                    },
+                    {
+                        id: `email_${Date.now() + 1}`,
+                        from: 'sales.inquiry@prospect.com',
+                        to: 'sales@company.com',
+                        subject: 'Pricing inquiry for enterprise plan',
+                        body: 'We are interested in your enterprise pricing. Our company has 500+ employees. Please send us a quote.',
+                        date: new Date(Date.now() - 3600000).toISOString(),
+                    },
+                ];
+                console.log(`📧 New Email (Mock): Returning ${mockEmails.length} test emails from ${folder}`);
+                return {
+                    emails: mockEmails,
+                    count: mockEmails.length,
+                    folder,
+                    timestamp: new Date().toISOString(),
+                };
+            },
+        },
+        /**
+         * Fetch emails from IMAP server
+         */
+        fetchEmails: {
+            name: 'fetchEmails',
+            displayName: 'Fetch Emails (IMAP)',
+            description: 'Fetch emails from an IMAP mailbox',
+            props: {
+                imapHost: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'IMAP Host',
+                    description: 'IMAP server hostname',
+                    required: true,
+                },
+                imapPort: {
+                    type: 'NUMBER',
+                    displayName: 'IMAP Port',
+                    description: 'IMAP server port',
+                    required: false,
+                    defaultValue: 993,
+                },
+                imapUser: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'Username',
+                    description: 'Email address or username',
+                    required: true,
+                },
+                imapPassword: {
+                    type: 'SECRET_TEXT',
+                    displayName: 'Password',
+                    description: 'Email password',
+                    required: true,
+                },
+                folder: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'Folder',
+                    description: 'Mailbox folder to fetch from',
+                    required: false,
+                    defaultValue: 'INBOX',
+                },
+                unreadOnly: {
+                    type: 'CHECKBOX',
+                    displayName: 'Unread Only',
+                    description: 'Only fetch unread emails',
+                    required: false,
+                    defaultValue: false,
+                },
+                limit: {
+                    type: 'NUMBER',
+                    displayName: 'Limit',
+                    description: 'Maximum number of emails to fetch',
+                    required: false,
+                    defaultValue: 10,
+                },
+            },
+            async run(context) {
+                const { imapHost, imapPort = 993, imapUser, imapPassword, folder = 'INBOX', unreadOnly = false, limit = 10 } = context.propsValue;
+                const host = context.auth?.imapHost || imapHost;
+                const port = context.auth?.imapPort || imapPort;
+                const user = context.auth?.imapUser || imapUser;
+                const password = context.auth?.imapPassword || imapPassword;
+                if (!host || !user || !password) {
+                    throw new Error('IMAP credentials are required');
+                }
+                const emails = await fetchImapEmails(host, Number(port), user, password, String(folder), Number(limit), Boolean(unreadOnly));
+                console.log(`📧 Fetch Emails: Retrieved ${emails.length} email(s) from ${folder}`);
+                return {
+                    emails,
+                    count: emails.length,
+                    folder,
+                };
+            },
+        },
+        /**
+         * Send email via SMTP
+         */
+        sendEmail: {
+            name: 'sendEmail',
+            displayName: 'Send Email (SMTP)',
+            description: 'Send an email via SMTP',
+            props: {
+                smtpHost: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'SMTP Host',
+                    description: 'SMTP server hostname (e.g., smtp.gmail.com)',
+                    required: true,
+                },
+                smtpPort: {
+                    type: 'NUMBER',
+                    displayName: 'SMTP Port',
+                    description: 'SMTP server port (587 for TLS, 465 for SSL)',
+                    required: false,
+                    defaultValue: 587,
+                },
+                smtpUser: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'Username',
+                    description: 'SMTP username/email',
+                    required: true,
+                },
+                smtpPassword: {
+                    type: 'SECRET_TEXT',
+                    displayName: 'Password',
+                    description: 'SMTP password',
+                    required: true,
+                },
+                from: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'From',
+                    description: 'Sender email address',
+                    required: true,
+                },
+                to: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'To',
+                    description: 'Recipient email address(es), comma-separated',
+                    required: true,
+                },
+                cc: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'CC',
+                    description: 'CC recipients (optional)',
+                    required: false,
+                },
+                bcc: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'BCC',
+                    description: 'BCC recipients (optional)',
+                    required: false,
+                },
+                subject: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'Subject',
+                    description: 'Email subject line',
+                    required: true,
+                },
+                body: {
+                    type: 'LONG_TEXT',
+                    displayName: 'Body (Plain Text)',
+                    description: 'Email body in plain text',
+                    required: true,
+                },
+                html: {
+                    type: 'LONG_TEXT',
+                    displayName: 'Body (HTML)',
+                    description: 'Email body in HTML format (optional)',
+                    required: false,
+                },
+                replyTo: {
+                    type: 'SHORT_TEXT',
+                    displayName: 'Reply-To',
+                    description: 'Reply-to address (optional)',
+                    required: false,
+                },
+            },
+            async run(context) {
+                const { smtpHost, smtpPort = 587, smtpUser, smtpPassword, from, to, subject, body, html, cc, bcc, replyTo } = context.propsValue;
+                const host = context.auth?.smtpHost || smtpHost;
+                const port = context.auth?.smtpPort || smtpPort;
+                const user = context.auth?.smtpUser || smtpUser;
+                const password = context.auth?.smtpPassword || smtpPassword;
+                if (!host || !user || !password) {
+                    throw new Error('SMTP credentials are required');
+                }
+                if (!from || !to || !subject || !body) {
+                    throw new Error('From, To, Subject, and Body are required');
+                }
+                const result = await sendSmtpEmail(host, Number(port), user, password, String(from), String(to), String(subject), String(body), html);
+                console.log(`📤 Send Email: Message sent to ${to}`);
+                return {
+                    success: true,
+                    messageId: result.messageId,
+                    accepted: result.accepted,
+                    from,
+                    to,
+                    subject,
+                    timestamp: new Date().toISOString(),
+                };
+            },
+        },
+        /**
+         * Parse email content
+         */
+        parseEmail: {
+            name: 'parseEmail',
+            displayName: 'Parse Email',
+            description: 'Extract structured data from email content',
+            props: {
+                rawEmail: {
+                    type: 'LONG_TEXT',
+                    displayName: 'Raw Email',
+                    description: 'Raw email content or JSON email object',
+                    required: true,
+                },
+                extractAttachments: {
+                    type: 'CHECKBOX',
+                    displayName: 'Extract Attachments',
+                    description: 'Include attachment information',
+                    required: false,
+                    defaultValue: false,
+                },
+            },
+            async run(context) {
+                const { rawEmail, extractAttachments } = context.propsValue;
+                let email;
+                if (typeof rawEmail === 'string') {
+                    try {
+                        email = JSON.parse(rawEmail);
+                    }
+                    catch {
+                        // Parse as raw email text - simplified parsing
+                        const lines = rawEmail.split('\n');
+                        email = {
+                            subject: '',
+                            from: '',
+                            to: '',
+                            body: rawEmail,
+                        };
+                        for (const line of lines) {
+                            if (line.toLowerCase().startsWith('subject:')) {
+                                email.subject = line.substring(8).trim();
+                            }
+                            else if (line.toLowerCase().startsWith('from:')) {
+                                email.from = line.substring(5).trim();
+                            }
+                            else if (line.toLowerCase().startsWith('to:')) {
+                                email.to = line.substring(3).trim();
+                            }
+                        }
+                    }
+                }
+                else {
+                    email = rawEmail;
+                }
+                console.log(`📧 Parse Email: Extracted from ${email.from || 'unknown'}`);
+                return {
+                    from: email.from || '',
+                    to: email.to || '',
+                    subject: email.subject || '',
+                    body: email.body || email.text || '',
+                    html: email.html || '',
+                    date: email.date || new Date().toISOString(),
+                    attachments: extractAttachments ? (email.attachments || []) : [],
+                };
+            },
+        },
+    },
+};
+exports.email = emailBit;
+exports.default = emailBit;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @ha-bits/bit-email\n * \n * Email integration bit for IMAP fetching and SMTP sending.\n * Provides triggers for new emails and actions for sending emails.\n */\n\nimport { ImapFlow } from 'imapflow';\n\ninterface EmailContext {\n  auth?: {\n    imapHost?: string;\n    imapPort?: number;\n    imapUser?: string;\n    imapPassword?: string;\n    smtpHost?: string;\n    smtpPort?: number;\n    smtpUser?: string;\n    smtpPassword?: string;\n  };\n  propsValue: Record<string, any>;\n}\n\ninterface EmailMessage {\n  id: string;\n  from: string;\n  to: string;\n  subject: string;\n  body: string;\n  date: string;\n  attachments?: Array<{\n    filename: string;\n    contentType: string;\n    size: number;\n  }>;\n}\n\n/**\n * Fetch emails from IMAP server using imapflow\n */\nasync function fetchImapEmails(\n  host: string,\n  port: number,\n  user: string,\n  password: string,\n  folder: string = 'INBOX',\n  limit: number = 10,\n  unreadOnly: boolean = true\n): Promise<EmailMessage[]> {\n  console.log(`📧 IMAP: Connecting to ${host}:${port} as ${user}...`);\n  console.log(`📧 IMAP: Fetching from ${folder}, limit: ${limit}, unreadOnly: ${unreadOnly}`);\n  \n  const client = new ImapFlow({\n    host,\n    port,\n    secure: port === 993,\n    auth: {\n      user,\n      pass: password,\n    },\n    logger: false,\n  });\n\n  const emails: EmailMessage[] = [];\n\n  try {\n    await client.connect();\n    console.log(`📧 IMAP: Connected successfully`);\n\n    const lock = await client.getMailboxLock(folder);\n    \n    try {\n      // Build search query\n      const searchQuery: any = unreadOnly ? { seen: false } : 'all';\n      \n      // Search for messages\n      const searchResult = await client.search(searchQuery, { uid: true });\n      const messages = Array.isArray(searchResult) ? searchResult : [];\n      \n      if (messages.length === 0) {\n        console.log(`📧 IMAP: No messages found matching criteria`);\n        return emails;\n      }\n\n      // Get the most recent messages up to limit\n      const messagesToFetch = messages.slice(-limit).reverse();\n      console.log(`📧 IMAP: Found ${messages.length} messages, fetching ${messagesToFetch.length}`);\n\n      // Fetch message details\n      for await (const message of client.fetch(messagesToFetch, {\n        uid: true,\n        envelope: true,\n        source: true,\n        bodyStructure: true,\n      })) {\n        const envelope = message.envelope;\n        if (!envelope) continue;\n        \n        // Parse from address\n        const fromAddr = envelope.from?.[0];\n        const from = fromAddr \n          ? (fromAddr.name ? `${fromAddr.name} <${fromAddr.address}>` : fromAddr.address || '')\n          : '';\n        \n        // Parse to addresses\n        const toAddrs = envelope.to || [];\n        const to = toAddrs\n          .map((addr: any) => addr.name ? `${addr.name} <${addr.address}>` : addr.address || '')\n          .join(', ');\n\n        // Extract body from source\n        let body = '';\n        if (message.source) {\n          const sourceStr = message.source.toString();\n          // Simple extraction - find body after headers\n          const bodyMatch = sourceStr.split(/\\r?\\n\\r?\\n/);\n          if (bodyMatch.length > 1) {\n            body = bodyMatch.slice(1).join('\\n\\n');\n          }\n        }\n\n        // Extract attachments info from bodyStructure\n        const attachments: Array<{ filename: string; contentType: string; size: number }> = [];\n        if (message.bodyStructure) {\n          extractAttachments(message.bodyStructure, attachments);\n        }\n\n        emails.push({\n          id: String(message.uid),\n          from,\n          to,\n          subject: envelope.subject || '',\n          body,\n          date: envelope.date?.toISOString() || new Date().toISOString(),\n          attachments: attachments.length > 0 ? attachments : undefined,\n        });\n      }\n    } finally {\n      lock.release();\n    }\n  } finally {\n    await client.logout();\n    console.log(`📧 IMAP: Disconnected`);\n  }\n\n  console.log(`📧 IMAP: Fetched ${emails.length} email(s)`);\n  return emails;\n}\n\n/**\n * Recursively extract attachment info from bodyStructure\n */\nfunction extractAttachments(\n  structure: any,\n  attachments: Array<{ filename: string; contentType: string; size: number }>\n): void {\n  if (!structure) return;\n\n  // Check if this part is an attachment\n  if (structure.disposition === 'attachment' || \n      (structure.disposition === 'inline' && structure.dispositionParameters?.filename)) {\n    const filename = structure.dispositionParameters?.filename || \n                     structure.parameters?.name || \n                     'attachment';\n    attachments.push({\n      filename,\n      contentType: `${structure.type}/${structure.subtype}`,\n      size: structure.size || 0,\n    });\n  }\n\n  // Recurse into child parts\n  if (structure.childNodes && Array.isArray(structure.childNodes)) {\n    for (const child of structure.childNodes) {\n      extractAttachments(child, attachments);\n    }\n  }\n}\n\n/**\n * Simulate SMTP send (in real implementation, use nodemailer or similar)\n */\nasync function sendSmtpEmail(\n  host: string,\n  port: number,\n  user: string,\n  password: string,\n  from: string,\n  to: string,\n  subject: string,\n  body: string,\n  html?: string,\n  attachments?: Array<{ filename: string; content: string | Buffer }>\n): Promise<{ messageId: string; accepted: string[] }> {\n  console.log(`📤 SMTP: Connecting to ${host}:${port} as ${user}...`);\n  console.log(`📤 SMTP: Sending from ${from} to ${to}`);\n  console.log(`📤 SMTP: Subject: ${subject}`);\n  \n  // In production, this would use nodemailer\n  // For now, return mock response\n  const messageId = `<${Date.now()}.${Math.random().toString(36).substring(7)}@habits.local>`;\n  \n  return {\n    messageId,\n    accepted: [to]\n  };\n}\n\nconst emailBit = {\n  displayName: 'Email (IMAP/SMTP)',\n  description: 'Email integration for fetching (IMAP) and sending (SMTP) emails',\n  logoUrl: 'lucide:Mail',\n  \n  auth: {\n    type: 'CUSTOM',\n    displayName: 'Email Credentials',\n    description: 'IMAP and SMTP server credentials',\n    required: false,\n    props: {\n      imapHost: { type: 'SHORT_TEXT', displayName: 'IMAP Host', required: false },\n      imapPort: { type: 'NUMBER', displayName: 'IMAP Port', required: false, defaultValue: 993 },\n      imapUser: { type: 'SHORT_TEXT', displayName: 'IMAP Username', required: false },\n      imapPassword: { type: 'SECRET_TEXT', displayName: 'IMAP Password', required: false },\n      smtpHost: { type: 'SHORT_TEXT', displayName: 'SMTP Host', required: false },\n      smtpPort: { type: 'NUMBER', displayName: 'SMTP Port', required: false, defaultValue: 587 },\n      smtpUser: { type: 'SHORT_TEXT', displayName: 'SMTP Username', required: false },\n      smtpPassword: { type: 'SECRET_TEXT', displayName: 'SMTP Password', required: false },\n    }\n  },\n  \n  triggers: {\n    /**\n     * IMAP trigger - fetch new emails\n     */\n    newEmail: {\n      name: 'newEmail',\n      displayName: 'New Email (IMAP)',\n      description: 'Trigger when new emails arrive in the mailbox',\n      type: 'POLLING',\n      props: {\n        imapHost: {\n          type: 'SHORT_TEXT',\n          displayName: 'IMAP Host',\n          description: 'IMAP server hostname (e.g., imap.gmail.com)',\n          required: true,\n        },\n        imapPort: {\n          type: 'NUMBER',\n          displayName: 'IMAP Port',\n          description: 'IMAP server port (default: 993 for SSL)',\n          required: false,\n          defaultValue: 993,\n        },\n        imapUser: {\n          type: 'SHORT_TEXT',\n          displayName: 'Username',\n          description: 'Email address or username',\n          required: true,\n        },\n        imapPassword: {\n          type: 'SECRET_TEXT',\n          displayName: 'Password',\n          description: 'Email password or app-specific password',\n          required: true,\n        },\n        folder: {\n          type: 'SHORT_TEXT',\n          displayName: 'Folder',\n          description: 'Mailbox folder to monitor',\n          required: false,\n          defaultValue: 'INBOX',\n        },\n        unreadOnly: {\n          type: 'CHECKBOX',\n          displayName: 'Unread Only',\n          description: 'Only fetch unread emails',\n          required: false,\n          defaultValue: true,\n        },\n        limit: {\n          type: 'NUMBER',\n          displayName: 'Limit',\n          description: 'Maximum number of emails to fetch',\n          required: false,\n          defaultValue: 10,\n        },\n      },\n      async run(context: EmailContext) {\n        const { \n          imapHost, imapPort = 993, imapUser, imapPassword,\n          folder = 'INBOX', unreadOnly = true, limit = 10\n        } = context.propsValue;\n        \n        const host = context.auth?.imapHost || imapHost;\n        const port = context.auth?.imapPort || imapPort;\n        const user = context.auth?.imapUser || imapUser;\n        const password = context.auth?.imapPassword || imapPassword;\n        \n        if (!host || !user || !password) {\n          throw new Error('IMAP credentials are required');\n        }\n        \n        const emails = await fetchImapEmails(\n          host, Number(port), user, password,\n          String(folder), Number(limit), Boolean(unreadOnly)\n        );\n        \n        console.log(`📧 IMAP Trigger: Fetched ${emails.length} email(s)`);\n        \n        return {\n          emails,\n          count: emails.length,\n          folder,\n          timestamp: new Date().toISOString(),\n        };\n      },\n    },\n  },\n  \n  actions: {\n    /**\n     * New Email action (for workflow testing - simulates IMAP trigger as action)\n     */\n    newEmail: {\n      name: 'newEmail',\n      displayName: 'New Email (IMAP)',\n      description: 'Fetch new emails from IMAP mailbox (action version of trigger)',\n      props: {\n        imapHost: {\n          type: 'SHORT_TEXT',\n          displayName: 'IMAP Host',\n          description: 'IMAP server hostname',\n          required: false,\n        },\n        imapPort: {\n          type: 'NUMBER',\n          displayName: 'IMAP Port',\n          description: 'IMAP server port',\n          required: false,\n          defaultValue: 993,\n        },\n        imapUser: {\n          type: 'SHORT_TEXT',\n          displayName: 'Username',\n          description: 'Email address or username',\n          required: false,\n        },\n        imapPassword: {\n          type: 'SECRET_TEXT',\n          displayName: 'Password',\n          description: 'Email password',\n          required: false,\n        },\n        folder: {\n          type: 'SHORT_TEXT',\n          displayName: 'Folder',\n          description: 'Mailbox folder',\n          required: false,\n          defaultValue: 'INBOX',\n        },\n        unreadOnly: {\n          type: 'CHECKBOX',\n          displayName: 'Unread Only',\n          description: 'Only fetch unread emails',\n          required: false,\n          defaultValue: true,\n        },\n        limit: {\n          type: 'NUMBER',\n          displayName: 'Limit',\n          description: 'Maximum number of emails',\n          required: false,\n          defaultValue: 10,\n        },\n      },\n      async run(context: EmailContext) {\n        const { folder = 'INBOX' } = context.propsValue;\n        \n        // Return mock test data for workflow testing\n        const mockEmails: EmailMessage[] = [\n          {\n            id: `email_${Date.now()}`,\n            from: 'customer@example.com',\n            to: 'support@company.com',\n            subject: 'Help with my order #12345',\n            body: 'Hi, I placed an order last week and haven\\'t received any shipping confirmation. Can you help me track it? Order number is 12345. Thanks!',\n            date: new Date().toISOString(),\n          },\n          {\n            id: `email_${Date.now() + 1}`,\n            from: 'sales.inquiry@prospect.com',\n            to: 'sales@company.com',\n            subject: 'Pricing inquiry for enterprise plan',\n            body: 'We are interested in your enterprise pricing. Our company has 500+ employees. Please send us a quote.',\n            date: new Date(Date.now() - 3600000).toISOString(),\n          },\n        ];\n        \n        console.log(`📧 New Email (Mock): Returning ${mockEmails.length} test emails from ${folder}`);\n        \n        return {\n          emails: mockEmails,\n          count: mockEmails.length,\n          folder,\n          timestamp: new Date().toISOString(),\n        };\n      },\n    },\n    \n    /**\n     * Fetch emails from IMAP server\n     */\n    fetchEmails: {\n      name: 'fetchEmails',\n      displayName: 'Fetch Emails (IMAP)',\n      description: 'Fetch emails from an IMAP mailbox',\n      props: {\n        imapHost: {\n          type: 'SHORT_TEXT',\n          displayName: 'IMAP Host',\n          description: 'IMAP server hostname',\n          required: true,\n        },\n        imapPort: {\n          type: 'NUMBER',\n          displayName: 'IMAP Port',\n          description: 'IMAP server port',\n          required: false,\n          defaultValue: 993,\n        },\n        imapUser: {\n          type: 'SHORT_TEXT',\n          displayName: 'Username',\n          description: 'Email address or username',\n          required: true,\n        },\n        imapPassword: {\n          type: 'SECRET_TEXT',\n          displayName: 'Password',\n          description: 'Email password',\n          required: true,\n        },\n        folder: {\n          type: 'SHORT_TEXT',\n          displayName: 'Folder',\n          description: 'Mailbox folder to fetch from',\n          required: false,\n          defaultValue: 'INBOX',\n        },\n        unreadOnly: {\n          type: 'CHECKBOX',\n          displayName: 'Unread Only',\n          description: 'Only fetch unread emails',\n          required: false,\n          defaultValue: false,\n        },\n        limit: {\n          type: 'NUMBER',\n          displayName: 'Limit',\n          description: 'Maximum number of emails to fetch',\n          required: false,\n          defaultValue: 10,\n        },\n      },\n      async run(context: EmailContext) {\n        const { \n          imapHost, imapPort = 993, imapUser, imapPassword,\n          folder = 'INBOX', unreadOnly = false, limit = 10\n        } = context.propsValue;\n        \n        const host = context.auth?.imapHost || imapHost;\n        const port = context.auth?.imapPort || imapPort;\n        const user = context.auth?.imapUser || imapUser;\n        const password = context.auth?.imapPassword || imapPassword;\n        \n        if (!host || !user || !password) {\n          throw new Error('IMAP credentials are required');\n        }\n        \n        const emails = await fetchImapEmails(\n          host, Number(port), user, password,\n          String(folder), Number(limit), Boolean(unreadOnly)\n        );\n        \n        console.log(`📧 Fetch Emails: Retrieved ${emails.length} email(s) from ${folder}`);\n        \n        return {\n          emails,\n          count: emails.length,\n          folder,\n        };\n      },\n    },\n    \n    /**\n     * Send email via SMTP\n     */\n    sendEmail: {\n      name: 'sendEmail',\n      displayName: 'Send Email (SMTP)',\n      description: 'Send an email via SMTP',\n      props: {\n        smtpHost: {\n          type: 'SHORT_TEXT',\n          displayName: 'SMTP Host',\n          description: 'SMTP server hostname (e.g., smtp.gmail.com)',\n          required: true,\n        },\n        smtpPort: {\n          type: 'NUMBER',\n          displayName: 'SMTP Port',\n          description: 'SMTP server port (587 for TLS, 465 for SSL)',\n          required: false,\n          defaultValue: 587,\n        },\n        smtpUser: {\n          type: 'SHORT_TEXT',\n          displayName: 'Username',\n          description: 'SMTP username/email',\n          required: true,\n        },\n        smtpPassword: {\n          type: 'SECRET_TEXT',\n          displayName: 'Password',\n          description: 'SMTP password',\n          required: true,\n        },\n        from: {\n          type: 'SHORT_TEXT',\n          displayName: 'From',\n          description: 'Sender email address',\n          required: true,\n        },\n        to: {\n          type: 'SHORT_TEXT',\n          displayName: 'To',\n          description: 'Recipient email address(es), comma-separated',\n          required: true,\n        },\n        cc: {\n          type: 'SHORT_TEXT',\n          displayName: 'CC',\n          description: 'CC recipients (optional)',\n          required: false,\n        },\n        bcc: {\n          type: 'SHORT_TEXT',\n          displayName: 'BCC',\n          description: 'BCC recipients (optional)',\n          required: false,\n        },\n        subject: {\n          type: 'SHORT_TEXT',\n          displayName: 'Subject',\n          description: 'Email subject line',\n          required: true,\n        },\n        body: {\n          type: 'LONG_TEXT',\n          displayName: 'Body (Plain Text)',\n          description: 'Email body in plain text',\n          required: true,\n        },\n        html: {\n          type: 'LONG_TEXT',\n          displayName: 'Body (HTML)',\n          description: 'Email body in HTML format (optional)',\n          required: false,\n        },\n        replyTo: {\n          type: 'SHORT_TEXT',\n          displayName: 'Reply-To',\n          description: 'Reply-to address (optional)',\n          required: false,\n        },\n      },\n      async run(context: EmailContext) {\n        const { \n          smtpHost, smtpPort = 587, smtpUser, smtpPassword,\n          from, to, subject, body, html, cc, bcc, replyTo\n        } = context.propsValue;\n        \n        const host = context.auth?.smtpHost || smtpHost;\n        const port = context.auth?.smtpPort || smtpPort;\n        const user = context.auth?.smtpUser || smtpUser;\n        const password = context.auth?.smtpPassword || smtpPassword;\n        \n        if (!host || !user || !password) {\n          throw new Error('SMTP credentials are required');\n        }\n        \n        if (!from || !to || !subject || !body) {\n          throw new Error('From, To, Subject, and Body are required');\n        }\n        \n        const result = await sendSmtpEmail(\n          host, Number(port), user, password,\n          String(from), String(to), String(subject), String(body), html\n        );\n        \n        console.log(`📤 Send Email: Message sent to ${to}`);\n        \n        return {\n          success: true,\n          messageId: result.messageId,\n          accepted: result.accepted,\n          from,\n          to,\n          subject,\n          timestamp: new Date().toISOString(),\n        };\n      },\n    },\n    \n    /**\n     * Parse email content\n     */\n    parseEmail: {\n      name: 'parseEmail',\n      displayName: 'Parse Email',\n      description: 'Extract structured data from email content',\n      props: {\n        rawEmail: {\n          type: 'LONG_TEXT',\n          displayName: 'Raw Email',\n          description: 'Raw email content or JSON email object',\n          required: true,\n        },\n        extractAttachments: {\n          type: 'CHECKBOX',\n          displayName: 'Extract Attachments',\n          description: 'Include attachment information',\n          required: false,\n          defaultValue: false,\n        },\n      },\n      async run(context: EmailContext) {\n        const { rawEmail, extractAttachments } = context.propsValue;\n        \n        let email: any;\n        if (typeof rawEmail === 'string') {\n          try {\n            email = JSON.parse(rawEmail);\n          } catch {\n            // Parse as raw email text - simplified parsing\n            const lines = rawEmail.split('\\n');\n            email = {\n              subject: '',\n              from: '',\n              to: '',\n              body: rawEmail,\n            };\n            for (const line of lines) {\n              if (line.toLowerCase().startsWith('subject:')) {\n                email.subject = line.substring(8).trim();\n              } else if (line.toLowerCase().startsWith('from:')) {\n                email.from = line.substring(5).trim();\n              } else if (line.toLowerCase().startsWith('to:')) {\n                email.to = line.substring(3).trim();\n              }\n            }\n          }\n        } else {\n          email = rawEmail;\n        }\n        \n        console.log(`📧 Parse Email: Extracted from ${email.from || 'unknown'}`);\n        \n        return {\n          from: email.from || '',\n          to: email.to || '',\n          subject: email.subject || '',\n          body: email.body || email.text || '',\n          html: email.html || '',\n          date: email.date || new Date().toISOString(),\n          attachments: extractAttachments ? (email.attachments || []) : [],\n        };\n      },\n    },\n  },\n};\n\nexport const email = emailBit;\nexport default emailBit;\n"]}