fraim-framework 2.0.35 → 2.0.37

package/registry/scripts/profile-server.ts

@@ -0,0 +1,424 @@
+#!/usr/bin/env npx tsx
+
+import { execSync } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Production Server Profiler
+ * Automates the analysis of Azure App Service performance for coding agents.
+ * 
+ * Usage: npx tsx profile-server.ts [--prod|--preprod|--local] [--logs]
+ * 
+ * Self-contained script - reads configuration from .fraim/config.json
+ * Requires: Azure CLI (az) installed and authenticated
+ */
+
+// Self-contained configuration loading
+interface FraimConfig {
+  persona: { name: string };
+  azure?: {
+    prodAppName?: string;
+    prodResourceGroup?: string;
+    preprodAppName?: string;
+    preprodResourceGroup?: string;
+    localAppName?: string;
+    localResourceGroup?: string;
+  };
+}
+
+function loadClientConfig(): FraimConfig {
+  const configPath = join(process.cwd(), '.fraim', 'config.json');
+  if (!existsSync(configPath)) {
+    throw new Error('.fraim/config.json not found. Run fraim init first.');
+  }
+  return JSON.parse(readFileSync(configPath, 'utf-8'));
+}
+
+function getEnvOr(keys: string[], fallback: string): string {
+  for (const key of keys) {
+    const value = process.env[key];
+    if (value && value.length) return value;
+  }
+  return fallback;
+}
+
+interface ProfilingConfig {
+    env: 'prod' | 'preprod' | 'local';
+    appName: string;
+    resourceGroup: string;
+}
+
+function checkAzureCLI(): boolean {
+  try {
+    execSync('az --version', { stdio: 'pipe' });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function checkAzureAuth(): boolean {
+  try {
+    execSync('az account show', { stdio: 'pipe' });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+async function getAppServicePlanMetrics(appName: string, resourceGroup: string): Promise<void> {
+  try {
+    console.log('\n--- ☁️ App Service Plan Metrics ---');
+    
+    // Get App Service Plan ID
+    const planIdCmd = `az webapp show --name ${appName} --resource-group ${resourceGroup} --query "appServicePlanId" -o tsv`;
+    const planId = execSync(planIdCmd, { encoding: 'utf8' }).trim();
+    const planName = planId.split('/').pop();
+    console.log(`📋 Plan: ${planName}`);
+
+    // Get CPU and Memory metrics for last 5 minutes
+    console.log('📊 Fetching CPU and Memory metrics (last 5 minutes)...');
+    const metricsCmd = `az monitor metrics list --resource "${planId}" --metrics CpuPercentage MemoryPercentage --interval PT1M --query "value[].{name:name.value, data:timeseries[0].data}" -o json`;
+    
+    const metricsOutput = execSync(metricsCmd, { encoding: 'utf8' });
+    const metrics = JSON.parse(metricsOutput);
+    
+    for (const metric of metrics) {
+      const latestData = metric.data[metric.data.length - 1];
+      const value = latestData?.average || latestData?.total || 'N/A';
+      console.log(`  ${metric.name}: ${typeof value === 'number' ? value.toFixed(2) + '%' : value}`);
+    }
+  } catch (error: any) {
+    console.log(`⚠️  Could not fetch App Service Plan metrics: ${error.message.split('\n')[0]}`);
+  }
+}
+
+async function getAppServiceMetrics(appName: string, resourceGroup: string): Promise<void> {
+  try {
+    console.log('\n--- 🖥️ App Service Metrics ---');
+    
+    // Get subscription ID
+    const subscriptionId = execSync('az account show --query id -o tsv', { encoding: 'utf8' }).trim();
+    
+    // Get app-level metrics using Azure CLI
+    console.log('📊 Fetching App Service metrics (last 5 minutes)...');
+    const appResourceId = `/subscriptions/${subscriptionId}/resourceGroups/${resourceGroup}/providers/Microsoft.Web/sites/${appName}`;
+    
+    const appMetricsCmd = `az monitor metrics list --resource "${appResourceId}" --metrics CpuTime Requests Http2xx Http4xx Http5xx --interval PT1M --query "value[].{name:name.value, data:timeseries[0].data}" -o json`;
+    
+    const appMetricsOutput = execSync(appMetricsCmd, { encoding: 'utf8' });
+    const appMetrics = JSON.parse(appMetricsOutput);
+    
+    for (const metric of appMetrics) {
+      const latestData = metric.data[metric.data.length - 1];
+      const value = latestData?.total || latestData?.average || 'N/A';
+      let displayValue = value;
+      
+      if (typeof value === 'number') {
+        if (metric.name === 'CpuTime') {
+          displayValue = `${value.toFixed(2)}s`;
+        } else {
+          displayValue = value.toString();
+        }
+      }
+      
+      console.log(`  ${metric.name}: ${displayValue}`);
+    }
+  } catch (error: any) {
+    console.log(`⚠️  Could not fetch App Service metrics: ${error.message.split('\n')[0]}`);
+  }
+}
+
+async function getProcessInformation(appName: string): Promise<void> {
+  try {
+    console.log('\n--- ⚙️ Process Information (Kudu API) ---');
+    
+    // Get access token for Kudu API
+    const token = execSync('az account get-access-token --resource https://management.azure.com/ --query accessToken -o tsv', { encoding: 'utf8' }).trim();
+    
+    // Import axios dynamically
+    const axios = (await import('axios')).default;
+    
+    // Get process list from Kudu
+    console.log('📋 Fetching running processes...');
+    const processResponse = await axios.get(`https://${appName}.scm.azurewebsites.net/api/processes`, {
+      headers: { Authorization: `Bearer ${token}` },
+      timeout: 10000
+    });
+    
+    const processes = processResponse.data;
+    
+    // Sort by CPU usage and show top processes
+    const sortedProcesses = processes
+      .filter((p: any) => p.cpu_usage !== undefined)
+      .sort((a: any, b: any) => (b.cpu_usage || 0) - (a.cpu_usage || 0))
+      .slice(0, 10);
+    
+    console.log('\n🔥 Top 10 Processes by CPU Usage:');
+    console.log('PID\tCPU%\tMemory(MB)\tName');
+    console.log('---\t----\t---------\t----');
+    
+    for (const process of sortedProcesses) {
+      const pid = process.id || 'N/A';
+      const cpu = process.cpu_usage ? process.cpu_usage.toFixed(2) : '0.00';
+      const memory = process.working_set ? (process.working_set / 1024 / 1024).toFixed(1) : 'N/A';
+      const name = process.name || 'Unknown';
+      
+      console.log(`${pid}\t${cpu}\t${memory}\t\t${name.substring(0, 30)}`);
+    }
+    
+  } catch (error: any) {
+    console.log(`⚠️  Could not fetch process information: ${error.message.split('\n')[0]}`);
+    console.log('   This might be due to authentication issues or Kudu API being unavailable.');
+  }
+}
+
+async function getSystemInformation(appName: string): Promise<void> {
+  try {
+    console.log('\n--- 🖥️ System Information ---');
+    
+    const token = execSync('az account get-access-token --resource https://management.azure.com/ --query accessToken -o tsv', { encoding: 'utf8' }).trim();
+    const axios = (await import('axios')).default;
+    
+    // Get system info using Kudu command API
+    console.log('📊 Fetching system information...');
+    
+    const commands = [
+      { name: 'Memory Info', cmd: 'cat /proc/meminfo | head -10' },
+      { name: 'CPU Info', cmd: 'cat /proc/cpuinfo | grep "model name" | head -1' },
+      { name: 'Disk Usage', cmd: 'df -h | head -5' },
+      { name: 'Load Average', cmd: 'uptime' }
+    ];
+    
+    for (const command of commands) {
+      try {
+        const response = await axios.post(`https://${appName}.scm.azurewebsites.net/api/command`, {
+          command: command.cmd,
+          dir: '/home'
+        }, {
+          headers: { Authorization: `Bearer ${token}` },
+          timeout: 5000
+        });
+        
+        console.log(`\n${command.name}:`);
+        const output = response.data.Output || response.data.Error || 'No output';
+        console.log(output.split('\n').map((line: string) => `  ${line}`).join('\n'));
+        
+      } catch (cmdError: any) {
+        console.log(`\n${command.name}: Could not retrieve (${cmdError.message.split('\n')[0]})`);
+      }
+    }
+    
+  } catch (error: any) {
+    console.log(`⚠️  Could not fetch system information: ${error.message.split('\n')[0]}`);
+  }
+}
+
+async function getApplicationLogs(appName: string, resourceGroup: string): Promise<void> {
+  try {
+    console.log('\n--- 📋 Recent Application Logs ---');
+    
+    // Get recent logs using Azure CLI
+    console.log('📄 Fetching recent application logs...');
+    const logsCmd = `az webapp log tail --name ${appName} --resource-group ${resourceGroup} --provider application --timeout 5`;
+    
+    try {
+      const logs = execSync(logsCmd, { encoding: 'utf8', timeout: 10000 });
+      console.log('Recent logs:');
+      console.log(logs.split('\n').slice(-20).map(line => `  ${line}`).join('\n'));
+    } catch (logError) {
+      console.log('⚠️  Could not fetch logs - they may not be enabled or available');
+      console.log('   Enable application logging in Azure portal for better diagnostics');
+    }
+    
+  } catch (error: any) {
+    console.log(`⚠️  Could not fetch application logs: ${error.message.split('\n')[0]}`);
+  }
+}
+
+async function profileLocalEnvironment(): Promise<void> {
+  console.log('\n--- 🏠 Local Environment Profiling ---');
+  
+  try {
+    // Basic system information
+    console.log('💻 System Information:');
+    
+    if (process.platform === 'win32') {
+      try {
+        const systemInfo = execSync('systeminfo | findstr /C:"Total Physical Memory" /C:"Available Physical Memory" /C:"Processor"', { encoding: 'utf8' });
+        console.log(systemInfo.split('\n').map(line => `  ${line.trim()}`).filter(line => line).join('\n'));
+      } catch {
+        console.log('  Could not retrieve Windows system info');
+      }
+    } else {
+      try {
+        const memInfo = execSync('free -h', { encoding: 'utf8' });
+        const cpuInfo = execSync('cat /proc/cpuinfo | grep "model name" | head -1', { encoding: 'utf8' });
+        console.log('  Memory:');
+        console.log(memInfo.split('\n').map(line => `    ${line}`).join('\n'));
+        console.log('  CPU:');
+        console.log(`    ${cpuInfo.trim()}`);
+      } catch {
+        console.log('  Could not retrieve Linux system info');
+      }
+    }
+    
+    // Node.js process information
+    console.log('\n🟢 Node.js Process Information:');
+    console.log(`  Node Version: ${process.version}`);
+    console.log(`  Platform: ${process.platform}`);
+    console.log(`  Architecture: ${process.arch}`);
+    console.log(`  Memory Usage:`);
+    const memUsage = process.memoryUsage();
+    console.log(`    RSS: ${(memUsage.rss / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`    Heap Used: ${(memUsage.heapUsed / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`    Heap Total: ${(memUsage.heapTotal / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`    External: ${(memUsage.external / 1024 / 1024).toFixed(2)} MB`);
+    
+  } catch (error: any) {
+    console.log(`⚠️  Error profiling local environment: ${error.message}`);
+  }
+}
+
+async function main() {
+    const config = loadClientConfig();
+    
+    // Azure configuration with environment variable fallbacks
+    const azureConfig = {
+        prodAppName: config.azure?.prodAppName || getEnvOr(['FRAIM_AZURE_PROD_APP_NAME'], 'fraim-app-prod'),
+        prodResourceGroup: config.azure?.prodResourceGroup || getEnvOr(['FRAIM_AZURE_PROD_RESOURCE_GROUP'], 'fraim-prod-rg'),
+        preprodAppName: config.azure?.preprodAppName || getEnvOr(['FRAIM_AZURE_PREPROD_APP_NAME'], 'fraim-app-pre-prod'),
+        preprodResourceGroup: config.azure?.preprodResourceGroup || getEnvOr(['FRAIM_AZURE_PREPROD_RESOURCE_GROUP'], 'fraim-pre-prod-rg'),
+        localAppName: config.azure?.localAppName || getEnvOr(['FRAIM_AZURE_LOCAL_APP_NAME'], 'local'),
+        localResourceGroup: config.azure?.localResourceGroup || getEnvOr(['FRAIM_AZURE_LOCAL_RESOURCE_GROUP'], 'local')
+    };
+
+    const CONFIGS: Record<string, ProfilingConfig> = {
+        prod: {
+            env: 'prod',
+            appName: azureConfig.prodAppName,
+            resourceGroup: azureConfig.prodResourceGroup
+        },
+        preprod: {
+            env: 'preprod',
+            appName: azureConfig.preprodAppName,
+            resourceGroup: azureConfig.preprodResourceGroup
+        },
+        local: {
+            env: 'local',
+            appName: azureConfig.localAppName,
+            resourceGroup: azureConfig.localResourceGroup
+        }
+    };
+
+    const args = process.argv.slice(2);
+    let profileConfig: ProfilingConfig = CONFIGS.local;
+    const includeLogs = args.includes('--logs');
+
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`
+🔍 Azure App Service Profiler
+
+Usage:
+  npx tsx profile-server.ts [options]
+
+Options:
+  --prod                           Profile production environment
+  --preprod                        Profile pre-production environment  
+  --local                          Profile local environment (default)
+  --logs                           Include application logs in analysis
+  --help, -h                       Show this help message
+
+Examples:
+  # Profile production server
+  npx tsx profile-server.ts --prod
+
+  # Profile with logs
+  npx tsx profile-server.ts --prod --logs
+
+  # Profile local environment
+  npx tsx profile-server.ts --local
+
+Requirements:
+  - Azure CLI (az) installed and authenticated
+  - Proper permissions to access App Service resources
+  - For Kudu API access: Contributor role on the App Service
+
+Configuration:
+  Reads Azure settings from .fraim/config.json or environment variables:
+  - FRAIM_AZURE_PROD_APP_NAME
+  - FRAIM_AZURE_PROD_RESOURCE_GROUP
+  - FRAIM_AZURE_PREPROD_APP_NAME
+  - FRAIM_AZURE_PREPROD_RESOURCE_GROUP
+        `);
+        return;
+    }
+
+    if (args.includes('--prod')) profileConfig = CONFIGS.prod;
+    else if (args.includes('--preprod')) profileConfig = CONFIGS.preprod;
+    else if (args.includes('--local')) profileConfig = CONFIGS.local;
+
+    console.log(`\n🚀 Starting Server Profiling`);
+    console.log(`📊 Environment: ${profileConfig.env.toUpperCase()}`);
+    console.log(`🏷️  App: ${profileConfig.appName}`);
+    console.log(`📁 Resource Group: ${profileConfig.resourceGroup}`);
+
+    if (profileConfig.env === 'local') {
+        await profileLocalEnvironment();
+        console.log('\n✅ Local profiling completed');
+        return;
+    }
+
+    // Check prerequisites for Azure profiling
+    console.log('\n🔍 Checking prerequisites...');
+    
+    if (!checkAzureCLI()) {
+        console.error('❌ Azure CLI not found. Please install Azure CLI first.');
+        console.error('   Download from: https://docs.microsoft.com/en-us/cli/azure/install-azure-cli');
+        process.exit(1);
+    }
+    console.log('✅ Azure CLI found');
+
+    if (!checkAzureAuth()) {
+        console.error('❌ Not authenticated with Azure. Please run: az login');
+        process.exit(1);
+    }
+    console.log('✅ Azure authentication verified');
+
+    try {
+        // Verify app exists
+        console.log(`\n🔍 Verifying App Service: ${profileConfig.appName}`);
+        execSync(`az webapp show --name ${profileConfig.appName} --resource-group ${profileConfig.resourceGroup} --query name -o tsv`, { stdio: 'pipe' });
+        console.log('✅ App Service found');
+
+        // Run profiling analysis
+        await getAppServicePlanMetrics(profileConfig.appName, profileConfig.resourceGroup);
+        await getAppServiceMetrics(profileConfig.appName, profileConfig.resourceGroup);
+        await getProcessInformation(profileConfig.appName);
+        await getSystemInformation(profileConfig.appName);
+        
+        if (includeLogs) {
+            await getApplicationLogs(profileConfig.appName, profileConfig.resourceGroup);
+        }
+
+        console.log('\n✅ Server profiling completed successfully');
+        console.log('\n💡 Tips:');
+        console.log('   - Use --logs flag to include application logs');
+        console.log('   - High CPU usage may indicate performance bottlenecks');
+        console.log('   - High memory usage may indicate memory leaks');
+        console.log('   - Check process list for unexpected or resource-heavy processes');
+
+    } catch (error: any) {
+        console.error(`\n❌ Profiling failed: ${error.message}`);
+        console.error('\nTroubleshooting:');
+        console.error('   - Verify app name and resource group are correct');
+        console.error('   - Ensure you have proper permissions (Contributor role)');
+        console.error('   - Check if the App Service is running');
+        console.error('   - Try: az webapp list --query "[].{name:name, resourceGroup:resourceGroup}"');
+        process.exit(1);
+    }
+}
+
+// Run the main function
+main().catch(console.error);

package/registry/scripts/run-thank-you-workflow.ts

@@ -0,0 +1,122 @@
+#!/usr/bin/env tsx
+
+/**
+ * Runner script for thank-you email workflow
+ * Called by AI agents to generate thank-you emails
+ */
+
+import { getResolvedIssues, findExecutiveByEmail, getPersonaEmailForExecutive } from './generate-engagement-emails';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+interface CustomerData {
+  email: string;
+  name: string;
+  issues: Array<{
+    number: number;
+    title: string;
+    body: string;
+  }>;
+  executiveId?: string;
+  executiveName?: string;
+  personaEmail?: string;
+}
+
+async function main() {
+  console.log('🎯 Starting thank-you email generation workflow...\n');
+
+  // Step 1: Get resolved issues
+  console.log('📋 Step 1: Retrieving resolved issues...');
+  const issues = await getResolvedIssues();
+
+  console.log(`\n✅ Found ${issues.length} resolved issues\n`);
+
+  // Step 2: Extract customer information
+  console.log('📧 Step 2: Extracting customer information...\n');
+
+  const customerMap = new Map<string, CustomerData>();
+
+  for (const issue of issues) {
+    // Extract email and name from issue body or title
+    let customerEmail: string | null = null;
+    let customerName: string | null = null;
+
+    // Try to extract from body first
+    const bodyEmailMatch = issue.body?.match(/\*\*Reported by:\*\*\s+(.+?)\s+\((.+?)\)/);
+    if (bodyEmailMatch) {
+      customerName = bodyEmailMatch[1].trim();
+      customerEmail = bodyEmailMatch[2].trim();
+    }
+
+    // Try to extract from title (format: "email: summary")
+    if (!customerEmail) {
+      const titleEmailMatch = issue.title.match(/^([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}):/);
+      if (titleEmailMatch) {
+        customerEmail = titleEmailMatch[1];
+      }
+    }
+
+    if (!customerEmail) {
+      console.log(`⚠️  Issue #${issue.number}: Could not extract customer email, skipping`);
+      continue;
+    }
+
+    // Normalize email to lowercase for consistent matching
+    const normalizedEmail = customerEmail.toLowerCase();
+
+    // Add or update customer data
+    if (!customerMap.has(normalizedEmail)) {
+      customerMap.set(normalizedEmail, {
+        email: normalizedEmail,
+        name: customerName || 'Valued Customer',
+        issues: []
+      });
+    }
+
+    const customerData = customerMap.get(normalizedEmail)!;
+    customerData.issues.push({
+      number: issue.number,
+      title: issue.title,
+      body: issue.body || ''
+    });
+  }
+
+  console.log(`📊 Found ${customerMap.size} unique customers\n`);
+
+  // Step 3: Lookup executive data for each customer
+  console.log('🔍 Step 3: Looking up executive data...\n');
+
+  const entries = Array.from(customerMap.entries());
+  for (const [email, customerData] of entries) {
+    try {
+      const executive = await findExecutiveByEmail(email);
+
+      if (executive) {
+        customerData.executiveId = executive.id;
+        customerData.executiveName = executive.name;
+
+        if (executive.id) {
+          const personaEmail = await getPersonaEmailForExecutive(executive.id);
+          customerData.personaEmail = personaEmail;
+          console.log(`✅ ${email}: Found executive ${executive.name} (${executive.id}), Persona email: ${personaEmail}`);
+        } else {
+          console.log(`⚠️  ${email}: Found executive ${executive.name} but no ID`);
+        }
+      } else {
+        console.log(`⚠️  ${email}: No executive record found in database`);
+      }
+    } catch (error) {
+      console.error(`❌ ${email}: Error looking up executive:`, error);
+    }
+  }
+
+  console.log('\n📝 Customer Data Summary:\n');
+  console.log(JSON.stringify(Array.from(customerMap.values()), null, 2));
+
+  // Save to temp file for AI agent to process
+  const outputPath = join(process.cwd(), 'temp-customer-data.json');
+  writeFileSync(outputPath, JSON.stringify(Array.from(customerMap.values()), null, 2));
+  console.log(`\n💾 Customer data saved to: ${outputPath}`);
+}
+
+main().catch(console.error);

package/registry/scripts/send-newsletter-simple.ts

@@ -0,0 +1,102 @@
+#!/usr/bin/env tsx
+
+/**
+ * Send Newsletter - Deterministic Script
+ * 
+ * Simple script that users run after approving newsletter JSON.
+ * No decisions, just sends the newsletter.
+ * 
+ * Usage:
+ *   npm run send-newsletter                                    # Send to all executives and potential customers
+ *   npm run send-newsletter -- --showonly                      # List recipients without sending
+ *   npm run send-newsletter -- --no-potential-customers        # Send only to active executives
+ *   npm run send-newsletter -- --only-potential-customers      # Send only to potential customers
+ *   npm run send-newsletter -- --email=user@example.com        # Send to specific email
+ *   npm run send-newsletter -- exec-XXX exec-YYY               # Send to specific executive IDs
+ */
+
+import { sendNewsletterToExecutives } from './newsletter-helpers';
+import { readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+
+async function main() {
+  console.log('📧 Weekly Newsletter Sender\n');
+
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+  const showOnly = args.includes('--showonly');
+  const excludePotentialCustomers = args.includes('--no-potential-customers');
+  const onlyPotentialCustomers = args.includes('--only-potential-customers');
+  const filterEmails: string[] = [];
+  const filterExecIds: string[] = [];
+
+  // Parse email filters (--email=address)
+  args.forEach(arg => {
+    if (arg.startsWith('--email=')) {
+      filterEmails.push(arg.substring(8));
+    } else if (arg.startsWith('exec-')) {
+      filterExecIds.push(arg);
+    }
+  });
+
+  // Find the most recent newsletter
+  const newslettersDir = join(process.cwd(), 'docs', 'customer-development', 'newsletters');
+
+  if (!existsSync(newslettersDir)) {
+    console.error('❌ Error: No newsletters directory found');
+    console.error('   Expected: docs/customer-development/newsletters/');
+    console.error('   Generate a newsletter first using the AI agent workflow');
+    process.exit(1);
+  }
+
+  const files = readdirSync(newslettersDir)
+    .filter(f => f.startsWith('newsletter-') && f.endsWith('.json'))
+    .sort()
+    .reverse(); // Most recent first
+
+  if (files.length === 0) {
+    console.error('❌ Error: No newsletter files found');
+    console.error('   Generate a newsletter first using the AI agent workflow');
+    process.exit(1);
+  }
+
+  const latestNewsletter = files[0];
+  const newsletterPath = join(newslettersDir, latestNewsletter);
+
+  console.log(`📄 Found newsletter: ${latestNewsletter}`);
+
+  if (showOnly) {
+    console.log(`📋 Listing recipients (--showonly mode - no emails will be sent)...\n`);
+  } else if (filterEmails.length > 0 || filterExecIds.length > 0) {
+    console.log(`📧 Sending to filtered recipients...\n`);
+    console.log(`⚠️  This will send real emails. Make sure the newsletter is approved!`);
+  } else {
+    if (onlyPotentialCustomers) {
+      console.log(`📧 Sending to potential customers only...\n`);
+    } else {
+      console.log(`📧 Sending to all active executives${excludePotentialCustomers ? '' : ' and potential customers'}...\n`);
+    }
+    console.log(`⚠️  This will send real emails. Make sure the newsletter is approved!`);
+  }
+
+  console.log(`   Preview: ${newsletterPath.replace('.json', '.html')}\n`);
+
+  // Determine what to include based on flags
+  const includePotentialCustomers = onlyPotentialCustomers || !excludePotentialCustomers;
+  const includeExecutives = !onlyPotentialCustomers;
+
+  // Send newsletter (or show only)
+  await sendNewsletterToExecutives(
+    newsletterPath,
+    filterEmails.length > 0 ? filterEmails : undefined,
+    filterExecIds.length > 0 ? filterExecIds : undefined,
+    includePotentialCustomers,
+    showOnly,
+    includeExecutives
+  );
+}
+
+main().catch(error => {
+  console.error('❌ Error:', error.message);
+  process.exit(1);
+});