@realtimex/email-automator 2.2.1 → 2.3.1

package/dist/api/src/services/intelligence.js

@@ -0,0 +1,243 @@
+import OpenAI from 'openai';
+import Instructor from '@instructor-ai/instructor';
+import { z } from 'zod';
+import { config } from '../config/index.js';
+import { createLogger } from '../utils/logger.js';
+import { ContentCleaner } from '../utils/contentCleaner.js';
+const logger = createLogger('Intelligence');
+// Define the schema for email analysis
+export const EmailAnalysisSchema = z.object({
+    summary: z.string().describe('A brief summary of the email content'),
+    category: z.enum(['spam', 'newsletter', 'promotional', 'transactional', 'social', 'support', 'client', 'internal', 'personal', 'other'])
+        .describe('The category of the email'),
+    sentiment: z.enum(['Positive', 'Neutral', 'Negative'])
+        .describe('The emotional tone of the email'),
+    is_useless: z.boolean()
+        .describe('Whether the email is considered useless (spam, newsletter, etc.)'),
+    suggested_actions: z.array(z.enum(['none', 'delete', 'archive', 'reply', 'flag']))
+        .describe('The recommended next actions (e.g. ["reply", "archive"])'),
+    draft_response: z.string().optional()
+        .describe('A suggested draft response if the action is reply'),
+    priority: z.enum(['High', 'Medium', 'Low'])
+        .describe('The urgency of the email'),
+    key_points: z.array(z.string()).optional()
+        .describe('Key points extracted from the email'),
+    action_items: z.array(z.string()).optional()
+        .describe('Action items mentioned in the email'),
+});
+export class IntelligenceService {
+    client;
+    model;
+    isConfigured = false;
+    constructor(overrides) {
+        const apiKey = overrides?.apiKey || config.llm.apiKey;
+        const baseUrl = overrides?.baseUrl || config.llm.baseUrl;
+        this.model = overrides?.model || config.llm.model;
+        // Allow local LLM servers (LM Studio, Ollama) or custom endpoints that don't need API keys
+        // We assume any custom baseUrl might be a local/private instance.
+        const isCustomEndpoint = baseUrl && !baseUrl.includes('api.openai.com');
+        if (!apiKey && !isCustomEndpoint) {
+            logger.warn('LLM_API_KEY is missing and no custom LLM endpoint configured. AI analysis will not work.');
+            return;
+        }
+        try {
+            const oai = new OpenAI({
+                apiKey: apiKey || 'not-needed-for-local', // Placeholder for local LLMs
+                baseURL: baseUrl,
+            });
+            this.client = Instructor({
+                client: oai,
+                mode: 'MD_JSON',
+            });
+            this.isConfigured = true;
+            logger.info('Intelligence service initialized', { model: this.model, baseUrl: baseUrl || 'default' });
+        }
+        catch (error) {
+            console.error('[Intelligence] Init failed:', error);
+            logger.error('Failed to initialize Intelligence service', error);
+        }
+    }
+    isReady() {
+        const ready = this.isConfigured && !!this.client;
+        if (!ready)
+            console.log('[Intelligence] isReady check failed:', { isConfigured: this.isConfigured, hasClient: !!this.client });
+        return ready;
+    }
+    async analyzeEmail(content, context, eventLogger, emailId) {
+        console.log('[Intelligence] analyzeEmail called for:', context.subject);
+        if (!this.isReady()) {
+            console.log('[Intelligence] Not ready, skipping');
+            logger.warn('Intelligence service not ready, skipping analysis');
+            if (eventLogger) {
+                await eventLogger.info('Skipped', 'AI Analysis skipped: Model not configured. Please check settings.', undefined, emailId);
+            }
+            return null;
+        }
+        // 1. Prepare Content and Signals
+        const cleanedContent = ContentCleaner.cleanEmailBody(content).substring(0, 2500);
+        const metadataSignals = [];
+        if (context.metadata?.listUnsubscribe)
+            metadataSignals.push('- Contains Unsubscribe header (High signal for Newsletter/Promo)');
+        if (context.metadata?.autoSubmitted && context.metadata.autoSubmitted !== 'no')
+            metadataSignals.push(`- Auto-Submitted: ${context.metadata.autoSubmitted}`);
+        if (context.metadata?.importance)
+            metadataSignals.push(`- Sender Priority/Importance: ${context.metadata.importance}`);
+        if (context.metadata?.mailer)
+            metadataSignals.push(`- Sent via: ${context.metadata.mailer}`);
+        const systemPrompt = `You are an AI Email Assistant. Your task is to analyze the provided email and extract structured information as JSON.
+Do NOT include any greetings, chatter, or special tokens like <|channel|> in your output.
+Return ONLY a valid JSON object.
+
+Definitions for Categories:
+- "important": Work-related, urgent, from known contacts
+- "promotional": Marketing, sales, discounts
+- "transactional": Receipts, shipping, confirmations
+- "social": LinkedIn, friends, social updates
+- "newsletter": Subscribed content
+- "spam": Junk, suspicious
+
+Context:
+- Current Date: ${new Date().toISOString()}
+- Subject: ${context.subject}
+- From: ${context.sender}
+- Date: ${context.date}
+${metadataSignals.length > 0 ? `\nMetadata Signals:\n${metadataSignals.join('\n')}` : ''}
+${context.userPreferences?.autoTrashSpam ? '- User has auto-trash spam enabled' : ''}
+${context.userPreferences?.smartDrafts ? '- User wants draft responses for important emails' : ''}
+
+REQUIRED JSON STRUCTURE:
+{
+  "summary": "string",
+  "category": "spam|newsletter|promotional|transactional|social|support|client|internal|personal|other",
+  "sentiment": "Positive|Neutral|Negative",
+  "is_useless": boolean,
+  "suggested_actions": ["none"|"delete"|"archive"|"reply"|"flag"],
+  "draft_response": "string (optional)",
+  "priority": "High|Medium|Low",
+  "key_points": ["string"],
+  "action_items": ["string"]
+}`;
+        // 2. Log Thinking Phase
+        if (eventLogger) {
+            console.log('[Intelligence] Logging "Thinking" event');
+            try {
+                await eventLogger.info('Thinking', `Analyzing email: ${context.subject}`, {
+                    model: this.model,
+                    system_prompt: systemPrompt,
+                    content_preview: cleanedContent
+                }, emailId);
+            }
+            catch (err) {
+                console.error('[Intelligence] Failed to log thinking event:', err);
+            }
+        }
+        let rawResponse = '';
+        try {
+            // Using raw completion call to handle garbage characters and strip tokens manually
+            const response = await this.client.client.chat.completions.create({
+                model: this.model,
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: cleanedContent || '[Empty email body]' },
+                ],
+                temperature: 0.1,
+            });
+            rawResponse = response.choices[0]?.message?.content || '';
+            console.log('[Intelligence] Raw LLM Response received (length:', rawResponse.length, ')');
+            // Clean the response: Find first '{' and last '}'
+            let jsonStr = rawResponse.trim();
+            const startIdx = jsonStr.indexOf('{');
+            const endIdx = jsonStr.lastIndexOf('}');
+            if (startIdx === -1 || endIdx === -1) {
+                throw new Error('Response did not contain a valid JSON object (missing curly braces)');
+            }
+            jsonStr = jsonStr.substring(startIdx, endIdx + 1);
+            const parsed = JSON.parse(jsonStr);
+            const validated = EmailAnalysisSchema.parse(parsed);
+            logger.debug('Email analyzed', {
+                category: validated.category,
+                actions: validated.suggested_actions,
+            });
+            if (eventLogger && emailId) {
+                await eventLogger.analysis('Decided', emailId, {
+                    ...validated,
+                    _raw_response: rawResponse
+                });
+            }
+            return validated;
+        }
+        catch (error) {
+            console.error('[Intelligence] AI Analysis failed:', error);
+            if (eventLogger) {
+                await eventLogger.error('Error', {
+                    error: error instanceof Error ? error.message : String(error),
+                    raw_response: rawResponse || 'No response received from LLM'
+                }, emailId);
+            }
+            return null;
+        }
+    }
+    async generateDraftReply(originalEmail, instructions) {
+        if (!this.isReady()) {
+            return null;
+        }
+        try {
+            const response = await this.client.chat.completions.create({
+                model: this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: `You are a professional email assistant. Generate a polite and appropriate reply to the email.
+${instructions ? `Additional instructions: ${instructions}` : ''}
+Keep the response concise and professional.`,
+                    },
+                    {
+                        role: 'user',
+                        content: `Original email from ${originalEmail.sender}:
+Subject: ${originalEmail.subject}
+
+${originalEmail.body}
+
+Please write a reply.`,
+                    },
+                ],
+            });
+            return response.choices[0]?.message?.content || null;
+        }
+        catch (error) {
+            logger.error('Draft generation failed', error);
+            return null;
+        }
+    }
+    async testConnection() {
+        if (!this.isReady()) {
+            return { success: false, message: 'Intelligence service not initialized. Check your API Key.' };
+        }
+        try {
+            await this.client.chat.completions.create({
+                model: this.model,
+                messages: [{ role: 'user', content: 'Say "Connection Successful"' }],
+                max_tokens: 5,
+            });
+            return { success: true, message: 'Connection successful!' };
+        }
+        catch (error) {
+            logger.error('Connection test failed', error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+}
+// Singleton instance with default config
+let defaultInstance = null;
+export function getIntelligenceService(overrides) {
+    if (overrides) {
+        return new IntelligenceService(overrides);
+    }
+    if (!defaultInstance) {
+        defaultInstance = new IntelligenceService();
+    }
+    return defaultInstance;
+}

package/dist/api/src/services/microsoft.js

@@ -0,0 +1,256 @@
+import * as msal from '@azure/msal-node';
+import { config } from '../config/index.js';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('MicrosoftService');
+const GRAPH_SCOPES = [
+    'https://graph.microsoft.com/Mail.Read',
+    'https://graph.microsoft.com/Mail.ReadWrite',
+    'https://graph.microsoft.com/User.Read',
+];
+export class MicrosoftService {
+    pca;
+    cca = null;
+    constructor() {
+        const publicConfig = {
+            auth: {
+                clientId: config.microsoft.clientId,
+                authority: `https://login.microsoftonline.com/${config.microsoft.tenantId}`,
+            },
+        };
+        this.pca = new msal.PublicClientApplication(publicConfig);
+        // Confidential client for server-side token refresh
+        if (config.microsoft.clientSecret) {
+            const confidentialConfig = {
+                auth: {
+                    clientId: config.microsoft.clientId,
+                    authority: `https://login.microsoftonline.com/${config.microsoft.tenantId}`,
+                    clientSecret: config.microsoft.clientSecret,
+                },
+            };
+            this.cca = new msal.ConfidentialClientApplication(confidentialConfig);
+        }
+    }
+    async initiateDeviceCodeFlow() {
+        const deviceCodeRequest = {
+            scopes: GRAPH_SCOPES,
+            deviceCodeCallback: (response) => {
+                logger.info('Device code received', { userCode: response.userCode });
+            },
+        };
+        const response = await this.pca.acquireTokenByDeviceCode(deviceCodeRequest);
+        // The device code flow returns tokens directly after user completes auth
+        // For now, we return the device code info for the frontend to display
+        return {
+            userCode: '',
+            verificationUri: 'https://microsoft.com/devicelogin',
+            message: 'Please visit https://microsoft.com/devicelogin and enter the code shown',
+            expiresIn: 900,
+            interval: 5,
+            deviceCode: '',
+        };
+    }
+    async acquireTokenByDeviceCode(deviceCodeCallback) {
+        try {
+            const response = await this.pca.acquireTokenByDeviceCode({
+                scopes: GRAPH_SCOPES,
+                deviceCodeCallback,
+            });
+            return response;
+        }
+        catch (error) {
+            logger.error('Device code flow failed', error);
+            return null;
+        }
+    }
+    async saveAccount(supabase, userId, emailAddress, authResult) {
+        const { data, error } = await supabase
+            .from('email_accounts')
+            .upsert({
+            user_id: userId,
+            email_address: emailAddress,
+            provider: 'outlook',
+            access_token: authResult.accessToken,
+            refresh_token: null, // MSAL handles token cache internally
+            token_expires_at: authResult.expiresOn?.toISOString() || null,
+            scopes: authResult.scopes,
+            is_active: true,
+            updated_at: new Date().toISOString(),
+        }, { onConflict: 'user_id, email_address' })
+            .select()
+            .single();
+        if (error)
+            throw error;
+        return data;
+    }
+    async refreshTokenIfNeeded(supabase, account) {
+        if (!account.token_expires_at)
+            return account;
+        const expiresAt = new Date(account.token_expires_at).getTime();
+        const now = Date.now();
+        const bufferMs = 5 * 60 * 1000;
+        if (expiresAt > now + bufferMs) {
+            return account;
+        }
+        logger.info('Refreshing Microsoft token', { accountId: account.id });
+        // For Microsoft, we need the CCA with client secret for refresh
+        if (!this.cca) {
+            throw new Error('Microsoft client secret not configured for token refresh');
+        }
+        // In production, you'd use refresh tokens stored in a token cache
+        // This is a simplified implementation
+        throw new Error('Microsoft token refresh requires re-authentication');
+    }
+    async fetchMessages(account, options = {}) {
+        const accessToken = account.access_token || '';
+        const { top = 20, skip = 0, filter } = options;
+        let url = `https://graph.microsoft.com/v1.0/me/messages?$top=${top}&$skip=${skip}&$orderby=receivedDateTime desc&$select=id,conversationId,subject,from,toRecipients,receivedDateTime,body,bodyPreview,importance`;
+        if (filter) {
+            url += `&$filter=${encodeURIComponent(filter)}`;
+        }
+        const response = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            logger.error('Failed to fetch Outlook messages', new Error(error));
+            throw new Error('Failed to fetch messages from Outlook');
+        }
+        const data = await response.json();
+        const messages = (data.value || []).map((msg) => ({
+            id: msg.id,
+            conversationId: msg.conversationId,
+            subject: msg.subject || 'No Subject',
+            sender: msg.from?.emailAddress?.address || 'Unknown',
+            recipient: msg.toRecipients?.[0]?.emailAddress?.address || '',
+            date: msg.receivedDateTime,
+            body: msg.body?.content || '',
+            snippet: msg.bodyPreview || '',
+            headers: {
+                importance: msg.importance,
+            }
+        }));
+        return {
+            messages,
+            hasMore: !!data['@odata.nextLink'],
+        };
+    }
+    async trashMessage(account, messageId) {
+        const accessToken = account.access_token || '';
+        const response = await fetch(`https://graph.microsoft.com/v1.0/me/messages/${messageId}/move`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ destinationId: 'deleteditems' }),
+        });
+        if (!response.ok) {
+            throw new Error('Failed to trash message');
+        }
+        logger.debug('Outlook message trashed', { messageId });
+    }
+    async archiveMessage(account, messageId) {
+        const accessToken = account.access_token || '';
+        const response = await fetch(`https://graph.microsoft.com/v1.0/me/messages/${messageId}/move`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ destinationId: 'archive' }),
+        });
+        if (!response.ok) {
+            throw new Error('Failed to archive message');
+        }
+        logger.debug('Outlook message archived', { messageId });
+    }
+    async markAsRead(account, messageId) {
+        const accessToken = account.access_token || '';
+        await fetch(`https://graph.microsoft.com/v1.0/me/messages/${messageId}`, {
+            method: 'PATCH',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ isRead: true }),
+        });
+        logger.debug('Outlook message marked as read', { messageId });
+    }
+    async flagMessage(account, messageId) {
+        const accessToken = account.access_token || '';
+        await fetch(`https://graph.microsoft.com/v1.0/me/messages/${messageId}`, {
+            method: 'PATCH',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ flag: { flagStatus: 'flagged' } }),
+        });
+        logger.debug('Outlook message flagged', { messageId });
+    }
+    async createDraft(account, originalMessageId, replyContent) {
+        const accessToken = account.access_token || '';
+        // Get original message
+        const originalResponse = await fetch(`https://graph.microsoft.com/v1.0/me/messages/${originalMessageId}`, {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+        const original = await originalResponse.json();
+        // Create reply draft
+        const response = await fetch(`https://graph.microsoft.com/v1.0/me/messages/${originalMessageId}/createReply`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            throw new Error('Failed to create reply draft');
+        }
+        const draft = await response.json();
+        // Update draft with content
+        await fetch(`https://graph.microsoft.com/v1.0/me/messages/${draft.id}`, {
+            method: 'PATCH',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                body: {
+                    contentType: 'text',
+                    content: replyContent,
+                },
+            }),
+        });
+        logger.debug('Outlook draft created', { draftId: draft.id });
+        return draft.id;
+    }
+    async getProfile(account) {
+        const accessToken = account.access_token || '';
+        const response = await fetch('https://graph.microsoft.com/v1.0/me', {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error('Failed to get profile');
+        }
+        const profile = await response.json();
+        return {
+            emailAddress: profile.mail || profile.userPrincipalName || '',
+            displayName: profile.displayName || '',
+        };
+    }
+}
+// Singleton
+let instance = null;
+export function getMicrosoftService() {
+    if (!instance) {
+        instance = new MicrosoftService();
+    }
+    return instance;
+}