erosolar-cli 1.7.54 → 1.7.56

package/dist/bin/tools/emailTools.js

@@ -1,448 +0,0 @@
-/**
- * Email Tools - SMTP email sending capabilities
- *
- * Supports Gmail, Outlook, and custom SMTP servers with app password authentication.
- * Users configure their email credentials via /secrets or environment variables.
- */
-import * as nodemailer from 'nodemailer';
-import { getSecretValue } from '../core/secretStore.js';
-// SMTP provider presets
-const SMTP_PRESETS = {
-    gmail: {
-        host: 'smtp.gmail.com',
-        port: 587,
-        secure: false, // Uses STARTTLS
-    },
-    outlook: {
-        host: 'smtp.office365.com',
-        port: 587,
-        secure: false,
-    },
-    hotmail: {
-        host: 'smtp.office365.com',
-        port: 587,
-        secure: false,
-    },
-    yahoo: {
-        host: 'smtp.mail.yahoo.com',
-        port: 587,
-        secure: false,
-    },
-    icloud: {
-        host: 'smtp.mail.me.com',
-        port: 587,
-        secure: false,
-    },
-    zoho: {
-        host: 'smtp.zoho.com',
-        port: 587,
-        secure: false,
-    },
-};
-function getEmailConfig() {
-    // Check secretStore first, then fall back to environment variables
-    const provider = (getSecretValue('SMTP_PROVIDER') || process.env['SMTP_PROVIDER'] || 'gmail').toLowerCase();
-    const user = getSecretValue('SMTP_USER') || process.env['SMTP_USER'] || process.env['EMAIL_USER'];
-    const password = getSecretValue('SMTP_PASSWORD') || process.env['SMTP_PASSWORD'] || process.env['EMAIL_APP_PASSWORD'] || process.env['SMTP_APP_PASSWORD'];
-    if (!user || !password) {
-        return null;
-    }
-    // Get preset or custom config
-    const preset = SMTP_PRESETS[provider];
-    const customHost = getSecretValue('SMTP_HOST') || process.env['SMTP_HOST'];
-    const customPort = getSecretValue('SMTP_PORT') || process.env['SMTP_PORT'];
-    const fromName = getSecretValue('SMTP_FROM_NAME') || process.env['SMTP_FROM_NAME'] || process.env['EMAIL_FROM_NAME'];
-    return {
-        provider,
-        host: customHost || preset?.host || 'smtp.gmail.com',
-        port: parseInt(customPort || String(preset?.port || 587), 10),
-        secure: process.env['SMTP_SECURE'] === 'true' || preset?.secure || false,
-        user,
-        password,
-        fromName: fromName || undefined,
-    };
-}
-async function createTransporter(config) {
-    const transporter = nodemailer.createTransport({
-        host: config.host,
-        port: config.port,
-        secure: config.secure,
-        auth: {
-            user: config.user,
-            pass: config.password,
-        },
-        tls: {
-            // Allow self-signed certificates for custom SMTP servers
-            rejectUnauthorized: process.env['SMTP_REJECT_UNAUTHORIZED'] !== 'false',
-        },
-    });
-    // Verify connection
-    await transporter.verify();
-    return transporter;
-}
-export function createEmailTools() {
-    return [
-        {
-            name: 'send_email',
-            description: `Send an email via SMTP. Supports Gmail, Outlook, Yahoo, iCloud, Zoho, and custom SMTP servers.
-
-Configuration (set via /secrets or environment variables):
-- SMTP_USER or EMAIL_USER: Your email address
-- SMTP_PASSWORD or EMAIL_APP_PASSWORD: Your app password (NOT your regular password)
-- SMTP_PROVIDER: gmail, outlook, yahoo, icloud, zoho (default: gmail)
-- SMTP_FROM_NAME: Display name for sent emails (optional)
-
-For Gmail:
-1. Enable 2-Factor Authentication
-2. Go to https://myaccount.google.com/apppasswords
-3. Generate an app password for "Mail"
-4. Use that app password as SMTP_PASSWORD
-
-For Outlook/Hotmail:
-1. Go to https://account.live.com/proofs/AppPassword
-2. Generate an app password
-3. Use that as SMTP_PASSWORD
-
-Use cases:
-- Send notifications, reports, or alerts
-- Automated outreach (investors, leads, contacts)
-- Send formatted HTML emails with attachments
-- Batch email campaigns with personalization`,
-            parameters: {
-                type: 'object',
-                properties: {
-                    to: {
-                        type: 'string',
-                        description: 'Recipient email address(es). For multiple recipients, use comma-separated values.',
-                    },
-                    subject: {
-                        type: 'string',
-                        description: 'Email subject line',
-                    },
-                    body: {
-                        type: 'string',
-                        description: 'Email body content. Can be plain text or HTML.',
-                    },
-                    html: {
-                        type: 'boolean',
-                        description: 'Set to true if body contains HTML content (default: false)',
-                    },
-                    cc: {
-                        type: 'string',
-                        description: 'CC recipient(s), comma-separated (optional)',
-                    },
-                    bcc: {
-                        type: 'string',
-                        description: 'BCC recipient(s), comma-separated (optional)',
-                    },
-                    reply_to: {
-                        type: 'string',
-                        description: 'Reply-To address (optional)',
-                    },
-                    attachments: {
-                        type: 'array',
-                        items: {
-                            type: 'object',
-                            properties: {
-                                filename: { type: 'string' },
-                                path: { type: 'string', description: 'File path to attach' },
-                                content: { type: 'string', description: 'Base64 encoded content (alternative to path)' },
-                            },
-                        },
-                        description: 'Array of attachments (optional)',
-                    },
-                },
-                required: ['to', 'subject', 'body'],
-            },
-            handler: async (args) => {
-                const config = getEmailConfig();
-                if (!config) {
-                    return `Email not configured. Please set up SMTP credentials:
-
-Required environment variables:
-- SMTP_USER or EMAIL_USER: Your email address
-- SMTP_PASSWORD or EMAIL_APP_PASSWORD: Your app password
-
-Optional:
-- SMTP_PROVIDER: gmail, outlook, yahoo, icloud, zoho (default: gmail)
-- SMTP_FROM_NAME: Display name for sent emails
-
-For Gmail, create an app password at: https://myaccount.google.com/apppasswords
-For Outlook, create an app password at: https://account.live.com/proofs/AppPassword
-
-Use /secrets to configure these values.`;
-                }
-                const to = args['to'];
-                const subject = args['subject'];
-                const body = args['body'];
-                const isHtml = args['html'] === true;
-                const cc = args['cc'];
-                const bcc = args['bcc'];
-                const replyTo = args['reply_to'];
-                const attachments = args['attachments'];
-                if (!to || !subject || !body) {
-                    return 'Error: to, subject, and body are required parameters.';
-                }
-                try {
-                    const transporter = await createTransporter(config);
-                    const fromAddress = config.fromName
-                        ? `"${config.fromName}" <${config.user}>`
-                        : config.user;
-                    const mailOptions = {
-                        from: fromAddress,
-                        to,
-                        subject,
-                        ...(isHtml ? { html: body } : { text: body }),
-                        ...(cc && { cc }),
-                        ...(bcc && { bcc }),
-                        ...(replyTo && { replyTo }),
-                        ...(attachments && {
-                            attachments: attachments.map(att => ({
-                                filename: att.filename,
-                                ...(att.path ? { path: att.path } : {}),
-                                ...(att.content ? { content: att.content, encoding: 'base64' } : {}),
-                            })),
-                        }),
-                    };
-                    const info = await transporter.sendMail(mailOptions);
-                    return `✅ Email sent successfully!
-
-To: ${to}
-Subject: ${subject}
-Message ID: ${info.messageId}
-Provider: ${config.provider}
-${cc ? `CC: ${cc}` : ''}
-${bcc ? `BCC: ${bcc}` : ''}
-${attachments?.length ? `Attachments: ${attachments.length} file(s)` : ''}
-
-Response: ${info.response || 'Accepted'}`;
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    // Provide helpful error messages
-                    if (errorMessage.includes('Invalid login') || errorMessage.includes('authentication')) {
-                        return `❌ Authentication failed.
-
-Error: ${errorMessage}
-
-Common fixes:
-1. Make sure you're using an APP PASSWORD, not your regular password
-2. For Gmail: https://myaccount.google.com/apppasswords
-3. For Outlook: https://account.live.com/proofs/AppPassword
-4. Ensure 2-Factor Authentication is enabled on your account
-5. Check that SMTP_USER matches the email account`;
-                    }
-                    if (errorMessage.includes('ENOTFOUND') || errorMessage.includes('ECONNREFUSED')) {
-                        return `❌ Could not connect to SMTP server.
-
-Error: ${errorMessage}
-
-Current config:
-- Host: ${config.host}
-- Port: ${config.port}
-- Provider: ${config.provider}
-
-Try setting SMTP_HOST and SMTP_PORT manually if using a custom server.`;
-                    }
-                    return `❌ Failed to send email: ${errorMessage}`;
-                }
-            },
-        },
-        {
-            name: 'verify_email_config',
-            description: 'Verify that email/SMTP configuration is correct and can connect to the mail server.',
-            parameters: {
-                type: 'object',
-                properties: {},
-            },
-            handler: async () => {
-                const config = getEmailConfig();
-                if (!config) {
-                    return `❌ Email not configured.
-
-Required environment variables:
-- SMTP_USER or EMAIL_USER
-- SMTP_PASSWORD or EMAIL_APP_PASSWORD
-
-Optional:
-- SMTP_PROVIDER: gmail, outlook, yahoo, icloud, zoho
-- SMTP_HOST, SMTP_PORT: For custom SMTP servers
-- SMTP_FROM_NAME: Display name
-
-Use /secrets to configure these values.`;
-                }
-                try {
-                    await createTransporter(config);
-                    return `✅ Email configuration verified!
-
-Provider: ${config.provider}
-Host: ${config.host}
-Port: ${config.port}
-User: ${config.user}
-Secure: ${config.secure ? 'Yes (SSL/TLS)' : 'No (STARTTLS)'}
-From Name: ${config.fromName || '(not set)'}
-
-SMTP connection successful. You can now use send_email to send emails.`;
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    return `❌ Email configuration verification failed.
-
-Provider: ${config.provider}
-Host: ${config.host}
-Port: ${config.port}
-User: ${config.user}
-
-Error: ${errorMessage}
-
-Common issues:
-1. Wrong app password (must use app password, not regular password)
-2. 2FA not enabled on email account
-3. Wrong SMTP provider selected
-4. Network/firewall blocking SMTP ports`;
-                }
-            },
-        },
-        {
-            name: 'send_batch_emails',
-            description: `Send personalized emails to multiple recipients in batch.
-
-Useful for:
-- Investor outreach campaigns
-- Lead nurturing sequences
-- Newsletter distribution
-- Bulk notifications with personalization
-
-Supports template variables: {{name}}, {{company}}, {{custom_field}}`,
-            parameters: {
-                type: 'object',
-                properties: {
-                    recipients: {
-                        type: 'array',
-                        items: {
-                            type: 'object',
-                            properties: {
-                                email: { type: 'string', description: 'Recipient email' },
-                                name: { type: 'string', description: 'Recipient name for personalization' },
-                                company: { type: 'string', description: 'Company name (optional)' },
-                                custom: {
-                                    type: 'object',
-                                    description: 'Custom fields for template substitution',
-                                },
-                            },
-                            required: ['email'],
-                        },
-                        description: 'Array of recipients with personalization data',
-                    },
-                    subject_template: {
-                        type: 'string',
-                        description: 'Subject line template with {{variables}}',
-                    },
-                    body_template: {
-                        type: 'string',
-                        description: 'Email body template with {{variables}}',
-                    },
-                    html: {
-                        type: 'boolean',
-                        description: 'Set to true if body contains HTML (default: false)',
-                    },
-                    delay_ms: {
-                        type: 'number',
-                        description: 'Delay between emails in milliseconds (default: 1000). Helps avoid rate limits.',
-                    },
-                },
-                required: ['recipients', 'subject_template', 'body_template'],
-            },
-            handler: async (args) => {
-                const config = getEmailConfig();
-                if (!config) {
-                    return 'Email not configured. Use /secrets to set SMTP_USER and SMTP_PASSWORD.';
-                }
-                const recipients = args['recipients'];
-                const subjectTemplate = args['subject_template'];
-                const bodyTemplate = args['body_template'];
-                const isHtml = args['html'] === true;
-                const delayMs = args['delay_ms'] || 1000;
-                if (!recipients?.length || !subjectTemplate || !bodyTemplate) {
-                    return 'Error: recipients, subject_template, and body_template are required.';
-                }
-                try {
-                    const transporter = await createTransporter(config);
-                    const fromAddress = config.fromName
-                        ? `"${config.fromName}" <${config.user}>`
-                        : config.user;
-                    const results = [];
-                    for (let i = 0; i < recipients.length; i++) {
-                        const recipient = recipients[i];
-                        if (!recipient)
-                            continue;
-                        // Apply template substitution
-                        const personalizedSubject = applyTemplate(subjectTemplate, recipient);
-                        const personalizedBody = applyTemplate(bodyTemplate, recipient);
-                        try {
-                            await transporter.sendMail({
-                                from: fromAddress,
-                                to: recipient.email,
-                                subject: personalizedSubject,
-                                ...(isHtml ? { html: personalizedBody } : { text: personalizedBody }),
-                            });
-                            results.push({ email: recipient.email, success: true });
-                        }
-                        catch (error) {
-                            results.push({
-                                email: recipient.email,
-                                success: false,
-                                error: error instanceof Error ? error.message : String(error),
-                            });
-                        }
-                        // Delay between emails (except for last one)
-                        if (i < recipients.length - 1 && delayMs > 0) {
-                            await new Promise(resolve => setTimeout(resolve, delayMs));
-                        }
-                    }
-                    const successful = results.filter(r => r.success).length;
-                    const failed = results.filter(r => !r.success);
-                    let summary = `📧 Batch Email Results
-
-Total: ${recipients.length}
-Sent: ${successful}
-Failed: ${failed.length}
-Provider: ${config.provider}
-`;
-                    if (failed.length > 0) {
-                        summary += '\n❌ Failed emails:\n';
-                        for (const f of failed) {
-                            summary += `- ${f.email}: ${f.error}\n`;
-                        }
-                    }
-                    return summary;
-                }
-                catch (error) {
-                    return `❌ Batch email failed: ${error instanceof Error ? error.message : String(error)}`;
-                }
-            },
-        },
-    ];
-}
-function applyTemplate(template, data) {
-    let result = template;
-    // Standard fields
-    result = result.replace(/\{\{email\}\}/gi, data.email);
-    result = result.replace(/\{\{name\}\}/gi, data.name || '');
-    result = result.replace(/\{\{company\}\}/gi, data.company || '');
-    // First name extraction
-    const firstName = data.name?.split(' ')[0] || '';
-    result = result.replace(/\{\{first_name\}\}/gi, firstName);
-    result = result.replace(/\{\{firstName\}\}/gi, firstName);
-    // Custom fields
-    if (data.custom) {
-        for (const [key, value] of Object.entries(data.custom)) {
-            const regex = new RegExp(`\\{\\{${key}\\}\\}`, 'gi');
-            result = result.replace(regex, value);
-        }
-    }
-    // Clean up any remaining unmatched placeholders
-    result = result.replace(/\{\{[^}]+\}\}/g, '');
-    return result;
-}
-export { getEmailConfig };