fraim-framework 2.0.34 → 2.0.36

package/registry/scripts/newsletter-helpers.ts

@@ -0,0 +1,777 @@
+#!/usr/bin/env tsx
+
+/**
+ * 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).
+ */
+
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from 'fs';
+import { MongoClient } from 'mongodb';
+import { join } from 'path';
+
+// Self-contained utility functions (no FRAIM internal imports)
+function determineDatabaseName(): string {
+  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 'fraim_ppe';
+  }
+  // Default to production
+  return process.env.MONGO_DB_NAME || 'fraim_prod';
+}
+
+function determineSchema(branchName: string): string {
+  if (branchName.includes('ppe') || branchName.includes('staging')) return 'ppe';
+  return 'prod';
+}
+
+function getCurrentGitBranch(): string {
+  try {
+    return execSync('git branch --show-current', { encoding: 'utf8' }).trim();
+  } catch (error) {
+    return 'master';
+  }
+}
+
+interface FraimConfig {
+  persona: { name: string; displayNamePattern: string; emailSignature: string };
+  git: { repoOwner: string; repoName: string };
+  database: { identityCollection: string; executiveCollection: string };
+  marketing: { websiteUrl?: string; chatUrl?: 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;
+}
+
+// Load configuration
+const config = loadClientConfig();
+
+const fraimConfig = {
+  repoOwner: config.git.repoOwner || 'mathursrus',
+  repoName: config.git.repoName || 'fraim-repo',
+  personaName: config.persona.name,
+  identityCollection: config.database?.identityCollection || 'Identity',
+  executiveCollection: config.database?.executiveCollection || 'Executive',
+  defaultEmail: getEnvOr(['FRAIM_DEFAULT_EMAIL'], 'agent@example.com'),
+  prodDefaultEmail: getEnvOr(['PROD_FRAIM_DEFAULT_EMAIL'], 'agent@example.com'),
+  defaultAccessToken: getEnvOr(['FRAIM_DEFAULT_ACCESS_TOKEN'], ''),
+  defaultRefreshToken: getEnvOr(['FRAIM_DEFAULT_REFRESH_TOKEN'], ''),
+  prodAccessToken: getEnvOr(['PROD_FRAIM_DEFAULT_ACCESS_TOKEN'], ''),
+  prodRefreshToken: getEnvOr(['PROD_FRAIM_DEFAULT_REFRESH_TOKEN'], ''),
+  defaultOAuthClientId: getEnvOr(['FRAIM_DEFAULT_OAUTH_CLIENT_ID'], ''),
+  defaultOAuthClientSecret: getEnvOr(['FRAIM_DEFAULT_OAUTH_CLIENT_SECRET'], ''),
+  prodOAuthClientId: getEnvOr(['PROD_FRAIM_DEFAULT_OAUTH_CLIENT_ID'], ''),
+  prodOAuthClientSecret: getEnvOr(['PROD_FRAIM_DEFAULT_OAUTH_CLIENT_SECRET'], ''),
+  webAppUrl: config.marketing?.websiteUrl || getEnvOr(['FRAIM_WEB_APP_URL'], 'http://localhost:3000'),
+  chatUrl: config.marketing?.chatUrl || getEnvOr(['FRAIM_CHAT_URL'], ''),
+};
+
+// Helper functions for database operations
+function getProductionDatabase() {
+  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');
+  }
+  return new MongoClient(mongoUrl);
+}
+
+/**
+ * Get database name, defaulting to production
+ */
+function getDatabaseName(): string {
+  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 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: string): string {
+  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 = determineSchema(getCurrentGitBranch());
+    return `${schema}_${baseName}`;
+  }
+  // Default to prod schema
+  return `prod_${baseName}`;
+}
+// Reuse existing email infrastructure - implemented inline to avoid FRAIM internal imports
+
+/**
+ * Find executive by email in database (defaults to production)
+ */
+async function findExecutiveByEmail(email: string): Promise<Executive | null> {
+  const client = getProductionDatabase();
+  try {
+    await client.connect();
+    const dbName = getDatabaseName();
+    const db = client.db(dbName);
+    const executive = await db.collection(getCollectionName('Executive')).findOne({ email: email.toLowerCase() });
+    return executive as unknown as Executive;
+  } finally {
+    await client.close();
+  }
+}
+
+/**
+ * Get the persona email for an executive from the identity collection
+ */
+async function getPersonaEmailForExecutive(executiveId: string): Promise<string> {
+  const { MongoClient } = await import('mongodb');
+  const mongoUrl = process.env.PROD_MONGO_DATABASE_URL || process.env.MONGO_DATABASE_URL;
+  if (!mongoUrl) {
+    console.warn(`⚠️  PROD_MONGO_DATABASE_URL not set, using default ${fraimConfig.personaName} email`);
+    return fraimConfig.defaultEmail;
+  }
+
+  const client = new MongoClient(mongoUrl);
+  try {
+    await client.connect();
+    const dbName = getDatabaseName();
+    const db = client.db(dbName);
+    const collectionName = getCollectionName(fraimConfig.identityCollection);
+
+    // Query the identity collection (defaults to prod)
+    let identity = await db.collection(collectionName).findOne({
+      executive_id: executiveId,
+      status: 'active'
+    });
+
+    if (!identity) {
+      identity = await db.collection(collectionName).findOne({
+        executive_id: executiveId
+      });
+    }
+
+    if (identity && identity.email) {
+      return identity.email;
+    }
+
+    return fraimConfig.defaultEmail;
+  } catch (error) {
+    console.warn(`⚠️  Could not get ${fraimConfig.personaName} email for executive ${executiveId}:`, error);
+    return fraimConfig.defaultEmail;
+  } finally {
+    await client.close();
+  }
+}
+
+interface ResolvedIssue {
+  number: number;
+  title: string;
+  body: string;
+  closedAt: string;
+  author: {
+    login: string;
+  };
+  labels: Array<{
+    name: string;
+  }>;
+}
+
+interface Executive {
+  id?: string;
+  email: string;
+  name: string;
+}
+
+interface PotentialCustomer {
+  email: string;
+  name: string;
+  addedDate?: string;
+  source?: string; // e.g., "linkedin", "referral", "website", etc.
+}
+
+interface Newsletter {
+  metadata: {
+    generatedOn: string;
+    weekStart: string;
+    weekEnd: string;
+    totalIssues: number;
+    [key: string]: any;
+  };
+  content: {
+    weekTitle: string;
+    [key: string]: any;
+  };
+}
+
+/**
+ * Get the latest date from existing newsletter files
+ * Returns the most recent date when newsletter was sent, or null if no files exist
+ */
+export function getLatestNewsletterDate(): string | null {
+  const newslettersDir = 'docs/customer-development/newsletters';
+  if (!existsSync(newslettersDir)) {
+    return null;
+  }
+
+  const files = 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: string[] = [];
+  for (const file of files) {
+    const dateMatch = file.match(/newsletter-(\d{4}-\d{2}-\d{2})\.json/);
+    if (dateMatch) {
+      const filePath = 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
+ */
+export async function getResolvedIssuesForNewsletter(date?: string): Promise<ResolvedIssue[]> {
+  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=${fraimConfig.repoOwner}/${fraimConfig.repoName} --state=closed --closed=">${date}" --json number,title,body,labels,closedAt,author --limit 100`;
+  const output = execSync(command, { encoding: 'utf-8' });
+  const issues: ResolvedIssue[] = JSON.parse(output);
+
+  console.log(`✅ Found ${issues.length} resolved issues`);
+
+  return issues;
+}
+
+/**
+ * Get all active executives (defaults to production database)
+ * DETERMINISTIC: Just fetches executive list
+ */
+export async function getAllActiveExecutives(): Promise<Executive[]> {
+  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 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 as unknown as Executive[];
+    }
+
+    return executives as unknown as Executive[];
+  } finally {
+    await client.close();
+  }
+}
+
+/**
+ * Get all potential customers (leads who have expressed interest)
+ * DETERMINISTIC: Just fetches potential customer list from JSON file
+ */
+export function getPotentialCustomers(): PotentialCustomer[] {
+  const potentialCustomersPath = join(process.cwd(), 'docs', 'customer-development', 'potential-customers.json');
+
+  if (!existsSync(potentialCustomersPath)) {
+    return [];
+  }
+
+  try {
+    const content = readFileSync(potentialCustomersPath, 'utf-8');
+    return JSON.parse(content) as PotentialCustomer[];
+  } catch (error) {
+    console.error('❌ Error reading potential customers file:', error);
+    return [];
+  }
+}
+/**
+ * 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
+ */
+export async function sendNewsletterToExecutives(
+  newsletterPath: string,
+  filterEmails?: string[],
+  filterExecIds?: string[],
+  includePotentialCustomers: boolean = true,
+  showOnly: boolean = false,
+  includeExecutives: boolean = true
+): Promise<void> {
+  console.log(`📧 Sending newsletter from: ${newsletterPath}`);
+
+  if (!existsSync(newsletterPath)) {
+    throw new Error(`Newsletter file not found: ${newsletterPath}`);
+  }
+
+  const newsletter: Newsletter = JSON.parse(readFileSync(newsletterPath, 'utf-8'));
+  const htmlPath = newsletterPath.replace('.json', '.html');
+
+  if (!existsSync(htmlPath)) {
+    throw new Error(`Newsletter HTML not found: ${htmlPath}. Generate it first.`);
+  }
+
+  const html = readFileSync(htmlPath, 'utf-8');
+  let executives: any[] = [];
+
+  // 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: PotentialCustomer[] = [];
+  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 getPersonaEmailForExecutive(exec.id)
+          : fraimConfig.defaultEmail;
+        const fromDisplayName = `${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 = fraimConfig.prodDefaultEmail || 'agent@example.com';
+      const defaultDisplayName = `${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 getPersonaEmailForExecutive(executive.id)
+          : fraimConfig.defaultEmail;
+
+        const fromDisplayName = `${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 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 = fraimConfig.prodDefaultEmail || 'agent@example.com';
+  const defaultDisplayName = `${fraimConfig.personaName} - Your AI Executive Assistant`;
+  const defaultAccessToken = fraimConfig.prodAccessToken || '';
+  const defaultRefreshToken = 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?: string): Promise<{ access_token?: string; refresh_token?: string } | null> {
+  if (!executiveId) return null;
+
+  const mongoUrl = process.env.PROD_MONGO_DATABASE_URL || process.env.MONGO_DATABASE_URL;
+  if (!mongoUrl) return null;
+
+  const client = new MongoClient(mongoUrl);
+  try {
+    await client.connect();
+    const dbName = getDatabaseName();
+    const db = client.db(dbName);
+    const collectionName = getCollectionName(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: Newsletter): string {
+  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: any, index: number) => {
+      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: any) => {
+      text += `• ${f.title}: ${f.description}\n`;
+    });
+    text += `\n`;
+  }
+
+  if (content.improvements && content.improvements.length > 0) {
+    text += `IMPROVEMENTS:\n`;
+    content.improvements.forEach((i: any) => {
+      text += `• ${i.title}: ${i.description}\n`;
+    });
+    text += `\n`;
+  }
+
+  if (content.bugFixes && content.bugFixes.length > 0) {
+    text += `BUG FIXES:\n`;
+    content.bugFixes.forEach((b: any) => {
+      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${fraimConfig.personaName}\nYour AI Executive Assistant\n\n`;
+  text += `Visit: ${fraimConfig.webAppUrl ? `${fraimConfig.webAppUrl}/wellness/${fraimConfig.personaName.toLowerCase()}` : '#'}\n`;
+
+  return text;
+}
+
+/**
+ * Send email via Gmail API (reuses existing pattern)
+ */
+async function sendEmailViaGmail(
+  params: {
+    to: string;
+    subject: string;
+    plainTextBody: string;
+    htmlBody: string;
+    fromEmail: string;
+    fromDisplayName: string;
+  },
+  executive?: any,
+  personaTokens?: { access_token?: string; refresh_token?: string } | null
+): Promise<void> {
+  const { to, subject, plainTextBody, htmlBody, fromEmail, fromDisplayName } = params;
+
+  let accessToken: string;
+  let refreshToken: string;
+  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 = fraimConfig.prodRefreshToken || '';
+    if (prodRefreshToken && refreshToken === prodRefreshToken) {
+      isProdToken = true;
+    }
+  } else if (executive?.personaAccessToken && executive?.personaRefreshToken) {
+    accessToken = executive.personaAccessToken;
+    refreshToken = executive.personaRefreshToken;
+  } else {
+    accessToken = fraimConfig.defaultAccessToken || '';
+    refreshToken = fraimConfig.defaultRefreshToken || '';
+
+    if (!accessToken || !refreshToken) {
+      throw new Error(`${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`,
+    ``,
+    plainTextBody,
+    ``,
+    `--${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
+        ? fraimConfig.prodOAuthClientId
+        : fraimConfig.defaultOAuthClientId;
+      const clientSecret = isProdToken
+        ? fraimConfig.prodOAuthClientSecret
+        : 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() as any;
+
+      // 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}`);
+  }
+}