+
+
+ 📋 Summary
+{summary_escaped}
+
+
+
+
+ 📝 Full Transcript
+{transcript_html}
+ This is a test email from Chronicle Email Service.
If you received this, the email service is working correctly!
" + ) + + if success: + print("✅ Test email sent successfully") + else: + print("❌ Failed to send test email") + + except Exception as e: + print(f"❌ Error: {e}") + + +if __name__ == '__main__': + asyncio.run(main()) diff --git a/backends/advanced/src/advanced_omi_backend/plugins/email_summarizer/plugin.py b/backends/advanced/src/advanced_omi_backend/plugins/email_summarizer/plugin.py new file mode 100644 index 00000000..02521d29 --- /dev/null +++ b/backends/advanced/src/advanced_omi_backend/plugins/email_summarizer/plugin.py @@ -0,0 +1,288 @@ +""" +Email Summarizer Plugin for Chronicle. + +Automatically sends email summaries when conversations complete. +""" +import logging +from datetime import datetime +from typing import Any, Dict, List, Optional + +from advanced_omi_backend.database import get_database +from advanced_omi_backend.llm_client import async_generate + +from ..base import BasePlugin, PluginContext, PluginResult +from .email_service import SMTPEmailService +from .templates import format_html_email, format_text_email + +logger = logging.getLogger(__name__) + + +class EmailSummarizerPlugin(BasePlugin): + """ + Plugin for sending email summaries when conversations complete. + + Subscribes to conversation.complete events and: + 1. Retrieves user email from database + 2. Generates LLM summary of the conversation + 3. Formats HTML and plain text emails + 4. Sends email via SMTP + + Configuration (config/plugins.yml): + enabled: true + events: + - conversation.complete + condition: + type: always + smtp_host: smtp.gmail.com + smtp_port: 587 + smtp_username: ${SMTP_USERNAME} + smtp_password: ${SMTP_PASSWORD} + smtp_use_tls: true + from_email: noreply@chronicle.ai + from_name: Chronicle AI + subject_prefix: "Conversation Summary" + summary_max_sentences: 3 + """ + + SUPPORTED_ACCESS_LEVELS: List[str] = ['conversation'] + + def __init__(self, config: Dict[str, Any]): + """ + Initialize Email Summarizer plugin. + + Args: + config: Plugin configuration from config/plugins.yml + """ + super().__init__(config) + + self.subject_prefix = config.get('subject_prefix', 'Conversation Summary') + self.summary_max_sentences = config.get('summary_max_sentences', 3) + self.include_conversation_id = config.get('include_conversation_id', True) + self.include_duration = config.get('include_duration', True) + + # Email service will be initialized in initialize() + self.email_service: Optional[SMTPEmailService] = None + + # MongoDB database handle + self.db = None + + async def initialize(self): + """ + Initialize plugin resources. + + Sets up SMTP email service and MongoDB connection. + + Raises: + ValueError: If SMTP configuration is incomplete + Exception: If email service initialization fails + """ + if not self.enabled: + logger.info("Email Summarizer plugin is disabled, skipping initialization") + return + + logger.info("Initializing Email Summarizer plugin...") + + # Initialize SMTP email service + try: + smtp_config = { + 'smtp_host': self.config.get('smtp_host'), + 'smtp_port': self.config.get('smtp_port', 587), + 'smtp_username': self.config.get('smtp_username'), + 'smtp_password': self.config.get('smtp_password'), + 'smtp_use_tls': self.config.get('smtp_use_tls', True), + 'from_email': self.config.get('from_email'), + 'from_name': self.config.get('from_name', 'Chronicle AI'), + } + + self.email_service = SMTPEmailService(smtp_config) + + # Test SMTP connection + logger.info("Testing SMTP connectivity...") + if await self.email_service.test_connection(): + logger.info("✅ SMTP connection test successful") + else: + raise Exception("SMTP connection test failed") + + except Exception as e: + logger.error(f"Failed to initialize email service: {e}") + raise + + # Get MongoDB database handle + self.db = get_database() + logger.info("✅ Email Summarizer plugin initialized successfully") + + async def cleanup(self): + """Clean up plugin resources.""" + logger.info("Email Summarizer plugin cleanup complete") + + async def on_conversation_complete(self, context: PluginContext) -> Optional[PluginResult]: + """ + Send email summary when conversation completes. + + Args: + context: Plugin context with conversation data + - conversation: dict - Full conversation data + - transcript: str - Complete transcript + - duration: float - Conversation duration + - conversation_id: str - Conversation identifier + + Returns: + PluginResult with success status and message + """ + try: + logger.info(f"Processing conversation complete event for user: {context.user_id}") + + # Extract conversation data + conversation = context.data.get('conversation', {}) + transcript = context.data.get('transcript', '') + duration = context.data.get('duration', 0) + conversation_id = context.data.get('conversation_id', 'unknown') + created_at = conversation.get('created_at') + + # Validate transcript exists + if not transcript or transcript.strip() == '': + logger.warning(f"Empty transcript for conversation {conversation_id}, skipping email") + return PluginResult( + success=False, + message="Skipped: Empty transcript" + ) + + # Get user email from database + user_email = await self._get_user_email(context.user_id) + if not user_email: + logger.warning(f"No email found for user {context.user_id}, cannot send summary") + return PluginResult( + success=False, + message=f"No email configured for user {context.user_id}" + ) + + # Generate LLM summary + summary = await self._generate_summary(transcript) + + # Format email subject and body + subject = self._format_subject(created_at) + body_html = format_html_email( + summary=summary, + transcript=transcript, + conversation_id=conversation_id, + duration=duration, + created_at=created_at + ) + body_text = format_text_email( + summary=summary, + transcript=transcript, + conversation_id=conversation_id, + duration=duration, + created_at=created_at + ) + + # Send email + success = await self.email_service.send_email( + to_email=user_email, + subject=subject, + body_text=body_text, + body_html=body_html + ) + + if success: + logger.info(f"✅ Email summary sent to {user_email} for conversation {conversation_id}") + return PluginResult( + success=True, + message=f"Email sent to {user_email}", + data={'recipient': user_email, 'conversation_id': conversation_id} + ) + else: + logger.error(f"Failed to send email to {user_email}") + return PluginResult( + success=False, + message=f"Failed to send email to {user_email}" + ) + + except Exception as e: + logger.error(f"Error in email summarizer plugin: {e}", exc_info=True) + return PluginResult( + success=False, + message=f"Error: {str(e)}" + ) + + async def _get_user_email(self, user_id: str) -> Optional[str]: + """ + Get notification email from user. + + Args: + user_id: User identifier (MongoDB ObjectId) + + Returns: + User's notification_email, or None if not set + """ + try: + from bson import ObjectId + + # Query users collection + user = await self.db['users'].find_one({'_id': ObjectId(user_id)}) + + if not user: + logger.warning(f"User {user_id} not found") + return None + + notification_email = user.get('notification_email') + + if not notification_email: + logger.warning(f"User {user_id} has no notification_email set") + return None + + logger.debug(f"Sending notification to {notification_email} for user {user_id}") + return notification_email + + except Exception as e: + logger.error(f"Error fetching user email: {e}", exc_info=True) + return None + + async def _generate_summary(self, transcript: str) -> str: + """ + Generate LLM summary of the conversation. + + Args: + transcript: Full conversation transcript + + Returns: + Generated summary (2-3 sentences) + """ + try: + prompt = ( + f"Summarize this conversation in {self.summary_max_sentences} sentences or less. " + f"Focus on key points, main topics discussed, and any action items or decisions. " + f"Be concise and clear.\n\n" + f"Conversation:\n{transcript}" + ) + + logger.debug("Generating LLM summary...") + summary = await async_generate(prompt) + + if not summary or summary.strip() == '': + raise ValueError("LLM returned empty summary") + + logger.info("✅ LLM summary generated successfully") + return summary.strip() + + except Exception as e: + logger.error(f"Failed to generate LLM summary: {e}", exc_info=True) + # Fallback: return first 300 characters of transcript + logger.warning("Using fallback: truncated transcript") + return transcript[:300] + "..." if len(transcript) > 300 else transcript + + def _format_subject(self, created_at: Optional[datetime] = None) -> str: + """ + Format email subject line. + + Args: + created_at: Conversation creation timestamp + + Returns: + Formatted subject line + """ + if created_at: + date_str = created_at.strftime("%b %d, %Y at %I:%M %p") + return f"{self.subject_prefix} - {date_str}" + else: + return self.subject_prefix diff --git a/backends/advanced/src/advanced_omi_backend/plugins/email_summarizer/setup.py b/backends/advanced/src/advanced_omi_backend/plugins/email_summarizer/setup.py new file mode 100755 index 00000000..728ae607 --- /dev/null +++ b/backends/advanced/src/advanced_omi_backend/plugins/email_summarizer/setup.py @@ -0,0 +1,200 @@ +#!/usr/bin/env python3 +""" +Email Summarizer Plugin Setup Wizard + +Configures SMTP credentials and plugin settings. +Follows Chronicle's clean configuration architecture: +- Secrets → backends/advanced/.env +- Non-secret settings → plugins/email_summarizer/config.yml +- Orchestration → config/plugins.yml +""" + +import shutil +import sys +from datetime import datetime +from pathlib import Path + +import yaml +from dotenv import set_key +from rich.console import Console +from rich.prompt import Confirm + +# Add repo root to path for setup_utils import +project_root = Path(__file__).resolve().parents[6] +sys.path.insert(0, str(project_root)) + +from setup_utils import ( + prompt_with_existing_masked, + prompt_value +) + +console = Console() + + +def update_plugins_yml_orchestration(): + """ + Update config/plugins.yml with orchestration settings only. + Plugin-specific settings are in plugins/email_summarizer/config.yml. + This follows Chronicle's three-file configuration architecture. + """ + plugins_yml_path = project_root / "config" / "plugins.yml" + + # Load existing or create from template + if plugins_yml_path.exists(): + with open(plugins_yml_path, 'r') as f: + config = yaml.safe_load(f) or {} + else: + # Copy from template + template_path = project_root / "config" / "plugins.yml.template" + if template_path.exists(): + with open(template_path, 'r') as f: + config = yaml.safe_load(f) or {} + else: + config = {'plugins': {}} + + # Ensure structure exists + if 'plugins' not in config: + config['plugins'] = {} + + # Only orchestration settings in config/plugins.yml + # Plugin-specific settings are in plugins/email_summarizer/config.yml + plugin_config = { + 'enabled': False, # Let user enable manually or prompt + 'events': ['conversation.complete'], + 'condition': {'type': 'always'} + } + + # Update or create plugin entry + config['plugins']['email_summarizer'] = plugin_config + + # Backup existing file + if plugins_yml_path.exists(): + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + backup_path = plugins_yml_path.parent / f"plugins.yml.backup.{timestamp}" + shutil.copy(plugins_yml_path, backup_path) + console.print(f"[dim]Backed up existing plugins.yml to {backup_path.name}[/dim]") + + # Write updated config + plugins_yml_path.parent.mkdir(parents=True, exist_ok=True) + with open(plugins_yml_path, 'w') as f: + yaml.dump(config, f, default_flow_style=False, sort_keys=False) + + console.print("[green]✅ Updated config/plugins.yml (orchestration only)[/green]") + + return plugins_yml_path + + +def main(): + """Interactive setup for Email Summarizer plugin""" + console.print("\n📧 [bold cyan]Email Summarizer Plugin Setup[/bold cyan]") + console.print("This plugin sends email summaries when conversations complete.\n") + + # Path to main backend .env file + env_path = str(project_root / "backends" / "advanced" / ".env") + + # SMTP Configuration + console.print("[bold]SMTP Configuration[/bold]") + console.print("[dim]For Gmail: Use App Password (Settings > Security > 2FA > App Passwords)[/dim]\n") + + smtp_host = prompt_with_existing_masked( + prompt_text="SMTP Host", + env_file_path=env_path, + env_key="SMTP_HOST", + placeholders=['your-smtp-host-here'], + is_password=False, + default="smtp.gmail.com" + ) + + smtp_port = prompt_value("SMTP Port", default="587") + + smtp_username = prompt_with_existing_masked( + prompt_text="SMTP Username (your email)", + env_file_path=env_path, + env_key="SMTP_USERNAME", + placeholders=['your-email@example.com'], + is_password=False + ) + + smtp_password = prompt_with_existing_masked( + prompt_text="SMTP Password (App Password)", + env_file_path=env_path, + env_key="SMTP_PASSWORD", + placeholders=['your-password-here', 'your-app-password-here'], + is_password=True # Shows masked existing value + ) + + # Remove spaces from app password (Google adds spaces when copying) + smtp_password = smtp_password.replace(" ", "") + + smtp_use_tls = prompt_value("Use TLS? (true/false)", default="true") + + # Email sender configuration + from_email = prompt_with_existing_masked( + prompt_text="From Email", + env_file_path=env_path, + env_key="FROM_EMAIL", + placeholders=['noreply@example.com'], + is_password=False, + default=smtp_username # Default to SMTP username + ) + + from_name = prompt_value("From Name", default="Chronicle AI") + + # Save secrets to .env + console.print("\n💾 [bold]Saving credentials to .env...[/bold]") + + set_key(env_path, "SMTP_HOST", smtp_host) + set_key(env_path, "SMTP_PORT", smtp_port) + set_key(env_path, "SMTP_USERNAME", smtp_username) + set_key(env_path, "SMTP_PASSWORD", smtp_password) + set_key(env_path, "SMTP_USE_TLS", smtp_use_tls) + set_key(env_path, "FROM_EMAIL", from_email) + set_key(env_path, "FROM_NAME", from_name) + + console.print("[green]✅ SMTP credentials saved to backends/advanced/.env[/green]") + + # Auto-update plugins.yml with orchestration settings only + console.print("\n📝 [bold]Updating plugin configuration...[/bold]") + plugins_yml_path = update_plugins_yml_orchestration() + + # Prompt to enable plugin + enable_now = Confirm.ask("\nEnable email_summarizer plugin now?", default=True) + if enable_now: + with open(plugins_yml_path, 'r') as f: + config = yaml.safe_load(f) + config['plugins']['email_summarizer']['enabled'] = True + with open(plugins_yml_path, 'w') as f: + yaml.dump(config, f, default_flow_style=False, sort_keys=False) + console.print("[green]✅ Plugin enabled in config/plugins.yml[/green]") + + console.print("\n[bold cyan]✅ Email Summarizer configured successfully![/bold cyan]") + console.print("\n[bold]Configuration saved to:[/bold]") + console.print(" • [green]backends/advanced/.env[/green] - SMTP credentials (secrets)") + console.print(" • [green]config/plugins.yml[/green] - Plugin orchestration (enabled, events)") + console.print(" • [green]plugins/email_summarizer/config.yml[/green] - Plugin settings (already configured)") + console.print() + + if not enable_now: + console.print("[bold]To enable later:[/bold]") + console.print(" Edit config/plugins.yml and set: enabled: true") + console.print() + + console.print("[bold]Restart backend to apply:[/bold]") + console.print(" [dim]cd backends/advanced && docker compose restart[/dim]") + console.print() + console.print("[yellow]⚠️ SECURITY: Never commit secrets to git![/yellow]") + console.print("[yellow] • Secrets go in backends/advanced/.env (gitignored)[/yellow]") + console.print("[yellow] • Config files use ${ENV_VAR} references only[/yellow]") + + +if __name__ == '__main__': + try: + main() + except KeyboardInterrupt: + console.print("\n[yellow]Setup cancelled by user[/yellow]") + sys.exit(1) + except Exception as e: + console.print(f"\n[red]Error during setup: {e}[/red]") + import traceback + traceback.print_exc() + sys.exit(1) diff --git a/backends/advanced/src/advanced_omi_backend/plugins/email_summarizer/templates.py b/backends/advanced/src/advanced_omi_backend/plugins/email_summarizer/templates.py new file mode 100644 index 00000000..9f99e5cb --- /dev/null +++ b/backends/advanced/src/advanced_omi_backend/plugins/email_summarizer/templates.py @@ -0,0 +1,258 @@ +""" +Email templates for the Email Summarizer plugin. + +Provides HTML and plain text email templates. +""" +import html +from datetime import datetime +from typing import Optional + + +def format_duration(seconds: float) -> str: + """ + Format duration in seconds to human-readable format. + + Args: + seconds: Duration in seconds + + Returns: + Formatted duration (e.g., "5m 30s", "1h 15m") + """ + hours = int(seconds // 3600) + minutes = int((seconds % 3600) // 60) + secs = int(seconds % 60) + + if hours > 0: + return f"{hours}h {minutes}m" + elif minutes > 0: + return f"{minutes}m {secs}s" + else: + return f"{secs}s" + + +def format_html_email( + summary: str, + transcript: str, + conversation_id: str, + duration: float, + created_at: Optional[datetime] = None +) -> str: + """ + Format HTML email template. + + Args: + summary: LLM-generated summary + transcript: Full conversation transcript + conversation_id: Conversation identifier + duration: Conversation duration in seconds + created_at: Conversation creation timestamp + + Returns: + HTML email body + """ + formatted_duration = format_duration(duration) + date_str = created_at.strftime("%B %d, %Y at %I:%M %p") if created_at else "N/A" + + # Escape HTML to prevent XSS attacks + summary_escaped = html.escape(summary, quote=True) + transcript_escaped = html.escape(transcript, quote=True) + + # Format transcript with line breaks (after escaping) + transcript_html = transcript_escaped.replace('\n', '{summary_escaped}
+