@realtimex/email-automator 2.20.0 → 2.21.0

package/api/src/config/index.ts

@@ -48,10 +48,10 @@ function parseArgs(args: string[]): { port: number | null, noUi: boolean, rename
             port = p;
         }
     }
-    
+
     const noUi = args.includes('--no-ui');
     const rename = args.includes('--rename');
-    
+
     return { port, noUi, rename };
 }
 
@@ -120,12 +120,13 @@ export const config = {
 export function validateConfig(): { valid: boolean; errors: string[] } {
     const errors: string[] = [];
 
-    if (!config.supabase.url) {
-        errors.push('SUPABASE_URL is required');
-    }
-    if (!config.supabase.anonKey) {
-        errors.push('SUPABASE_ANON_KEY is required');
-    }
+    // For BYOK (Bring Your Own Key) apps, .env is optional
+    // if (!config.supabase.url) {
+    //     errors.push('SUPABASE_URL is required');
+    // }
+    // if (!config.supabase.anonKey) {
+    //     errors.push('SUPABASE_ANON_KEY is required');
+    // }
     if (config.isProduction && config.security.jwtSecret === 'dev-secret-change-in-production') {
         errors.push('JWT_SECRET must be set in production');
     }

package/api/src/routes/drafts.ts

@@ -0,0 +1,242 @@
+import { Router } from 'express';
+import { asyncHandler, NotFoundError } from '../middleware/errorHandler.js';
+import { authMiddleware } from '../middleware/auth.js';
+import { apiRateLimit } from '../middleware/rateLimit.js';
+import { getGmailService } from '../services/gmail.js';
+import { getMicrosoftService } from '../services/microsoft.js';
+import { createLogger } from '../utils/logger.js';
+
+const router = Router();
+const logger = createLogger('DraftsRoutes');
+
+// List drafts
+router.get('/',
+    apiRateLimit,
+    authMiddleware,
+    asyncHandler(async (req, res) => {
+        const {
+            limit = '100',
+            offset = '0',
+            status = 'pending',
+            account_id
+        } = req.query;
+
+        let query = req.supabase!
+            .from('emails')
+            .select(`
+                id, subject, sender, recipient, date,
+                draft_status, draft_created_at, draft_content, ai_analysis,
+                account_id, external_id, draft_id,
+                email_accounts!inner(id, user_id, email_address, provider)
+            `, { count: 'exact' })
+            .eq('email_accounts.user_id', req.user!.id)
+            .eq('draft_status', status)
+            .order('draft_created_at', { ascending: false })
+            .range(
+                parseInt(offset as string, 10),
+                parseInt(offset as string, 10) + parseInt(limit as string, 10) - 1
+            );
+
+        if (account_id) {
+            query = query.eq('account_id', account_id);
+        }
+
+        const { data, error, count } = await query;
+
+        if (error) throw error;
+
+        // Debug: Log draft content structure for first few emails
+        if (data && data.length > 0) {
+            logger.info(`Found ${data.length} drafts with draft_status='${status}'`);
+            data.slice(0, 3).forEach((email, idx) => {
+                const aiAnalysis = email.ai_analysis as any;
+                logger.debug(`Draft ${idx + 1} content check`, {
+                    emailId: email.id,
+                    hasDraftContent: !!email.draft_content,
+                    hasAiAnalysis: !!email.ai_analysis,
+                    aiAnalysisKeys: email.ai_analysis ? Object.keys(email.ai_analysis) : [],
+                    hasDraftResponse: !!aiAnalysis?.draft_response,
+                    hasDraftContentInAi: !!aiAnalysis?.draft_content,
+                    draftResponseLength: aiAnalysis?.draft_response?.length || 0,
+                    draftContentLength: aiAnalysis?.draft_content?.length || 0,
+                    persistedDraftLength: email.draft_content?.length || 0
+                });
+            });
+        }
+
+        // Filter out drafts without content (these can't be sent)
+        const validDrafts = (data || []).filter(email => {
+            const aiAnalysis = email.ai_analysis as any;
+            const hasContent = email.draft_content || aiAnalysis?.draft_response || aiAnalysis?.draft_content;
+
+            if (!hasContent) {
+                logger.debug('Draft without content filtered out', {
+                    emailId: email.id,
+                    subject: email.subject,
+                    hasAiAnalysis: !!email.ai_analysis,
+                    aiAnalysisKeys: email.ai_analysis ? Object.keys(email.ai_analysis) : []
+                });
+            }
+
+            return hasContent;
+        });
+
+        logger.info(`Returning ${validDrafts.length} valid drafts out of ${data?.length || 0} total`);
+
+        res.json({
+            drafts: validDrafts,
+            total: validDrafts.length
+        });
+    })
+);
+
+// Send draft
+router.post('/:emailId/send',
+    apiRateLimit,
+    authMiddleware,
+    asyncHandler(async (req, res) => {
+        const { emailId } = req.params;
+        const userId = req.user!.id;
+
+        // Fetch email with account info and SECURITY CHECK in query
+        const { data: email, error } = await req.supabase!
+            .from('emails')
+            .select('*, email_accounts!inner(*)')
+            .eq('id', emailId)
+            .eq('email_accounts.user_id', userId) // Security: Ensure user owns the account
+            .single();
+
+        if (error || !email) {
+            throw new NotFoundError('Email');
+        }
+
+        // if (email.email_accounts.user_id !== userId) {
+        //     throw new NotFoundError('Email');
+        // }
+
+        const account = email.email_accounts;
+        // CRITICAL: Priority Definition
+        // 1. draft_content (User edits / Persisted draft) overrides everything
+        // 2. ai_analysis.draft_response (EmailAnalysisSchema)
+        // 3. ai_analysis.draft_content (ContextAwareAnalysisSchema)
+        const aiAnalysis = email.ai_analysis as any;
+        const draftContent = email.draft_content ?? aiAnalysis?.draft_response ?? aiAnalysis?.draft_content;
+
+        logger.debug('Sending draft', {
+            emailId,
+            hasDraftContent: !!email.draft_content,
+            hasAiDraftResponse: !!aiAnalysis?.draft_response,
+            hasAiDraftContent: !!aiAnalysis?.draft_content,
+            contentLength: draftContent?.length || 0,
+            analysisKeys: email.ai_analysis ? Object.keys(email.ai_analysis) : []
+        });
+
+        if (!draftContent) {
+            logger.warn('Draft content missing', {
+                emailId,
+                draft_content: email.draft_content,
+                ai_draft_response: aiAnalysis?.draft_response,
+                ai_draft_content: aiAnalysis?.draft_content,
+                analysisKeys: email.ai_analysis ? Object.keys(email.ai_analysis) : []
+            });
+            return res.status(400).json({
+                error: 'No draft content found for this email',
+                details: 'No draft found in draft_content, ai_analysis.draft_response, or ai_analysis.draft_content fields'
+            });
+        }
+
+        let sentMessageId: string | null = null;
+        const replyToId = email.external_id;
+
+        try {
+            // Priority: Send existing draft if ID exists (cleaner, preserves original draft object)
+            if (email.draft_id) {
+                if (account.provider === 'gmail') {
+                    const gmailService = getGmailService();
+                    sentMessageId = await gmailService.sendDraft(account, email.draft_id);
+                } else if (account.provider === 'outlook') {
+                    const microsoftService = getMicrosoftService();
+                    sentMessageId = await microsoftService.sendDraft(account, email.draft_id);
+                }
+                logger.info('Sent existing draft', { draftId: email.draft_id, sentMessageId });
+            }
+            // Fallback: Create new reply using content (if draft object was deleted externally or not saved)
+            else {
+                if (account.provider === 'gmail') {
+                    const gmailService = getGmailService();
+                    // Send reply
+                    sentMessageId = await gmailService.sendReply(
+                        account,
+                        replyToId,
+                        draftContent,
+                        email.subject || ''
+                    );
+                } else if (account.provider === 'outlook') {
+                    const microsoftService = getMicrosoftService();
+                    sentMessageId = await microsoftService.sendReply(
+                        account,
+                        replyToId,
+                        draftContent
+                    );
+                }
+                logger.info('Sent draft via reply', { sentMessageId });
+            }
+
+            // Update email status
+            await req.supabase!
+                .from('emails')
+                .update({
+                    draft_status: 'sent',
+                    draft_sent_at: new Date().toISOString(),
+                    action_taken: 'reply', // Legacy compatibility
+                    actions_taken: ['reply']
+                })
+                .eq('id', emailId);
+
+            res.json({ success: true, messageId: sentMessageId || email.draft_id });
+
+        } catch (error: any) {
+            logger.error('Failed to send draft', error, { emailId });
+            res.status(500).json({
+                error: 'Failed to send draft',
+                details: error.message
+            });
+        }
+    })
+);
+
+// Dismiss draft
+router.post('/:emailId/dismiss',
+    apiRateLimit,
+    authMiddleware,
+    asyncHandler(async (req, res) => {
+        const { emailId } = req.params;
+
+        // Verify ownership
+        const { data: email, error } = await req.supabase!
+            .from('emails')
+            .select('id, email_accounts!inner(user_id)')
+            .eq('id', emailId)
+            .eq('email_accounts.user_id', req.user!.id)
+            .single();
+
+        if (error || !email) {
+            throw new NotFoundError('Email');
+        }
+
+        // Update status to dismissed
+        const { error: updateError } = await req.supabase!
+            .from('emails')
+            .update({
+                draft_status: 'dismissed',
+                draft_dismissed_at: new Date().toISOString()
+            })
+            .eq('id', emailId);
+
+        if (updateError) throw updateError;
+
+        res.json({ success: true });
+    })
+);
+
+export default router;

package/api/src/routes/index.ts

@@ -9,6 +9,7 @@ import emailsRoutes from './emails.js';
 import migrateRoutes from './migrate.js';
 import sdkRoutes from './sdk.js';
 import rulePacksRoutes from './rulePacks.js';
+import draftsRoutes from './drafts.js';
 
 const router = Router();
 
@@ -22,5 +23,6 @@ router.use('/emails', emailsRoutes);
 router.use('/migrate', migrateRoutes);
 router.use('/sdk', sdkRoutes);
 router.use('/rule-packs', rulePacksRoutes);
+router.use('/drafts', draftsRoutes);
 
 export default router;

package/api/src/services/gmail.ts

@@ -413,24 +413,87 @@ export class GmailService {
         }
     }
 
-    async sendDraft(account: EmailAccount, draftId: string): Promise<void> {
+    async sendDraft(account: EmailAccount, draftId: string): Promise<string> {
         const gmail = await this.getAuthenticatedClient(account);
 
         try {
-            await gmail.users.drafts.send({
+            const response = await gmail.users.drafts.send({
                 userId: 'me',
                 requestBody: {
                     id: draftId,
                 },
             });
 
-            logger.info('Draft sent successfully', { draftId });
+            const sentMessageId = response.data.id || draftId; // Fallback to draftId if no DB ID returned (rare)
+            logger.info('Draft sent successfully', { draftId, sentMessageId });
+            return sentMessageId;
         } catch (error) {
             logger.error('Gmail API Error sending draft', error);
             throw error;
         }
     }
 
+    /**
+     * Send a reply to a thread (used for sending drafts directly without creating a draft object first)
+     */
+    async sendReply(
+        account: EmailAccount,
+        originalMessageId: string,
+        replyContent: string,
+        subject: string
+    ): Promise<string> {
+        const gmail = await this.getAuthenticatedClient(account);
+
+        //Fetch original to get threadId and Message-ID
+        const original = await gmail.users.messages.get({ userId: 'me', id: originalMessageId });
+        const headers = original.data.payload?.headers || [];
+        const getHeader = (name: string) => headers.find(h => h.name?.toLowerCase() === name.toLowerCase())?.value || '';
+
+        const toAddress = getHeader('From');
+        const originalMsgId = getHeader('Message-ID');
+        const threadId = original.data.threadId;
+
+        // Threading headers
+        const replyHeaders = [];
+        if (originalMsgId) {
+            replyHeaders.push(`In-Reply-To: ${originalMsgId}`);
+            replyHeaders.push(`References: ${originalMsgId}`);
+        }
+
+        const rawMessage = [
+            `To: ${toAddress}`,
+            `Subject: ${subject}`,
+            ...replyHeaders,
+            'MIME-Version: 1.0',
+            'Content-Type: text/plain; charset="UTF-8"',
+            '',
+            replyContent,
+        ].join('\r\n');
+
+        const encodedMessage = Buffer.from(rawMessage)
+            .toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+
+        try {
+            const result = await gmail.users.messages.send({
+                userId: 'me',
+                requestBody: {
+                    threadId,
+                    raw: encodedMessage,
+                },
+            });
+
+            const messageId = result.data.id || 'unknown';
+            logger.info('Reply sent successfully', { messageId, threadId });
+            return messageId;
+        } catch (error) {
+            logger.error('Gmail API Error sending reply', error);
+            throw error;
+        }
+    }
+
 
     async addLabel(account: EmailAccount, messageId: string, labelIds: string[]): Promise<void> {
         const gmail = await this.getAuthenticatedClient(account);

package/api/src/services/intelligence.ts

@@ -84,6 +84,9 @@ export interface EmailContext {
     userPreferences?: {
         autoTrashSpam?: boolean;
         smartDrafts?: boolean;
+        categoryPatterns?: Record<string, string>;
+        vipSenders?: string[];
+        preferredLength?: number;
     };
 }
 
@@ -121,8 +124,58 @@ export class IntelligenceService {
         if (context.metadata?.autoSubmitted && context.metadata.autoSubmitted !== 'no') metadataSignals.push(`- Auto-Submitted: ${context.metadata.autoSubmitted}`);
         if (context.metadata?.importance) metadataSignals.push(`- Priority: ${context.metadata.importance}`);
 
+        // Adaptive Learning Signals
+        if (context.userPreferences?.vipSenders?.includes(context.sender)) {
+            metadataSignals.push('- SENDER IS VIP (High Priority Required)');
+        }
+
+        const senderDomain = context.sender.split('@')[1];
+        if (senderDomain && context.userPreferences?.categoryPatterns?.[senderDomain]) {
+            const learnedCategory = context.userPreferences.categoryPatterns[senderDomain];
+            metadataSignals.push(`- LEARNED PATTERN: Sender domain '${senderDomain}' is strictly category '${learnedCategory}'`);
+        }
+
         const systemPrompt = `You are an AI Email Assistant. Analyze the email and return structured JSON.
-Definitions for Categories: spam, newsletter, promotional, transactional, social, support, client, internal, personal, other.
+
+CATEGORY DEFINITIONS:
+- spam: Unwanted/unsolicited bulk email, phishing attempts
+- newsletter: Recurring subscription content (weekly digests, company updates) - check for List-Unsubscribe
+- news: Breaking news alerts, timely notifications (Google Alerts, news feeds)
+- promotional: Marketing emails, sales offers, advertisements
+- transactional: Receipts, confirmations, order updates, account notifications
+- social: Social media notifications (LinkedIn, Twitter, Facebook)
+- support: Customer service, help desk, support tickets
+- client: Business correspondence from clients/customers (High Importance)
+- internal: Company-internal communications (colleagues, HR, IT)
+- personal: Personal correspondence from friends/family
+- notification: Platform alerts/notifications (Github, Linear, etc) - distinct from social
+- other: Anything that doesn't fit above categories
+
+CRITICAL RULES:
+1. Platform notifications (linkedin.com, github.com) are ALWAYS "notification" or "social", never "personal"
+2. Emails from noreply@, no-reply@ are likely "transactional" or "notification"
+3. Weekly/Monthly digests are "newsletter"
+4. If "List-Unsubscribe" header is present, it is likely "newsletter" or "promotional"
+5. Follow "LEARNED PATTERN" signals strictly if present
+6. VIP Senders must be "High" priority unless irrelevant (e.g. OOO auto-reply)
+
+FEW-SHOT EXAMPLES:
+
+Example 1: LinkedIn Connection
+Subject: Canh Le wants to connect
+From: messages-noreply@linkedin.com
+Signals: [List-Unsubscribe]
+-> { "category": "social", "is_useless": true, "priority": "Low", "suggested_actions": ["archive"] }
+
+Example 2: Cold Sales
+Subject: Boost your productivity
+From: sales@unknown-vendor.com
+-> { "category": "spam", "is_useless": true, "priority": "Low", "suggested_actions": ["delete"] }
+
+Example 3: Client Question
+Subject: Question about the contract
+From: client@valued-customer.com
+-> { "category": "client", "priority": "High", "is_useless": false, "suggested_actions": ["reply", "flag"] }
 
 Context:
 - Subject: ${context.subject}
@@ -220,6 +273,15 @@ REQUIRED JSON STRUCTURE:
             myName?: string;
             myRole?: string;
             myCompany?: string;
+            myIndustry?: string;
+            workStyle?: 'corporate' | 'startup' | 'creative' | 'academic';
+            communicationStyle?: {
+                tone?: string;
+                length?: string;
+                signature?: string;
+                commonPhrases?: string[];
+            };
+            primaryGoal?: string;
 
             // Email analysis metadata
             category?: string;
@@ -254,6 +316,9 @@ REQUIRED JSON STRUCTURE:
                 if (richContext.myCompany) {
                     systemPrompt += ` at ${richContext.myCompany}`;
                 }
+                if (richContext.myIndustry) {
+                    systemPrompt += ` (${richContext.myIndustry} industry)`;
+                }
                 systemPrompt += '.';
             }
 
@@ -277,7 +342,55 @@ REQUIRED JSON STRUCTURE:
                 systemPrompt += `\n\nIMPORTANT: The incoming email is written in ${richContext.language}. You MUST write your reply in ${richContext.language}. Maintain appropriate formality and cultural conventions for ${richContext.language}.`;
             }
 
-            systemPrompt += '\n\nWrite ONLY the email body (no subject line). Be natural, concise, and professional. Match the tone of the incoming email.';
+            // Add persona-specific instructions
+            if (richContext?.workStyle) {
+                const styles = {
+                    corporate: "Maintain a formal, structured, and polite tone.",
+                    startup: "Be direct, concise, and action-oriented. Avoid fluff.",
+                    creative: "Be expressive, flexible, and approachable.",
+                    academic: "Be thorough, precise, and formal."
+                };
+                systemPrompt += `\nYour work style is: ${richContext.workStyle}. ${styles[richContext.workStyle as keyof typeof styles] || ''}`;
+            }
+
+            // Communication Preferences
+            if (richContext?.communicationStyle) {
+                const { tone, length, commonPhrases } = richContext.communicationStyle;
+
+                if (tone) systemPrompt += `\nPreferred Tone: ${tone}.`;
+
+                if (length) {
+                    const lengths = {
+                        brief: "Keep the reply very short (1-2 sentences).",
+                        medium: "Keep the reply distinct and focused (2-3 paragraphs max).",
+                        detailed: "Provide a comprehensive and detailed response."
+                    };
+                    systemPrompt += `\nResponse Length: ${lengths[length as keyof typeof lengths] || 'Medium'}.`;
+                }
+
+                if (commonPhrases && commonPhrases.length > 0) {
+                    systemPrompt += `\nincorporate these phrases if natural: ${commonPhrases.join(', ')}.`;
+                }
+            }
+
+            // Goal Alignment
+            if (richContext?.primaryGoal) {
+                const goals = {
+                    inbox_zero: "Goal: Clear the inbox. Resolve efficiently.",
+                    respond_faster: "Goal: Quick acknowledgment or resolution.",
+                    focus: "Goal: Protect user's time. Defer low-priority items.",
+                    reduce_time: "Goal: Minimal user editing required. Draft ready-to-send."
+                };
+                systemPrompt += `\n${goals[richContext.primaryGoal as keyof typeof goals] || ''}`;
+            }
+
+            systemPrompt += '\n\nWrite ONLY the email body (no subject line). Match the tone of the incoming email unless overridden by preferences.';
+            systemPrompt += '\n\nSTYLE GUIDELINES:';
+            systemPrompt += '\n- Start directly (e.g., "Thanks for the update" or "Hi [Name],")';
+            systemPrompt += '\n- NEVER use robotic phrases like "I hope this email finds you well" or "I am writing to you today"';
+            systemPrompt += '\n- Avoid "Please let me know if you have any questions" unless necessary - just say "Let me know if you need anything else"';
+            systemPrompt += '\n- Keep it under 150 words unless detail is explicitly requested';
+            systemPrompt += '\n- Use active voice';
 
             // Build user message with email context
             let userMessage = '';
@@ -357,13 +470,27 @@ REQUIRED JSON STRUCTURE:
 
         const systemPrompt = `You are an AI Automation Agent. Analyze the email and identify ALL rules that apply.
 
+CATEGORY DEFINITIONS:
+- spam: Unwanted/unsolicited bulk email, phishing attempts
+- newsletter: Recurring subscription content (weekly digests, company updates) - check for List-Unsubscribe
+- news: Breaking news alerts, timely notifications (Google Alerts, news feeds)
+- promotional: Marketing emails, sales offers, advertisements
+- transactional: Receipts, confirmations, order updates, account notifications
+- social: Social media notifications (LinkedIn, Twitter, Facebook)
+- support: Customer service, help desk, support tickets
+- client: Business correspondence from clients/customers (High Importance)
+- internal: Company-internal communications (colleagues, HR, IT)
+- personal: Personal correspondence from friends/family
+- notification: Platform alerts/notifications (Github, Linear, etc) - distinct from social
+- other: Anything that doesn't fit above categories
+
 Rules Context:
 ${rulesContext}
 
 REQUIRED JSON STRUCTURE:
 {
   "summary": "A brief summary of the email content",
-  "category": "spam|newsletter|news|promotional|transactional|social|support|client|internal|personal|other",
+  "category": "spam|newsletter|news|promotional|transactional|social|support|client|internal|personal|notification|other",
   "priority": "High|Medium|Low",
   "matched_rules": [
     {
@@ -377,26 +504,15 @@ REQUIRED JSON STRUCTURE:
   "draft_content": "Suggested reply if drafting, otherwise null"
 }
 
-CATEGORY DEFINITIONS (choose the most specific):
-- spam: Unwanted/unsolicited bulk email, phishing attempts
-- newsletter: Recurring subscription content (weekly digests, company updates)
-- news: Breaking news alerts, timely notifications, one-off news items (Google Alerts, news feeds)
-- promotional: Marketing emails, sales offers, advertisements
-- transactional: Receipts, confirmations, order updates, account notifications
-- social: Social media notifications (LinkedIn, Twitter, Facebook)
-- support: Customer service, help desk, support tickets
-- client: Business correspondence from clients/customers
-- internal: Company-internal communications (colleagues, HR, IT)
-- personal: Personal correspondence from friends/family
-- other: Anything that doesn't fit above categories
-
 CRITICAL INSTRUCTIONS:
 - Identify ALL rules that apply to this email (not just the best one)
 - Return an empty array if no rules match
 - Only include rules with confidence >= 0.7
 - For each matched rule, explain why it applies
 - Actions will be merged by the system - you don't need to resolve conflicts
-- Use "draft" action only if a rule explicitly requests it`;
+- Use "draft" action only if a rule explicitly requests it
+- Platform notifications (linkedin, github) are ALWAYS "notification" or "social"
+- Emails from noreply@ are likely "transactional" or "notification"`;
 
         if (eventLogger) {
             await eventLogger.info('Thinking', `Context-aware analysis: ${context.subject}`, {