fraim-framework 2.0.26 → 2.0.30

package/dist/registry/scripts/performance/profile-server.js

@@ -0,0 +1,390 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fraim_config_1 = require("../fraim-config");
+const azureConfig = fraim_config_1.fraimConfig.azure;
+const CONFIGS = {
+    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
+    }
+};
+async function main() {
+    const args = process.argv.slice(2);
+    let config = CONFIGS.local;
+    const includeLogs = args.includes('--logs');
+    if (args.includes('--prod'))
+        config = CONFIGS.prod;
+    else if (args.includes('--preprod'))
+        config = CONFIGS.preprod;
+    else if (args.includes('--local')) {
+        console.log('🔍 Running in local mode (log analysis only)');
+        config = CONFIGS.local;
+    }
+    else {
+        console.log('⚠️ No environment specified.');
+        console.log('Usage: npx tsx <this-script> [--prod|--preprod|--local] [--logs]');
+        return;
+    }
+    console.log(`\n🚀 Starting Profiling for Environment: ${config.env.toUpperCase()}`);
+    // 1. Infrastructure (Step 1)
+    if (config.env !== 'local') {
+        try {
+            console.log('\n--- ☁️ Step 1: Server Resource Analysis (Plan Level) ---');
+            // Get App Service Plan ID
+            const planId = (0, child_process_1.execSync)(`az webapp show --name ${config.appName} --resource-group ${config.resourceGroup} --query "appServicePlanId" -o tsv`).toString().trim();
+            console.log(`Plan ID: ${planId.split('/').pop()}`);
+            // 1a. Overall Metric (Plan Level)
+            // Get last 5 minutes of CPU/Memory
+            console.log(`> Fetching Plan Metrics (Last 5m)...`);
+            const metricCmd = `az monitor metrics list --resource "${planId}" --metrics CpuPercentage MemoryPercentage --interval PT1M --query "value[].{name:name.value, average:timeseries[0].data[-1].average}" -o json`;
+            try {
+                const metrics = JSON.parse((0, child_process_1.execSync)(metricCmd).toString());
+                metrics.forEach((m) => {
+                    console.log(`${m.name}: ${m.average != null ? m.average.toFixed(2) + '%' : 'N/A'}`);
+                });
+            }
+            catch (e) {
+                console.log(`⚠️ Could not fetch plan metrics: ${e.message.split('\n')[0]}`);
+            }
+            // Prepare for API calls
+            // Get Access Token explicitly
+            const token = (0, child_process_1.execSync)('az account get-access-token --resource https://management.azure.com/ --query accessToken -o tsv').toString().trim();
+            const axios = (await Promise.resolve().then(() => __importStar(require('axios')))).default;
+            // --- 1.5: App Level Metrics (CpuTime) ---
+            try {
+                console.log(`\n> Fetching App Metrics (Last 5m) for ${config.appName}...`);
+                const subscriptionId = (0, child_process_1.execSync)(`az account show --query id -o tsv`).toString().trim();
+                const siteResourceId = `/subscriptions/${subscriptionId}/resourceGroups/${config.resourceGroup}/providers/Microsoft.Web/sites/${config.appName}`;
+                const appResponse = await axios.get(`https://management.azure.com${siteResourceId}/providers/microsoft.insights/metrics?api-version=2018-01-01&metricnames=CpuTime&timespan=PT5M&aggregation=Total`, { headers: { Authorization: `Bearer ${token}` } });
+                if (appResponse.data && appResponse.data.value) {
+                    appResponse.data.value.forEach((m) => {
+                        const val = (m.timeseries[0]?.data[0]?.total);
+                        const displayVal = val !== undefined ? val.toFixed(2) : 'N/A';
+                        console.log(`${m.name.value}: ${displayVal}s (Total over 5m)`);
+                    });
+                }
+            }
+            catch (e) {
+                console.log(`⚠️ Could not fetch app metrics: ${e.message}`);
+            }
+            // 2. Process Metrics (Step 2)
+            console.log(`\n--- ⚙️ Step 2: Per-Process Resource Analysis (Kudu) ---`);
+            try {
+                // Token and axios already fetched above
+                const response = await axios.get(`https://${config.appName}.scm.azurewebsites.net/api/processes`, {
+                    headers: { Authorization: `Bearer ${token}` }
+                });
+                const processes = response.data;
+                // Shared diagnostics state
+                let memInfoOutput = '';
+                let psOutput = '';
+                let psLines = [];
+                // Use Kudu Command API to run 'top' remotely
+                try {
+                    const topCmd = {
+                        command: "top -b -d 3 -n 2",
+                        dir: "/home"
+                    };
+                    const cmdRes = await axios.post(`https://${config.appName}.scm.azurewebsites.net/api/command`, topCmd, {
+                        headers: { Authorization: `Bearer ${token}` },
+                        timeout: 25000
+                    });
+                    if (cmdRes.data && cmdRes.data.Output) {
+                        const lines = cmdRes.data.Output.split('\n');
+                        // --- Trace System Summary ---
+                        console.log('System Summary (from top):');
+                        let summaryLinesCount = 0;
+                        for (const line of lines) {
+                            if (line.trim() && summaryLinesCount < 5) {
+                                console.log(`  ${line.trim()}`);
+                                summaryLinesCount++;
+                            }
+                        }
+                        // --- Deep Dive: Missing Memory Investigation ---
+                        console.log(`\n> Investigating "Invisible" Memory Usage...`);
+                        try {
+                            const dfCmd = { command: "df -h | grep -E 'tmpfs|shm'", dir: "/home" };
+                            const dfRes = await axios.post(`https://${config.appName}.scm.azurewebsites.net/api/command`, dfCmd, { headers: { Authorization: `Bearer ${token}` } });
+                            console.log('  [Tmpfs/Shm Usage]:');
+                            console.log(dfRes.data.Output ? '  ' + dfRes.data.Output.replace(/\n/g, '\n  ').trim() : '  (No output)');
+                            const memInfoCmd = { command: "cat /proc/meminfo | grep -E 'MemTotal|MemFree|MemAvailable|SwapTotal|SwapFree|Shmem|Slab|SUnreclaim|Buffers|Cached|AnonPages|Committed_AS'", dir: "/home" };
+                            const memRes = await axios.post(`https://${config.appName}.scm.azurewebsites.net/api/command`, memInfoCmd, { headers: { Authorization: `Bearer ${token}` } });
+                            memInfoOutput = memRes.data.Output || '';
+                            console.log('  [Detailed MemInfo]:');
+                            console.log(memInfoOutput ? '  ' + memInfoOutput.replace(/\n/g, '\n  ').trim() : '  (No output)');
+                            console.log('\n  [Searching for Swap/VM Hogs in /proc...]:');
+                            const swapHogCmd = {
+                                command: "for f in /proc/[0-9]*/status; do grep -E '^(Name|Pid|VmSwap|VmSize)' $f 2>/dev/null | tr '\n' ' ' && echo ''; done | sort -k6 -rn | head -n 10",
+                                dir: "/home"
+                            };
+                            const swapRes = await axios.post(`https://${config.appName}.scm.azurewebsites.net/api/command`, swapHogCmd, { headers: { Authorization: `Bearer ${token}` } });
+                            console.log('  (Format: Name, Pid, VmSize, VmSwap)');
+                            console.log(swapRes.data.Output ? '  ' + swapRes.data.Output.replace(/\n/g, '\n  ').trim() : '  (No output)');
+                        }
+                        catch (e) {
+                            console.log(`  Could not inspect storage/meminfo: ${e.message}`);
+                        }
+                        let currentSnapshot = [];
+                        let foundHeader = false;
+                        let cpuColIndex = -1;
+                        let memColIndex = -1;
+                        let cmdColIndex = -1;
+                        for (const line of lines) {
+                            const trimmed = line.trim();
+                            if (!trimmed)
+                                continue;
+                            if (trimmed.includes('PID') && trimmed.includes('COMMAND')) {
+                                foundHeader = true;
+                                currentSnapshot = [];
+                                const headers = trimmed.split(/\s+/);
+                                cpuColIndex = headers.indexOf('%CPU');
+                                if (cpuColIndex === -1)
+                                    cpuColIndex = headers.indexOf('CPU%');
+                                memColIndex = headers.indexOf('%MEM');
+                                if (memColIndex === -1)
+                                    memColIndex = headers.indexOf('MEM%');
+                                cmdColIndex = headers.indexOf('COMMAND');
+                                continue;
+                            }
+                            if (foundHeader && cpuColIndex >= 0) {
+                                const parts = trimmed.split(/\s+/);
+                                if (parts.length >= 9) {
+                                    const pid = parts[0];
+                                    const cpuStr = parts[cpuColIndex];
+                                    const memStr = parts[memColIndex];
+                                    const cmd = parts.slice(cmdColIndex).join(' ');
+                                    const state = parts[7] || '?';
+                                    const time = parts[10] || '?';
+                                    const cpuVal = parseFloat(cpuStr);
+                                    const memVal = parseFloat(memStr);
+                                    if (!isNaN(parseInt(pid))) {
+                                        currentSnapshot.push({ pid, cmd, cpuStr, memStr, cpuVal, memVal, state, time });
+                                    }
+                                }
+                            }
+                        }
+                        if (currentSnapshot.length === 0) {
+                            console.log('(No processes found or parsing failed)');
+                        }
+                        else {
+                            console.log(`\n--- Cross-Referencing Memory Hogs (ps aux) ---`);
+                            try {
+                                const psRes = await axios.post(`https://${config.appName}.scm.azurewebsites.net/api/command`, { command: "ps aux", dir: "/home" }, { headers: { Authorization: `Bearer ${token}` } });
+                                psOutput = psRes.data.Output || '';
+                                console.log(`PID\tVSZ\tRSS\tCOMMAND`);
+                                console.log(`---\t---\t---\t-------`);
+                                psLines = psOutput.split('\n').filter((l) => l.includes(' '));
+                                psLines.slice(1, 10).forEach((l) => {
+                                    const p = l.trim().split(/\s+/);
+                                    if (p.length > 10) {
+                                        console.log(`${p[1]}\t${(parseInt(p[4]) / 1024).toFixed(0)}M\t${(parseInt(p[5]) / 1024).toFixed(0)}M\t${p.slice(10).join(' ').padEnd(30).slice(0, 30)}`);
+                                    }
+                                });
+                            }
+                            catch (e) {
+                                console.log(`  Could not fetch ps aux: ${e.message}`);
+                            }
+                            console.log(`\n--- Top Processes by CPU (top delta) ---`);
+                            console.log(`PID\tSTATE\tTIME+\t%CPU\t%MEM\tCOMMAND`);
+                            console.log(`---\t-----\t-----\t----\t----\t-------`);
+                            currentSnapshot.sort((a, b) => b.cpuVal - a.cpuVal);
+                            currentSnapshot.slice(0, 5).forEach(p => {
+                                console.log(`${p.pid}\t${p.state}\t${p.time}\t${p.cpuStr}%\t${p.memStr}%\t${p.cmd.padEnd(20).slice(0, 20)}`);
+                            });
+                            console.log(`\n--- 🧠 Step 4: Automated Diagnosis ---`);
+                            try {
+                                let healthy = true;
+                                if (memInfoOutput.includes('SwapTotal')) {
+                                    const swapTotal = parseInt(memInfoOutput.match(/SwapTotal:\s+(\d+)/)?.[1] || '0');
+                                    const swapFree = parseInt(memInfoOutput.match(/SwapFree:\s+(\d+)/)?.[1] || '0');
+                                    if (swapTotal > 0) {
+                                        const swapUsedPct = ((swapTotal - swapFree) / swapTotal) * 100;
+                                        if (swapUsedPct > 95) {
+                                            console.log(`❌ [CRITICAL] Swap Death detected (${swapUsedPct.toFixed(1)}% used).`);
+                                            healthy = false;
+                                        }
+                                    }
+                                }
+                                const hasApp = psOutput.includes('server.js') || psOutput.includes('orchestrator.ts');
+                                if (!hasApp) {
+                                    console.log(`❌ [CRITICAL] Application process 'server.js' NOT FOUND in ps aux.`);
+                                    healthy = false;
+                                }
+                                const kuduHog = currentSnapshot.find(p => p.pid === '851' && p.memVal > 20);
+                                if (kuduHog) {
+                                    console.log(`⚠️ [WARNING] Kudu (Azure Agent) is consuming ${kuduHog.memStr}% of physical RAM.`);
+                                    healthy = false;
+                                }
+                                const pm2Hogs = psLines.filter((l) => l.includes('God Daemon'));
+                                if (pm2Hogs.length > 1) {
+                                    console.log(`⚠️ [WARNING] Multiple PM2 God Daemons detected (${pm2Hogs.length}). Potential resource conflict.`);
+                                    healthy = false;
+                                }
+                                if (healthy) {
+                                    console.log(`✅ No obvious infrastructure bottlenecks detected.`);
+                                }
+                                else {
+                                    console.log(`\nRECOMMENDED ACTIONS:`);
+                                    console.log(`1. Restart the Web App to clear Swap and kill rogue agents.`);
+                                    console.log(`2. Consider upgrading the App Service Plan (B1 -> P1v3) for more RAM.`);
+                                }
+                            }
+                            catch (e) {
+                                console.log(`  Could not perform automated diagnosis: ${e.message}`);
+                            }
+                        }
+                    }
+                    else {
+                        console.log('Debug: Unexpected response format:', cmdRes.data);
+                    }
+                }
+                catch (err) {
+                    console.log(`⚠️ 'top' failed via Kudu: ${err.message}`);
+                }
+            }
+            catch (e) {
+                console.log(`⚠️ Could not fetch process metrics: ${e.message}`);
+            }
+        }
+        catch (error) {
+            console.error('❌ Failed to fetch infrastructure metrics:', error.message);
+        }
+    }
+    // 3. Log Analysis (Step 3)
+    if (includeLogs || config.env === 'local') {
+        console.log('\n--- 📝 Step 3: Log Analysis ---');
+        let logContent = '';
+        if (config.env !== 'local') {
+            try {
+                console.log('> Downloading recent logs from Azure...');
+                const fraimTmp = path.join(os.homedir(), '.fraim', 'tmp');
+                if (!fs.existsSync(fraimTmp))
+                    fs.mkdirSync(fraimTmp, { recursive: true });
+                const tempDir = fs.mkdtempSync(path.join(fraimTmp, `${fraim_config_1.fraimConfig.personaName.toLowerCase()}-logs-`));
+                const zipPath = path.join(tempDir, 'logs.zip');
+                (0, child_process_1.execSync)(`az webapp log download --name ${config.appName} --resource-group ${config.resourceGroup} --log-file "${zipPath}"`);
+                const originalCwd = process.cwd();
+                try {
+                    process.chdir(tempDir);
+                    try {
+                        (0, child_process_1.execSync)(`unzip -o logs.zip`);
+                    }
+                    catch (e) {
+                        try {
+                            (0, child_process_1.execSync)(`powershell -command "Expand-Archive -Path 'logs.zip' -DestinationPath '.' -Force"`);
+                        }
+                        catch (p) { }
+                    }
+                    process.chdir(originalCwd);
+                }
+                catch (e) {
+                    process.chdir(originalCwd);
+                }
+                const findLogFile = (dir) => {
+                    const files = fs.readdirSync(dir);
+                    for (const file of files) {
+                        const fullPath = path.join(dir, file);
+                        const stat = fs.statSync(fullPath);
+                        if (stat.isDirectory()) {
+                            const found = findLogFile(fullPath);
+                            if (found)
+                                return found;
+                        }
+                        else if (file.endsWith('_default_docker.log')) {
+                            return fullPath;
+                        }
+                    }
+                    return null;
+                };
+                const dockerLog = findLogFile(tempDir);
+                if (dockerLog)
+                    logContent = fs.readFileSync(dockerLog, 'utf-8');
+            }
+            catch (error) {
+                console.error('❌ Failed to download logs:', error.message);
+            }
+        }
+        else {
+            const localLogPath = path.join(process.cwd(), 'test.log');
+            if (fs.existsSync(localLogPath))
+                logContent = fs.readFileSync(localLogPath, 'utf-8');
+        }
+        if (logContent) {
+            analyzeLogs(logContent);
+        }
+    }
+}
+function analyzeLogs(content) {
+    const lines = content.split('\n');
+    let indexChecks = 0, decryptions = 0, dbConnections = 0, rssMemory = 0;
+    const indexPattern = /Ensured unique index/;
+    const decryptPattern = /Token decrypted/;
+    const dbConnPattern = /Database connection successful/;
+    const memoryPattern = /RSS: (\d+) MB/;
+    for (const line of lines) {
+        if (indexPattern.test(line))
+            indexChecks++;
+        if (decryptPattern.test(line))
+            decryptions++;
+        if (dbConnPattern.test(line))
+            dbConnections++;
+        const memMatch = line.match(memoryPattern);
+        if (memMatch)
+            rssMemory = Math.max(rssMemory, parseInt(memMatch[1]));
+    }
+    console.log('\n--- 📊 Operation Frequency ---');
+    console.log(`Ensured Unique Index: ${indexChecks}`);
+    console.log(`Token Decryptions:    ${decryptions}`);
+    console.log(`DB Connections:       ${dbConnections}`);
+    if (rssMemory > 0)
+        console.log(`Max RSS Detected: ${rssMemory} MB`);
+}
+main().catch(console.error);

package/dist/registry/scripts/run-thank-you-workflow.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Runner script for thank-you email workflow
+ * Called by AI agents to generate thank-you emails
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const generate_engagement_emails_1 = require("./generate-engagement-emails");
+const fs_1 = require("fs");
+const path_1 = require("path");
+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 (0, generate_engagement_emails_1.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();
+    for (const issue of issues) {
+        // Extract email and name from issue body or title
+        let customerEmail = null;
+        let customerName = 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 (0, generate_engagement_emails_1.findExecutiveByEmail)(email);
+            if (executive) {
+                customerData.executiveId = executive.id;
+                customerData.executiveName = executive.name;
+                if (executive.id) {
+                    const personaEmail = await (0, generate_engagement_emails_1.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 = (0, path_1.join)(process.cwd(), 'temp-customer-data.json');
+    (0, fs_1.writeFileSync)(outputPath, JSON.stringify(Array.from(customerMap.values()), null, 2));
+    console.log(`\n💾 Customer data saved to: ${outputPath}`);
+}
+main().catch(console.error);

package/dist/registry/scripts/send-newsletter-simple.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const newsletter_helpers_1 = require("./newsletter-helpers");
+const fs_1 = require("fs");
+const path_1 = require("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 = [];
+    const filterExecIds = [];
+    // 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 = (0, path_1.join)(process.cwd(), 'docs', 'customer-development', 'newsletters');
+    if (!(0, fs_1.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 = (0, fs_1.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 = (0, path_1.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 (0, newsletter_helpers_1.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);
+});

package/dist/registry/scripts/send-thank-you-emails.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Send Thank-You Emails from Candidates JSON File
+ *
+ * Usage:
+ *   npm run send-thank-you -- <filename> [exec-id-1] [exec-id-2] ...
+ *
+ * Examples:
+ *   npm run send-thank-you -- docs/customer-development/thank-you-notes/thank-you-candidates-2025-10-29.json
+ *   npm run send-thank-you -- docs/customer-development/thank-you-notes/thank-you-candidates-2025-10-29.json exec-123 exec-456
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const generate_engagement_emails_1 = require("./generate-engagement-emails");
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        console.error('❌ Error: Missing required argument: filename');
+        console.error('');
+        console.error('Usage: npm run send-thank-you -- <filename> [exec-id-1] [exec-id-2] ...');
+        console.error('');
+        console.error('Examples:');
+        console.error('  npm run send-thank-you -- docs/customer-development/thank-you-notes/thank-you-candidates-2025-10-29.json');
+        console.error('  npm run send-thank-you -- docs/customer-development/thank-you-notes/thank-you-candidates-2025-10-29.json exec-1760627251980-31qmjy5y4');
+        process.exit(1);
+    }
+    const filename = args[0];
+    const execIds = args.slice(1).filter(arg => arg.startsWith('exec-'));
+    if (execIds.length === 0) {
+        // Send to all pending candidates
+        console.log(`📧 Sending emails from: ${filename}`);
+        console.log(`🎯 Sending to ALL pending candidates`);
+        await (0, generate_engagement_emails_1.sendCustomerMail)(filename);
+    }
+    else if (execIds.length === 1) {
+        // Send to specific executive
+        console.log(`📧 Sending emails from: ${filename}`);
+        console.log(`🎯 Sending to executive: ${execIds[0]}`);
+        await (0, generate_engagement_emails_1.sendCustomerMail)(filename, execIds[0]);
+    }
+    else {
+        // Multiple executives - send to each one
+        console.log(`📧 Sending emails from: ${filename}`);
+        console.log(`🎯 Sending to ${execIds.length} executives: ${execIds.join(', ')}`);
+        for (const execId of execIds) {
+            console.log(`\n📧 Processing executive: ${execId}`);
+            await (0, generate_engagement_emails_1.sendCustomerMail)(filename, execId);
+        }
+    }
+}
+main().catch(error => {
+    console.error('❌ Error:', error);
+    process.exit(1);
+});