fraim-framework 2.0.26 → 2.0.30

package/dist/registry/scripts/newsletter-helpers.js

@@ -0,0 +1,731 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Newsletter Helper Functions
+ *
+ * DETERMINISTIC functions for AI agents to use when creating newsletters.
+ * AI agents do the CREATIVE work (categorization, content writing).
+ * These functions provide TOOLS (data fetching, email sending).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLatestNewsletterDate = getLatestNewsletterDate;
+exports.getResolvedIssuesForNewsletter = getResolvedIssuesForNewsletter;
+exports.getAllActiveExecutives = getAllActiveExecutives;
+exports.getPotentialCustomers = getPotentialCustomers;
+exports.generateNewsletterHTML = generateNewsletterHTML;
+exports.saveNewsletter = saveNewsletter;
+exports.sendNewsletterToExecutives = sendNewsletterToExecutives;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const mongodb_1 = require("mongodb");
+const path_1 = require("path");
+const git_utils_1 = require("../../src/utils/git-utils");
+const fraim_config_1 = require("./fraim-config");
+// Reuse existing email infrastructure
+const generate_engagement_emails_1 = require("./generate-engagement-emails");
+/**
+ * Get the latest date from existing newsletter files
+ * Returns the most recent date when newsletter was sent, or null if no files exist
+ */
+function getLatestNewsletterDate() {
+    const newslettersDir = 'docs/customer-development/newsletters';
+    if (!(0, fs_1.existsSync)(newslettersDir)) {
+        return null;
+    }
+    const files = (0, fs_1.readdirSync)(newslettersDir).filter(f => f.startsWith('newsletter-') && f.endsWith('.json'));
+    if (files.length === 0) {
+        return null;
+    }
+    // Extract dates from filenames (e.g., newsletter-2025-11-01.json)
+    const dates = [];
+    for (const file of files) {
+        const dateMatch = file.match(/newsletter-(\d{4}-\d{2}-\d{2})\.json/);
+        if (dateMatch) {
+            const filePath = (0, path_1.join)(newslettersDir, file);
+            // Verify content is valid if needed, but for date extraction filename is enough
+            dates.push(dateMatch[1]);
+        }
+    }
+    if (dates.length === 0) {
+        return null;
+    }
+    // Return the most recent date
+    dates.sort();
+    const latestDate = dates[dates.length - 1];
+    console.log(`📅 Latest newsletter date found: ${latestDate}`);
+    return latestDate;
+}
+/**
+ * Get resolved issues for newsletter
+ * DETERMINISTIC: Just fetches issues, doesn't categorize or filter
+ * AI agent decides what to include and how to present it
+ *
+ * @param date Optional date string (YYYY-MM-DD). If not provided, uses latest newsletter date or last 7 days
+ */
+async function getResolvedIssuesForNewsletter(date) {
+    if (!date) {
+        // Try to get the latest newsletter date
+        const latestNewsletterDate = getLatestNewsletterDate();
+        if (latestNewsletterDate) {
+            date = latestNewsletterDate;
+            console.log(`📋 Using latest newsletter date as starting point: ${date}`);
+        }
+        else {
+            // Fallback to last 7 days if no previous newsletters exist
+            const fallbackDate = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+            date = fallbackDate;
+            console.log(`📋 No previous newsletters found, using last 7 days: ${date}`);
+        }
+    }
+    console.log(`📋 Fetching issues resolved since ${date}...`);
+    // Get all closed issues from the specified date (not just user-reported)
+    const command = `gh search issues --repo=${fraim_config_1.fraimConfig.repoOwner}/${fraim_config_1.fraimConfig.repoName} --state=closed --closed=">${date}" --json number,title,body,labels,closedAt,author --limit 100`;
+    const output = (0, child_process_1.execSync)(command, { encoding: 'utf-8' });
+    const issues = JSON.parse(output);
+    console.log(`✅ Found ${issues.length} resolved issues`);
+    return issues;
+}
+/**
+ * Get database name, defaulting to production
+ */
+function getDatabaseName() {
+    const env = process.env.NODE_ENV || process.env.ENVIRONMENT;
+    // If explicitly set to ppe/staging, use that; otherwise default to prod
+    if (env === 'ppe' || env === 'staging') {
+        return (0, git_utils_1.determineDatabaseName)();
+    }
+    // Default to production
+    return process.env.MONGO_DB_NAME || 'fraim_prod';
+}
+/**
+ * Get collection name with schema prefix (defaults to prod schema)
+ */
+function getCollectionName(baseName) {
+    const env = process.env.NODE_ENV || process.env.ENVIRONMENT;
+    // If explicitly set to ppe/staging, use that schema; otherwise default to prod
+    if (env === 'ppe' || env === 'staging') {
+        const schema = (0, git_utils_1.determineSchema)((0, git_utils_1.getCurrentGitBranch)());
+        return `${schema}_${baseName}`;
+    }
+    // Default to prod schema
+    return `prod_${baseName}`;
+}
+/**
+ * Get all active executives (defaults to production database)
+ * DETERMINISTIC: Just fetches executive list
+ */
+async function getAllActiveExecutives() {
+    const mongoUrl = process.env.PROD_MONGO_DATABASE_URL || process.env.MONGO_DATABASE_URL;
+    if (!mongoUrl) {
+        throw new Error('PROD_MONGO_DATABASE_URL or MONGO_DATABASE_URL environment variable is required');
+    }
+    const client = new mongodb_1.MongoClient(mongoUrl);
+    try {
+        await client.connect();
+        const dbName = getDatabaseName();
+        const collectionName = getCollectionName('Executive');
+        console.log(`[getAllActiveExecutives] Querying database: ${dbName}, collection: ${collectionName}`);
+        const db = client.db(dbName);
+        const executives = await db.collection(collectionName)
+            .find({})
+            .toArray();
+        console.log(`[getAllActiveExecutives] Found ${executives.length} executives in ${dbName}.${collectionName}`);
+        // If no executives found in prod, check PPE as fallback
+        if (executives.length === 0 && dbName === 'fraim_prod') {
+            console.log(`[getAllActiveExecutives] No executives in prod, checking PPE as fallback...`);
+            const ppeDb = client.db('fraim_ppe');
+            const ppeExecutives = await ppeDb.collection('ppe_Executive')
+                .find({})
+                .toArray();
+            console.log(`[getAllActiveExecutives] Found ${ppeExecutives.length} executives in fraim_ppe.ppe_Executive`);
+            return ppeExecutives;
+        }
+        return executives;
+    }
+    finally {
+        await client.close();
+    }
+}
+/**
+ * Get all potential customers (leads who have expressed interest)
+ * DETERMINISTIC: Just fetches potential customer list from JSON file
+ */
+function getPotentialCustomers() {
+    const potentialCustomersPath = (0, path_1.join)(process.cwd(), 'docs', 'customer-development', 'potential-customers.json');
+    if (!(0, fs_1.existsSync)(potentialCustomersPath)) {
+        return [];
+    }
+    try {
+        const content = (0, fs_1.readFileSync)(potentialCustomersPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        console.error('❌ Error reading potential customers file:', error);
+        return [];
+    }
+}
+/**
+ * Get default Persona email from database (defaults to production)
+ * Extracts the base email (part before the +) from existing executive Persona emails
+ * DETERMINISTIC: Reads from database, extracts pattern
+ */
+async function getDefaultPersonaEmailFromDatabase() {
+    const mongoUrl = process.env.PROD_MONGO_DATABASE_URL || process.env.MONGO_DATABASE_URL;
+    if (!mongoUrl) {
+        return null;
+    }
+    const client = new mongodb_1.MongoClient(mongoUrl);
+    try {
+        await client.connect();
+        const dbName = getDatabaseName();
+        const db = client.db(dbName);
+        const collectionName = getCollectionName(fraim_config_1.fraimConfig.identityCollection);
+        // Get any active Persona identity from the database (defaults to prod)
+        let identity = await db.collection(collectionName)
+            .findOne({ status: 'active' });
+        // Try any identity if no active one found or no email
+        if (!identity || !identity.email) {
+            identity = await db.collection(collectionName)
+                .findOne({ email: { $exists: true } });
+        }
+        if (!identity || !identity.email) {
+            return null;
+        }
+        const email = identity.email;
+        // Extract base email: if email is "persona+username@domain.com", extract "persona@domain.com"
+        if (email.includes('+')) {
+            const [localPart, rest] = email.split('+');
+            const domain = rest.split('@')[1];
+            return `${localPart}@${domain}`;
+        }
+        // If no plus sign, return as-is (it's already the base email)
+        return email;
+    }
+    catch (error) {
+        console.warn(`⚠️  Could not get default ${fraim_config_1.fraimConfig.personaName} email from database:`, error);
+        return null;
+    }
+    finally {
+        await client.close();
+    }
+}
+/**
+ * Generate HTML from newsletter JSON
+ * DETERMINISTIC: Just applies template, no creative decisions
+ */
+function generateNewsletterHTML(newsletter) {
+    const templatePath = (0, path_1.join)(process.cwd(), 'registry', 'templates', 'customer-development', 'weekly-newsletter-template.html');
+    let html = (0, fs_1.readFileSync)(templatePath, 'utf-8');
+    const { content } = newsletter;
+    // Replace simple variables
+    html = html.replace(/\{\{weekTitle\}\}/g, escapeHtml(content.weekTitle));
+    html = html.replace(/\{\{weekSubtitle\}\}/g, escapeHtml(content.weekSubtitle));
+    html = html.replace(/\{\{weekDate\}\}/g, escapeHtml(content.weekDate));
+    html = html.replace(/\{\{personaName\}\}/g, escapeHtml(fraim_config_1.fraimConfig.personaName));
+    html = html.replace(/\{\{chatUrl\}\}/g, escapeHtml(fraim_config_1.fraimConfig.chatUrl || '#'));
+    html = html.replace(/\{\{webAppUrl\}\}/g, escapeHtml(fraim_config_1.fraimConfig.webAppUrl || '#'));
+    html = html.replace(/\{\{openingMessage\}\}/g, escapeHtml(content.openingMessage));
+    html = html.replace(/\{\{ctaLink\}\}/g, content.ctaLink || (fraim_config_1.fraimConfig.webAppUrl ? `${fraim_config_1.fraimConfig.webAppUrl}/wellness/${fraim_config_1.fraimConfig.personaName.toLowerCase()}` : '#'));
+    html = html.replace(/\{\{ctaText\}\}/g, escapeHtml(content.ctaText || `Get ${fraim_config_1.fraimConfig.personaName} Now`));
+    html = html.replace(/\{\{unsubscribeLink\}\}/g, '#');
+    // Custom header text - check if this is the first newsletter
+    if (content.weekDate && (content.weekDate.toLowerCase().includes('month of november') || content.weekDate.toLowerCase().includes('month of october'))) {
+        html = html.replace(/🚀 Weekly Update/g, `🎉 ${fraim_config_1.fraimConfig.personaName}'s First Update`);
+        html = html.replace(/📅 Week of/g, "📅");
+        html = html.replace(/Coming Next Week/g, "Coming Next Month");
+    }
+    // Stats
+    html = html.replace(/\{\{statsFeatures\}\}/g, (newsletter.metadata.featuresCount || 0).toString());
+    html = html.replace(/\{\{statsImprovements\}\}/g, (newsletter.metadata.improvementsCount || 0).toString());
+    html = html.replace(/\{\{statsBugFixes\}\}/g, (newsletter.metadata.bugFixesCount || 0).toString());
+    // Hero feature(s) - support both single heroFeature and array of heroFeatures
+    const heroFeatures = content.heroFeatures || (content.heroFeature ? [content.heroFeature] : []);
+    if (heroFeatures.length > 0) {
+        // Generate HTML for all hero features, wrapped in proper table structure
+        const heroFeaturesHTML = heroFeatures.map((hero, index) => {
+            const badge = heroFeatures.length > 1 ? `HERO FEATURE ${index + 1}` : 'HERO FEATURE';
+            const marginBottom = index < heroFeatures.length - 1 ? '40px' : '0';
+            return `
+                    <tr>
+                        <td style="padding: 0 40px ${marginBottom} 40px;">
+                            <div style="background: linear-gradient(135deg, #667eea15 0%, #764ba215 100%); border: 2px solid #667eea; border-radius: 12px; padding: 35px; position: relative; overflow: hidden;">
+                                <div style="position: absolute; top: -10px; right: -10px; background: #ff6b6b; color: white; padding: 8px 20px; border-radius: 20px; font-size: 12px; font-weight: 700; letter-spacing: 1px; transform: rotate(12deg); box-shadow: 0 4px 12px rgba(255, 107, 107, 0.4);">
+                                    ⭐ ${badge}
+                                </div>
+                                <div style="font-size: 14px; color: #667eea; font-weight: 700; text-transform: uppercase; letter-spacing: 1.5px; margin-bottom: 12px;">🎯 ${heroFeatures.length > 1 ? `Feature ${index + 1} of the Week` : 'Feature of the Week'}</div>
+                                <div style="font-size: 28px; font-weight: 800; color: #212529; margin-bottom: 16px; line-height: 1.3;">${escapeHtml(hero.title)}</div>
+                                <div style="font-size: 16px; color: #495057; line-height: 1.8; margin-bottom: ${hero.impact ? '20px' : '0'};">${escapeHtml(hero.description)}</div>
+                                ${hero.impact ? `
+                                <div style="background: white; border-left: 4px solid #28a745; padding: 16px 20px; border-radius: 8px; margin-top: 20px;">
+                                    <div style="font-size: 14px; font-weight: 700; color: #28a745; margin-bottom: 8px;">💚 Real Impact:</div>
+                                    <div style="font-size: 15px; color: #495057; line-height: 1.7;">${escapeHtml(hero.impact)}</div>
+                                </div>
+                                ` : ''}
+                            </div>
+                        </td>
+                    </tr>
+      `;
+        }).join('');
+        html = html.replace(/\{\{heroFeatureTitle\}\}/g, escapeHtml(heroFeatures[0].title));
+        html = html.replace(/\{\{heroFeatureDescription\}\}/g, escapeHtml(heroFeatures[0].description));
+        html = html.replace(/\{\{heroFeatureImpact\}\}/g, escapeHtml(heroFeatures[0].impact || ''));
+        html = html.replace(/\{\{#if hasHeroFeature\}\}([\s\S]*?)\{\{\/if\}\}/, heroFeaturesHTML);
+        html = html.replace(/\{\{#if heroFeatureImpact\}\}([\s\S]*?)\{\{\/if\}\}/, heroFeatures[0].impact ? '$1' : '');
+    }
+    else {
+        html = html.replace(/\{\{#if hasHeroFeature\}\}[\s\S]*?\{\{\/if\}\}/, '');
+    }
+    // New features list
+    if (content.newFeatures && content.newFeatures.length > 0) {
+        const featuresHTML = content.newFeatures.map((feature, index) => `
+      <div style="margin-bottom: ${index < content.newFeatures.length - 1 ? '24px' : '0'}; padding: 24px; background: white; border-radius: 10px; border: 2px solid #e9ecef; box-shadow: 0 2px 8px rgba(0,0,0,0.04);">
+        <div style="font-size: 19px; font-weight: 700; color: #212529; margin-bottom: 10px;">✨ ${escapeHtml(feature.title)}</div>
+        <div style="font-size: 15px; color: #495057; line-height: 1.7;">${escapeHtml(feature.description)}</div>
+        ${feature.impact ? `<div style="margin-top: 12px; padding-top: 12px; border-top: 1px solid #e9ecef; font-size: 14px; color: #667eea; font-weight: 600;">💡 ${escapeHtml(feature.impact)}</div>` : ''}
+      </div>
+    `).join('');
+        html = html.replace(/\{\{newFeaturesList\}\}/g, featuresHTML);
+        html = html.replace(/\{\{#if hasNewFeatures\}\}([\s\S]*?)\{\{\/if\}\}/, '$1');
+    }
+    else {
+        html = html.replace(/\{\{#if hasNewFeatures\}\}[\s\S]*?\{\{\/if\}\}/, '');
+    }
+    // Improvements list
+    if (content.improvements && content.improvements.length > 0) {
+        const improvementsHTML = content.improvements.map((improvement, index) => `
+      <div style="margin-bottom: ${index < content.improvements.length - 1 ? '20px' : '0'}; padding: 20px; background: #f8f9fa; border-radius: 8px; border-left: 4px solid #28a745;">
+        <div style="font-size: 17px; font-weight: 700; color: #212529; margin-bottom: 8px;">🚀 ${escapeHtml(improvement.title)}</div>
+        <div style="font-size: 15px; color: #495057; line-height: 1.7;">${escapeHtml(improvement.description)}</div>
+      </div>
+    `).join('');
+        html = html.replace(/\{\{improvementsList\}\}/g, improvementsHTML);
+        html = html.replace(/\{\{#if hasImprovements\}\}([\s\S]*?)\{\{\/if\}\}/, '$1');
+    }
+    else {
+        html = html.replace(/\{\{#if hasImprovements\}\}[\s\S]*?\{\{\/if\}\}/, '');
+    }
+    // Bug fixes list
+    if (content.bugFixes && content.bugFixes.length > 0) {
+        const bugFixesHTML = content.bugFixes.map((fix, index) => `
+      <div style="margin-bottom: ${index < content.bugFixes.length - 1 ? '16px' : '0'}; padding: 16px; background: #fff8f0; border-radius: 8px; border-left: 4px solid #fd7e14;">
+        <div style="font-size: 16px; font-weight: 600; color: #212529; margin-bottom: 6px;">🔧 ${escapeHtml(fix.title)}</div>
+        <div style="font-size: 14px; color: #495057; line-height: 1.6;">${escapeHtml(fix.description)}</div>
+      </div>
+    `).join('');
+        html = html.replace(/\{\{bugFixesList\}\}/g, bugFixesHTML);
+        html = html.replace(/\{\{#if hasBugFixes\}\}([\s\S]*?)\{\{\/if\}\}/, '$1');
+    }
+    else {
+        html = html.replace(/\{\{#if hasBugFixes\}\}[\s\S]*?\{\{\/if\}\}/, '');
+    }
+    // Testimonial
+    if (content.testimonial) {
+        html = html.replace(/\{\{testimonialText\}\}/g, escapeHtml(content.testimonial.text));
+        html = html.replace(/\{\{testimonialAuthor\}\}/g, escapeHtml(content.testimonial.author));
+        html = html.replace(/\{\{testimonialRole\}\}/g, escapeHtml(content.testimonial.role));
+        html = html.replace(/\{\{#if hasTestimonial\}\}([\s\S]*?)\{\{\/if\}\}/, '$1');
+    }
+    else {
+        html = html.replace(/\{\{#if hasTestimonial\}\}[\s\S]*?\{\{\/if\}\}/, '');
+    }
+    // Coming next
+    if (content.comingNext) {
+        html = html.replace(/\{\{comingNextText\}\}/g, escapeHtml(content.comingNext));
+        html = html.replace(/\{\{#if hasComingNext\}\}([\s\S]*?)\{\{\/if\}\}/, '$1');
+    }
+    else {
+        html = html.replace(/\{\{#if hasComingNext\}\}[\s\S]*?\{\{\/if\}\}/, '');
+    }
+    // Conditional sections
+    html = html.replace(/\{\{#if showStats\}\}([\s\S]*?)\{\{\/if\}\}/, '$1');
+    html = html.replace(/\{\{#if showFOMO\}\}([\s\S]*?)\{\{\/if\}\}/, '$1');
+    return html;
+}
+/**
+ * Escape HTML special characters
+ */
+function escapeHtml(text) {
+    if (!text)
+        return '';
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}
+/**
+ * Save newsletter JSON and HTML
+ * DETERMINISTIC: Just writes files
+ */
+function saveNewsletter(newsletter, outputDir) {
+    const dir = outputDir || (0, path_1.join)(process.cwd(), 'docs', 'customer-development', 'newsletters');
+    if (!(0, fs_1.existsSync)(dir)) {
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    }
+    const dateStr = newsletter.metadata.weekEnd;
+    const jsonPath = (0, path_1.join)(dir, `newsletter-${dateStr}.json`);
+    const htmlPath = (0, path_1.join)(dir, `newsletter-${dateStr}.html`);
+    // Generate HTML
+    const html = generateNewsletterHTML(newsletter);
+    // Save JSON
+    (0, fs_1.writeFileSync)(jsonPath, JSON.stringify(newsletter, null, 2));
+    console.log(`✅ Saved newsletter JSON to: ${jsonPath}`);
+    // Save HTML
+    (0, fs_1.writeFileSync)(htmlPath, html);
+    console.log(`✅ Saved newsletter HTML to: ${htmlPath}`);
+    return jsonPath;
+}
+/**
+ * Send newsletter to all executives and potential customers
+ * DETERMINISTIC: Just sends emails, no decisions
+ *
+ * AI agents call this AFTER user approves the newsletter JSON
+ * @param newsletterPath Path to newsletter JSON file
+ * @param filterEmails Optional array of email addresses to send to (for testing)
+ * @param filterExecIds Optional array of executive IDs to send to (for testing)
+ * @param includePotentialCustomers Whether to include potential customers in the send (default: true)
+ * @param showOnly If true, only show recipient list without sending
+ */
+async function sendNewsletterToExecutives(newsletterPath, filterEmails, filterExecIds, includePotentialCustomers = true, showOnly = false, includeExecutives = true) {
+    console.log(`📧 Sending newsletter from: ${newsletterPath}`);
+    if (!(0, fs_1.existsSync)(newsletterPath)) {
+        throw new Error(`Newsletter file not found: ${newsletterPath}`);
+    }
+    const newsletter = JSON.parse((0, fs_1.readFileSync)(newsletterPath, 'utf-8'));
+    const htmlPath = newsletterPath.replace('.json', '.html');
+    if (!(0, fs_1.existsSync)(htmlPath)) {
+        throw new Error(`Newsletter HTML not found: ${htmlPath}. Generate it first.`);
+    }
+    const html = (0, fs_1.readFileSync)(htmlPath, 'utf-8');
+    let executives = [];
+    // Get executives only if includeExecutives is true
+    if (includeExecutives) {
+        executives = await getAllActiveExecutives();
+        // Filter executives if filters are provided
+        if (filterEmails && filterEmails.length > 0) {
+            console.log(`🔍 Filtering to ${filterEmails.length} email(s): ${filterEmails.join(', ')}`);
+            executives = executives.filter(exec => filterEmails.includes(exec.email));
+        }
+        if (filterExecIds && filterExecIds.length > 0) {
+            console.log(`🔍 Filtering to ${filterExecIds.length} executive ID(s): ${filterExecIds.join(', ')}`);
+            executives = executives.filter(exec => exec.id && filterExecIds.includes(exec.id));
+        }
+    }
+    // Get potential customers if requested
+    let potentialCustomers = [];
+    if (includePotentialCustomers) {
+        potentialCustomers = getPotentialCustomers();
+        // Filter potential customers if filterEmails is provided
+        if (filterEmails && filterEmails.length > 0) {
+            potentialCustomers = potentialCustomers.filter(customer => filterEmails.includes(customer.email));
+        }
+    }
+    if (includeExecutives) {
+        console.log(`📊 Found ${executives.length} executive(s) to send to`);
+    }
+    if (includePotentialCustomers) {
+        console.log(`📊 Found ${potentialCustomers.length} potential customer(s) to send to`);
+    }
+    if (showOnly) {
+        console.log(`\n📋 Recipient List (--showonly mode - no emails will be sent):\n`);
+        if (includeExecutives && executives.length > 0) {
+            console.log(`\n👥 ACTIVE EXECUTIVES (${executives.length}):\n`);
+            for (const exec of executives) {
+                const fromEmail = exec.id
+                    ? await (0, generate_engagement_emails_1.getPersonaEmailForExecutive)(exec.id)
+                    : fraim_config_1.fraimConfig.defaultEmail;
+                const fromDisplayName = `${fraim_config_1.fraimConfig.personaName} - ${exec.name}'s AI Executive Assistant`;
+                console.log(`   ${exec.name || 'Unknown Name'}`);
+                console.log(`   To: ${exec.email || 'No email'}`);
+                console.log(`   From Email: ${fromEmail}`);
+                console.log(`   From Display Name: ${fromDisplayName}`);
+                console.log(`   Executive ID: ${exec.id || 'No ID'}`);
+                console.log('');
+            }
+        }
+        if (potentialCustomers.length > 0) {
+            const defaultEmail = fraim_config_1.fraimConfig.prodDefaultEmail || 'agent@example.com';
+            const defaultDisplayName = `${fraim_config_1.fraimConfig.personaName} - Your AI Executive Assistant`;
+            console.log(`\n🎯 POTENTIAL CUSTOMERS (${potentialCustomers.length}):\n`);
+            potentialCustomers.forEach((customer, index) => {
+                console.log(`   ${customer.name || 'Unknown Name'}`);
+                console.log(`   To: ${customer.email || 'No email'}`);
+                console.log(`   From Email: ${defaultEmail}`);
+                console.log(`   From Display Name: ${defaultDisplayName}`);
+                console.log(`   Source: ${customer.source || 'Unknown'}`);
+                console.log('');
+            });
+        }
+        const totalRecipients = (includeExecutives ? executives.length : 0) + (includePotentialCustomers ? potentialCustomers.length : 0);
+        console.log(`✅ Total: ${totalRecipients} recipient(s) would receive the newsletter`);
+        return;
+    }
+    console.log(`\n📧 Sending newsletter...\n`);
+    // Send to active executives (from their personal Persona email) - only if includeExecutives is true
+    if (includeExecutives) {
+        for (const executive of executives) {
+            try {
+                console.log(`📧 Sending to executive ${executive.name} (${executive.email})...`);
+                const fromEmail = executive.id
+                    ? await (0, generate_engagement_emails_1.getPersonaEmailForExecutive)(executive.id)
+                    : fraim_config_1.fraimConfig.defaultEmail;
+                const fromDisplayName = `${fraim_config_1.fraimConfig.personaName} - ${executive.name}'s AI Executive Assistant`;
+                // Remove emojis from subject line for ASCII compatibility
+                const subject = newsletter.content.weekTitle.replace(/[^\x00-\x7F]/g, '').trim();
+                const plainText = generatePlainText(newsletter);
+                // Get tokens and send (reuses existing infrastructure)
+                const personaTokens = await getPersonaTokens(executive.id);
+                const executiveData = await (0, generate_engagement_emails_1.findExecutiveByEmail)(executive.email);
+                await sendEmailViaGmail({
+                    to: executive.email,
+                    subject,
+                    plainTextBody: plainText,
+                    htmlBody: html,
+                    fromEmail,
+                    fromDisplayName
+                }, executiveData, personaTokens);
+                console.log(`✅ Sent to ${executive.email}`);
+            }
+            catch (error) {
+                console.error(`❌ Failed to send to ${executive.email}:`, error);
+            }
+        }
+    }
+    // Send to potential customers (from PROD_FRAIM_DEFAULT_EMAIL)
+    const defaultEmail = fraim_config_1.fraimConfig.prodDefaultEmail || 'agent@example.com';
+    const defaultDisplayName = `${fraim_config_1.fraimConfig.personaName} - Your AI Executive Assistant`;
+    const defaultAccessToken = fraim_config_1.fraimConfig.prodAccessToken || '';
+    const defaultRefreshToken = fraim_config_1.fraimConfig.prodRefreshToken || '';
+    if (!defaultAccessToken || !defaultRefreshToken) {
+        console.warn('⚠️  PROD_FRAIM_DEFAULT_ACCESS_TOKEN or PROD_FRAIM_DEFAULT_REFRESH_TOKEN not set. Skipping potential customers.');
+    }
+    else {
+        for (const customer of potentialCustomers) {
+            try {
+                console.log(`📧 Sending to potential customer ${customer.name} (${customer.email})...`);
+                // Remove emojis from subject line for ASCII compatibility
+                const subject = newsletter.content.weekTitle.replace(/[^\x00-\x7F]/g, '').trim();
+                const plainText = generatePlainText(newsletter);
+                // Send from default Persona email with default tokens
+                await sendEmailViaGmail({
+                    to: customer.email,
+                    subject,
+                    plainTextBody: plainText,
+                    htmlBody: html,
+                    fromEmail: defaultEmail,
+                    fromDisplayName: defaultDisplayName
+                }, undefined, { access_token: defaultAccessToken, refresh_token: defaultRefreshToken });
+                console.log(`✅ Sent to ${customer.email}`);
+            }
+            catch (error) {
+                console.error(`❌ Failed to send to ${customer.email}:`, error);
+            }
+        }
+    }
+    console.log(`\n✅ Newsletter sending complete!`);
+    if (includeExecutives) {
+        console.log(`   Sent to ${executives.length} executive(s)`);
+    }
+    if (includePotentialCustomers) {
+        console.log(`   Sent to ${potentialCustomers.length} potential customer(s)`);
+    }
+    process.exit(0);
+}
+/**
+ * Get Persona tokens for executive
+ */
+async function getPersonaTokens(executiveId) {
+    if (!executiveId)
+        return null;
+    const mongoUrl = process.env.PROD_MONGO_DATABASE_URL || process.env.MONGO_DATABASE_URL;
+    if (!mongoUrl)
+        return null;
+    const client = new mongodb_1.MongoClient(mongoUrl);
+    try {
+        await client.connect();
+        const dbName = getDatabaseName();
+        const db = client.db(dbName);
+        const collectionName = getCollectionName(fraim_config_1.fraimConfig.identityCollection);
+        // Check for identity by executive ID
+        const identity = await db.collection(collectionName).findOne({
+            executive_id: executiveId,
+            status: 'active'
+        }) || await db.collection(collectionName).findOne({
+            executive_id: executiveId
+        });
+        if (identity && identity.access_token && identity.refresh_token) {
+            return {
+                access_token: identity.access_token,
+                refresh_token: identity.refresh_token
+            };
+        }
+        return null;
+    }
+    finally {
+        await client.close();
+    }
+}
+/**
+ * Generate plain text version
+ */
+function generatePlainText(newsletter) {
+    const { content } = newsletter;
+    let text = `${content.weekTitle}\n`;
+    text += `${content.weekSubtitle}\n`;
+    text += `Week of ${content.weekDate}\n\n`;
+    text += `${content.openingMessage}\n\n`;
+    // Hero feature(s) - support both single heroFeature and array of heroFeatures
+    const heroFeatures = content.heroFeatures || (content.heroFeature ? [content.heroFeature] : []);
+    if (heroFeatures.length > 0) {
+        const heroLabel = heroFeatures.length > 1 ? '✨ HERO FEATURES OF THE WEEK' : '✨ FEATURE OF THE WEEK';
+        text += `${heroLabel}\n\n`;
+        heroFeatures.forEach((hero, index) => {
+            if (heroFeatures.length > 1) {
+                text += `HERO FEATURE ${index + 1}:\n`;
+            }
+            text += `${hero.title}\n`;
+            text += `${hero.description}\n`;
+            if (hero.impact) {
+                text += `Impact: ${hero.impact}\n`;
+            }
+            text += `\n`;
+        });
+    }
+    if (content.newFeatures && content.newFeatures.length > 0) {
+        text += `NEW FEATURES:\n`;
+        content.newFeatures.forEach((f) => {
+            text += `• ${f.title}: ${f.description}\n`;
+        });
+        text += `\n`;
+    }
+    if (content.improvements && content.improvements.length > 0) {
+        text += `IMPROVEMENTS:\n`;
+        content.improvements.forEach((i) => {
+            text += `• ${i.title}: ${i.description}\n`;
+        });
+        text += `\n`;
+    }
+    if (content.bugFixes && content.bugFixes.length > 0) {
+        text += `BUG FIXES:\n`;
+        content.bugFixes.forEach((b) => {
+            text += `• ${b.title}: ${b.description}\n`;
+        });
+        text += `\n`;
+    }
+    if (content.testimonial) {
+        text += `\n"${content.testimonial.text}"\n`;
+        text += `— ${content.testimonial.author}, ${content.testimonial.role}\n\n`;
+    }
+    if (content.comingNext) {
+        text += `COMING NEXT:\n${content.comingNext}\n\n`;
+    }
+    text += `\nWith gratitude,\n${fraim_config_1.fraimConfig.personaName}\nYour AI Executive Assistant\n\n`;
+    text += `Visit: ${fraim_config_1.fraimConfig.webAppUrl ? `${fraim_config_1.fraimConfig.webAppUrl}/wellness/${fraim_config_1.fraimConfig.personaName.toLowerCase()}` : '#'}\n`;
+    return text;
+}
+/**
+ * Send email via Gmail API (reuses existing pattern)
+ */
+async function sendEmailViaGmail(params, executive, personaTokens) {
+    const { to, subject, plainTextBody, htmlBody, fromEmail, fromDisplayName } = params;
+    let accessToken;
+    let refreshToken;
+    let isProdToken = false; // Track if we're using PROD tokens
+    if (personaTokens?.access_token && personaTokens?.refresh_token) {
+        accessToken = personaTokens.access_token;
+        refreshToken = personaTokens.refresh_token;
+        // Check if these are PROD tokens by comparing with PROD_FRAIM_DEFAULT_REFRESH_TOKEN
+        const prodRefreshToken = fraim_config_1.fraimConfig.prodRefreshToken || '';
+        if (prodRefreshToken && refreshToken === prodRefreshToken) {
+            isProdToken = true;
+        }
+    }
+    else if (executive?.personaAccessToken && executive?.personaRefreshToken) {
+        accessToken = executive.personaAccessToken;
+        refreshToken = executive.personaRefreshToken;
+    }
+    else {
+        accessToken = fraim_config_1.fraimConfig.defaultAccessToken || '';
+        refreshToken = fraim_config_1.fraimConfig.defaultRefreshToken || '';
+        if (!accessToken || !refreshToken) {
+            throw new Error(`${fraim_config_1.fraimConfig.personaName} Gmail tokens not found`);
+        }
+    }
+    const boundary = `boundary_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const emailMessage = [
+        `To: ${to}`,
+        `From: ${fromDisplayName} <${fromEmail}>`,
+        `Subject: ${subject}`,
+        `Content-Type: multipart/alternative; boundary="${boundary}"`,
+        `MIME-Version: 1.0`,
+        ``,
+        `--${boundary}`,
+        `Content-Type: text/plain; charset=utf-8`,
+        ``,
+        `--${boundary}`,
+        `Content-Type: text/html; charset=utf-8`,
+        ``,
+        htmlBody,
+        ``,
+        `--${boundary}--`
+    ].join('\r\n');
+    // Note: base64 encoding without newlines is important
+    const url = 'https://gmail.googleapis.com/gmail/v1/users/me/messages/send';
+    const requestBody = {
+        raw: Buffer.from(emailMessage).toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '')
+    };
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            // Token refresh logic - use PROD OAuth credentials if using PROD tokens
+            const clientId = isProdToken
+                ? fraim_config_1.fraimConfig.prodOAuthClientId
+                : fraim_config_1.fraimConfig.defaultOAuthClientId;
+            const clientSecret = isProdToken
+                ? fraim_config_1.fraimConfig.prodOAuthClientSecret
+                : fraim_config_1.fraimConfig.defaultOAuthClientSecret;
+            if (!clientId || !clientSecret) {
+                throw new Error(`OAuth credentials not found for token refresh${isProdToken ? ' (PROD)' : ''}`);
+            }
+            const refreshResponse = await fetch('https://oauth2.googleapis.com/token', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: new URLSearchParams({
+                    client_id: clientId,
+                    client_secret: clientSecret,
+                    refresh_token: refreshToken,
+                    grant_type: 'refresh_token'
+                })
+            });
+            if (!refreshResponse.ok) {
+                throw new Error('Failed to refresh access token');
+            }
+            const tokenData = await refreshResponse.json();
+            // Retry with new token
+            const retryResponse = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${tokenData.access_token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(requestBody)
+            });
+            if (!retryResponse.ok) {
+                throw new Error(`Gmail API error after refresh: ${retryResponse.status}`);
+            }
+            return;
+        }
+        throw new Error(`Gmail API error: ${response.status}`);
+    }
+}