@realtimex/email-automator 2.3.8 → 2.4.5

package/api/src/middleware/validation.ts

@@ -69,11 +69,14 @@ export const schemas = {
         accountId: z.string().uuid('Invalid account ID'),
     }),
 
-    // Action schemas
+    // Action schemas - supports both single action (legacy) and actions array
     executeAction: z.object({
         emailId: z.string().uuid('Invalid email ID'),
-        action: z.enum(['delete', 'archive', 'draft', 'flag', 'none']),
+        action: z.enum(['delete', 'archive', 'draft', 'flag', 'read', 'star', 'none']).optional(),
+        actions: z.array(z.enum(['delete', 'archive', 'draft', 'flag', 'read', 'star', 'none'])).optional(),
         draftContent: z.string().optional(),
+    }).refine(data => data.action || (data.actions && data.actions.length > 0), {
+        message: 'Either action or actions must be provided',
     }),
 
     // Migration schemas
@@ -83,19 +86,23 @@ export const schemas = {
         accessToken: z.string().optional(),
     }),
 
-    // Rule schemas
+    // Rule schemas - supports both single action (legacy) and actions array
     createRule: z.object({
         name: z.string().min(1).max(100),
         condition: z.record(z.unknown()),
-        action: z.enum(['delete', 'archive', 'draft', 'star', 'read']),
+        action: z.enum(['delete', 'archive', 'draft', 'star', 'read']).optional(),
+        actions: z.array(z.enum(['delete', 'archive', 'draft', 'star', 'read'])).optional(),
         instructions: z.string().optional(),
         is_enabled: z.boolean().default(true),
+    }).refine(data => data.action || (data.actions && data.actions.length > 0), {
+        message: 'Either action or actions must be provided',
     }),
 
     updateRule: z.object({
         name: z.string().min(1).max(100).optional(),
         condition: z.record(z.unknown()).optional(),
         action: z.enum(['delete', 'archive', 'draft', 'star', 'read']).optional(),
+        actions: z.array(z.enum(['delete', 'archive', 'draft', 'star', 'read'])).optional(),
         instructions: z.string().optional(),
         is_enabled: z.boolean().optional(),
     }),

package/api/src/routes/actions.ts

@@ -11,15 +11,24 @@ import { createLogger } from '../utils/logger.js';
 const router = Router();
 const logger = createLogger('ActionRoutes');
 
-// Execute action on email
+// Execute action(s) on email - supports both single action and array of actions
 router.post('/execute',
     apiRateLimit,
     authMiddleware,
     validateBody(schemas.executeAction),
     asyncHandler(async (req, res) => {
-        const { emailId, action, draftContent } = req.body;
+        const { emailId, action, actions, draftContent } = req.body;
         const userId = req.user!.id;
 
+        // Support both single action (legacy) and actions array
+        const actionsToExecute: string[] = actions && actions.length > 0
+            ? actions
+            : (action ? [action] : []);
+
+        if (actionsToExecute.length === 0) {
+            return res.status(400).json({ error: 'No actions specified' });
+        }
+
         // Fetch email with account info
         const { data: email, error } = await req.supabase!
             .from('emails')
@@ -37,59 +46,85 @@ router.post('/execute',
         }
 
         const account = email.email_accounts;
-        let actionResult = { success: true, details: '' };
-
-        if (action === 'none') {
-            // Just mark as reviewed
-            await req.supabase!
-                .from('emails')
-                .update({ action_taken: 'none' })
-                .eq('id', emailId);
-        } else if (account.provider === 'gmail') {
-            const gmailService = getGmailService();
-            
-            if (action === 'delete') {
-                await gmailService.trashMessage(account, email.external_id);
-            } else if (action === 'archive') {
-                await gmailService.archiveMessage(account, email.external_id);
-            } else if (action === 'draft') {
-                const content = draftContent || email.ai_analysis?.draft_response || '';
-                if (content) {
-                    const draftId = await gmailService.createDraft(account, email.external_id, content);
-                    actionResult.details = `Draft created: ${draftId}`;
-                }
-            } else if (action === 'flag') {
-                await gmailService.addLabel(account, email.external_id, ['STARRED']);
-            }
+        const actionResults: { action: string; success: boolean; details?: string }[] = [];
+
+        for (const currentAction of actionsToExecute) {
+            try {
+                let details = '';
+
+                if (currentAction === 'none') {
+                    // Just mark as reviewed, no provider action needed
+                } else if (account.provider === 'gmail') {
+                    const gmailService = getGmailService();
+
+                    if (currentAction === 'delete') {
+                        await gmailService.trashMessage(account, email.external_id);
+                    } else if (currentAction === 'archive') {
+                        await gmailService.archiveMessage(account, email.external_id);
+                    } else if (currentAction === 'draft') {
+                        const content = draftContent || email.ai_analysis?.draft_response || '';
+                        if (content) {
+                            const draftId = await gmailService.createDraft(account, email.external_id, content);
+                            details = `Draft created: ${draftId}`;
+                        }
+                    } else if (currentAction === 'flag') {
+                        await gmailService.addLabel(account, email.external_id, ['STARRED']);
+                    } else if (currentAction === 'read') {
+                        await gmailService.markAsRead(account, email.external_id);
+                    } else if (currentAction === 'star') {
+                        await gmailService.starMessage(account, email.external_id);
+                    }
+                } else if (account.provider === 'outlook') {
+                    const microsoftService = getMicrosoftService();
 
-            await req.supabase!
-                .from('emails')
-                .update({ action_taken: action })
-                .eq('id', emailId);
-        } else if (account.provider === 'outlook') {
-            const microsoftService = getMicrosoftService();
-            
-            if (action === 'delete') {
-                await microsoftService.trashMessage(account, email.external_id);
-            } else if (action === 'archive') {
-                await microsoftService.archiveMessage(account, email.external_id);
-            } else if (action === 'draft') {
-                const content = draftContent || email.ai_analysis?.draft_response || '';
-                if (content) {
-                    const draftId = await microsoftService.createDraft(account, email.external_id, content);
-                    actionResult.details = `Draft created: ${draftId}`;
+                    if (currentAction === 'delete') {
+                        await microsoftService.trashMessage(account, email.external_id);
+                    } else if (currentAction === 'archive') {
+                        await microsoftService.archiveMessage(account, email.external_id);
+                    } else if (currentAction === 'draft') {
+                        const content = draftContent || email.ai_analysis?.draft_response || '';
+                        if (content) {
+                            const draftId = await microsoftService.createDraft(account, email.external_id, content);
+                            details = `Draft created: ${draftId}`;
+                        }
+                    } else if (currentAction === 'read') {
+                        await microsoftService.markAsRead(account, email.external_id);
+                    } else if (currentAction === 'star' || currentAction === 'flag') {
+                        await microsoftService.flagMessage(account, email.external_id);
+                    }
                 }
-            }
 
-            await req.supabase!
-                .from('emails')
-                .update({ action_taken: action })
-                .eq('id', emailId);
+                // Record this action using atomic append
+                await req.supabase!.rpc('append_email_action', {
+                    p_email_id: emailId,
+                    p_action: currentAction
+                });
+
+                actionResults.push({ action: currentAction, success: true, details: details || undefined });
+            } catch (err) {
+                logger.error('Action failed', err, { emailId, action: currentAction });
+                actionResults.push({
+                    action: currentAction,
+                    success: false,
+                    details: err instanceof Error ? err.message : 'Unknown error'
+                });
+            }
         }
 
-        logger.info('Action executed', { emailId, action, userId });
+        // Update legacy column with first action for backward compatibility
+        await req.supabase!
+            .from('emails')
+            .update({ action_taken: actionsToExecute[0] })
+            .eq('id', emailId);
+
+        logger.info('Actions executed', { emailId, actions: actionsToExecute, userId });
 
-        res.json(actionResult);
+        res.json({
+            success: actionResults.every(r => r.success),
+            results: actionResults,
+            // Legacy field for backward compatibility
+            details: actionResults.map(r => r.details).filter(Boolean).join('; ')
+        });
     })
 );
 

package/api/src/routes/emails.ts

@@ -19,8 +19,15 @@ router.get('/',
             account_id,
             action_taken,
             search,
+            sort_by = 'date',
+            sort_order = 'desc'
         } = req.query;
 
+        // Validate sort params
+        const validSortFields = ['date', 'created_at'];
+        const sortField = validSortFields.includes(sort_by as string) ? sort_by as string : 'date';
+        const isAscending = sort_order === 'asc';
+
         let query = req.supabase!
             .from('emails')
             .select(`
@@ -28,7 +35,7 @@ router.get('/',
                 email_accounts!inner(id, user_id, email_address, provider)
             `, { count: 'exact' })
             .eq('email_accounts.user_id', req.user!.id)
-            .order('date', { ascending: false })
+            .order(sortField, { ascending: isAscending })
             .range(
                 parseInt(offset as string, 10),
                 parseInt(offset as string, 10) + parseInt(limit as string, 10) - 1

package/api/src/routes/rules.ts

@@ -31,7 +31,11 @@ router.post('/',
     authMiddleware,
     validateBody(schemas.createRule),
     asyncHandler(async (req, res) => {
-        const { name, condition, action, is_enabled, instructions, attachments } = req.body;
+        const { name, condition, action, actions, is_enabled, instructions, attachments } = req.body;
+
+        // Use actions array if provided, otherwise use single action for backward compatibility
+        const ruleActions = actions && actions.length > 0 ? actions : (action ? [action] : []);
+        const primaryAction = ruleActions[0] || 'archive'; // For legacy column
 
         const { data, error } = await req.supabase!
             .from('rules')
@@ -39,7 +43,8 @@ router.post('/',
                 user_id: req.user!.id,
                 name,
                 condition,
-                action,
+                action: primaryAction, // Legacy column
+                actions: ruleActions,  // New multi-action column
                 is_enabled,
                 instructions,
                 attachments,
@@ -49,7 +54,7 @@ router.post('/',
 
         if (error) throw error;
 
-        logger.info('Rule created', { ruleId: data.id, userId: req.user!.id });
+        logger.info('Rule created', { ruleId: data.id, actions: ruleActions, userId: req.user!.id });
 
         res.status(201).json({ rule: data });
     })

package/api/src/services/eventLogger.ts

@@ -46,7 +46,15 @@ export class EventLogger {
         await this.log('action', state, { action, reason }, emailId);
     }
 
-    async error(state: string, error: any, emailId?: string) {
-        await this.log('error', state, { error: error.message || error }, emailId);
+    async error(state: string, errorOrDetails: any, emailId?: string) {
+        let details;
+        if (errorOrDetails instanceof Error) {
+            details = { error: errorOrDetails.message };
+        } else if (typeof errorOrDetails === 'object' && errorOrDetails !== null) {
+            details = errorOrDetails;
+        } else {
+            details = { error: String(errorOrDetails) };
+        }
+        await this.log('error', state, details, emailId);
     }
 }

package/api/src/services/gmail.ts

@@ -21,6 +21,7 @@ export interface GmailMessage {
     sender: string;
     recipient: string;
     date: string;
+    internalDate: string; // Gmail's internal timestamp (ms since epoch) - use this for checkpointing
     body: string;
     snippet: string;
     headers: {
@@ -224,6 +225,132 @@ export class GmailService {
         };
     }
 
+    /**
+     * Fetch messages in OLDEST-FIRST order using "Fetch IDs → Sort → Hydrate" strategy.
+     *
+     * Gmail API always returns newest first and doesn't support sorting.
+     * To process oldest emails first (critical for checkpoint-based sync), we:
+     * 1. Fetch ALL message IDs matching the query (lightweight, paginated)
+     * 2. Sort by internalDate ascending (oldest first)
+     * 3. Take first N messages (limit)
+     * 4. Hydrate only those N messages with full details
+     *
+     * This ensures we never skip emails when using max_emails pagination.
+     */
+    async fetchMessagesOldestFirst(
+        account: EmailAccount,
+        options: { limit: number; query?: string; maxIdsToFetch?: number }
+    ): Promise<{ messages: GmailMessage[]; hasMore: boolean }> {
+        const { limit, query, maxIdsToFetch = 1000 } = options;
+
+        // Step 1: Fetch all message IDs (lightweight)
+        const allIds = await this.fetchAllMessageIds(account, query, maxIdsToFetch);
+
+        if (allIds.length === 0) {
+            return { messages: [], hasMore: false };
+        }
+
+        logger.debug('Fetched message IDs', { count: allIds.length, query });
+
+        // Step 2: Sort by internalDate ascending (oldest first)
+        allIds.sort((a, b) => parseInt(a.internalDate) - parseInt(b.internalDate));
+
+        // Step 3: Take first N IDs
+        const idsToHydrate = allIds.slice(0, limit);
+        const hasMore = allIds.length > limit;
+
+        // Step 4: Hydrate those specific messages
+        const messages = await this.hydrateMessages(account, idsToHydrate.map(m => m.id));
+
+        // Re-sort hydrated messages by internalDate (maintain order)
+        messages.sort((a, b) => parseInt(a.internalDate) - parseInt(b.internalDate));
+
+        return { messages, hasMore };
+    }
+
+    /**
+     * Fetch all message IDs matching a query (lightweight, paginated).
+     * Uses minimal fields for speed: only id and internalDate.
+     */
+    private async fetchAllMessageIds(
+        account: EmailAccount,
+        query: string | undefined,
+        maxIds: number
+    ): Promise<{ id: string; internalDate: string }[]> {
+        const gmail = await this.getAuthenticatedClient(account);
+        const results: { id: string; internalDate: string }[] = [];
+        let pageToken: string | undefined;
+
+        do {
+            const response = await gmail.users.messages.list({
+                userId: 'me',
+                q: query,
+                pageToken,
+                maxResults: 500, // Max allowed per page
+                // Note: messages.list only returns id and threadId, not internalDate
+                // We need to fetch internalDate separately with minimal format
+            });
+
+            const messageRefs = response.data.messages || [];
+
+            // Fetch internalDate for each message (using metadata format for speed)
+            for (const ref of messageRefs) {
+                if (!ref.id || results.length >= maxIds) break;
+
+                try {
+                    const msg = await gmail.users.messages.get({
+                        userId: 'me',
+                        id: ref.id,
+                        format: 'minimal', // Only returns id, threadId, labelIds, snippet, internalDate
+                    });
+
+                    if (msg.data.id && msg.data.internalDate) {
+                        results.push({
+                            id: msg.data.id,
+                            internalDate: msg.data.internalDate,
+                        });
+                    }
+                } catch (error) {
+                    logger.warn('Failed to fetch message metadata', { messageId: ref.id });
+                }
+            }
+
+            pageToken = response.data.nextPageToken ?? undefined;
+        } while (pageToken && results.length < maxIds);
+
+        return results;
+    }
+
+    /**
+     * Hydrate specific messages by ID (fetch full details).
+     */
+    private async hydrateMessages(
+        account: EmailAccount,
+        messageIds: string[]
+    ): Promise<GmailMessage[]> {
+        const gmail = await this.getAuthenticatedClient(account);
+        const messages: GmailMessage[] = [];
+
+        for (const id of messageIds) {
+            try {
+                const detail = await gmail.users.messages.get({
+                    userId: 'me',
+                    id,
+                    format: 'full',
+                });
+
+                const parsed = this.parseMessage(detail.data);
+                if (parsed) {
+                    messages.push(parsed);
+                }
+            } catch (error) {
+                logger.warn('Failed to hydrate message', { messageId: id, error });
+            }
+        }
+
+        return messages;
+    }
+
     private parseMessage(message: gmail_v1.Schema$Message): GmailMessage | null {
         if (!message.id || !message.threadId) return null;
 
@@ -250,6 +377,7 @@ export class GmailService {
             sender: getHeader('From'),
             recipient: getHeader('To'),
             date: getHeader('Date'),
+            internalDate: message.internalDate || '', // Gmail's internal timestamp (ms since epoch)
             body,
             snippet: message.snippet || '',
             headers: {

package/api/src/services/intelligence.ts

@@ -167,7 +167,7 @@ REQUIRED JSON STRUCTURE:
                     { role: 'system', content: systemPrompt },
                     { role: 'user', content: cleanedContent || '[Empty email body]' },
                 ],
-                response_format: { type: 'json_object' },
+                // response_format: { type: 'json_object' }, // Removed for compatibility
                 temperature: 0.1,
             });
 

package/api/src/services/microsoft.ts

@@ -160,7 +160,9 @@ export class MicrosoftService {
         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`;
+        // IMPORTANT: Use ascending order to fetch OLDEST emails first
+        // This ensures checkpoint-based pagination works correctly and doesn't skip emails
+        let url = `https://graph.microsoft.com/v1.0/me/messages?$top=${top}&$skip=${skip}&$orderby=receivedDateTime asc&$select=id,conversationId,subject,from,toRecipients,receivedDateTime,body,bodyPreview,importance`;
         if (filter) {
             url += `&$filter=${encodeURIComponent(filter)}`;
         }