@realtimex/email-automator 2.2.1 → 2.3.1

package/dist/api/src/routes/actions.js

@@ -0,0 +1,173 @@
+import { Router } from 'express';
+import { asyncHandler, NotFoundError } from '../middleware/errorHandler.js';
+import { authMiddleware } from '../middleware/auth.js';
+import { apiRateLimit } from '../middleware/rateLimit.js';
+import { validateBody, schemas } from '../middleware/validation.js';
+import { getGmailService } from '../services/gmail.js';
+import { getMicrosoftService } from '../services/microsoft.js';
+import { getIntelligenceService } from '../services/intelligence.js';
+import { createLogger } from '../utils/logger.js';
+const router = Router();
+const logger = createLogger('ActionRoutes');
+// Execute action on email
+router.post('/execute', apiRateLimit, authMiddleware, validateBody(schemas.executeAction), asyncHandler(async (req, res) => {
+    const { emailId, action, draftContent } = req.body;
+    const userId = req.user.id;
+    // Fetch email with account info
+    const { data: email, error } = await req.supabase
+        .from('emails')
+        .select('*, email_accounts(*)')
+        .eq('id', emailId)
+        .single();
+    if (error || !email) {
+        throw new NotFoundError('Email');
+    }
+    // Verify ownership
+    if (email.email_accounts.user_id !== userId) {
+        throw new NotFoundError('Email');
+    }
+    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']);
+        }
+        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}`;
+            }
+        }
+        await req.supabase
+            .from('emails')
+            .update({ action_taken: action })
+            .eq('id', emailId);
+    }
+    logger.info('Action executed', { emailId, action, userId });
+    res.json(actionResult);
+}));
+// Generate AI draft for an email
+router.post('/draft/:emailId', apiRateLimit, authMiddleware, asyncHandler(async (req, res) => {
+    const { emailId } = req.params;
+    const { instructions } = req.body;
+    const userId = req.user.id;
+    // Fetch email
+    const { data: email, error } = await req.supabase
+        .from('emails')
+        .select('*, email_accounts(user_id)')
+        .eq('id', emailId)
+        .single();
+    if (error || !email) {
+        throw new NotFoundError('Email');
+    }
+    if (email.email_accounts.user_id !== userId) {
+        throw new NotFoundError('Email');
+    }
+    // Get user settings for LLM config
+    const { data: settings } = await req.supabase
+        .from('user_settings')
+        .select('llm_model, llm_base_url')
+        .eq('user_id', userId)
+        .single();
+    const intelligenceService = getIntelligenceService(settings ? { model: settings.llm_model, baseUrl: settings.llm_base_url } : undefined);
+    const draft = await intelligenceService.generateDraftReply({
+        subject: email.subject,
+        sender: email.sender,
+        body: email.body_snippet,
+    }, instructions);
+    if (!draft) {
+        return res.status(500).json({ error: 'Failed to generate draft' });
+    }
+    res.json({ draft });
+}));
+// Bulk actions
+router.post('/bulk', apiRateLimit, authMiddleware, asyncHandler(async (req, res) => {
+    const { emailIds, action } = req.body;
+    const userId = req.user.id;
+    if (!Array.isArray(emailIds) || emailIds.length === 0) {
+        return res.status(400).json({ error: 'emailIds must be a non-empty array' });
+    }
+    if (!['delete', 'archive', 'none'].includes(action)) {
+        return res.status(400).json({ error: 'Invalid action for bulk operation' });
+    }
+    const results = { success: 0, failed: 0 };
+    for (const emailId of emailIds) {
+        try {
+            // Fetch email
+            const { data: email } = await req.supabase
+                .from('emails')
+                .select('*, email_accounts(*)')
+                .eq('id', emailId)
+                .single();
+            if (!email || email.email_accounts.user_id !== userId) {
+                results.failed++;
+                continue;
+            }
+            const account = email.email_accounts;
+            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 (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);
+                }
+            }
+            await req.supabase
+                .from('emails')
+                .update({ action_taken: action })
+                .eq('id', emailId);
+            results.success++;
+        }
+        catch (err) {
+            logger.error('Bulk action failed for email', err, { emailId });
+            results.failed++;
+        }
+    }
+    res.json(results);
+}));
+export default router;

package/dist/api/src/routes/auth.js

@@ -0,0 +1,106 @@
+import { Router } from 'express';
+import { asyncHandler, ValidationError } from '../middleware/errorHandler.js';
+import { authMiddleware } from '../middleware/auth.js';
+import { authRateLimit } from '../middleware/rateLimit.js';
+import { validateBody, schemas } from '../middleware/validation.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('AuthRoutes');
+// Gmail OAuth
+router.get('/gmail/url', authRateLimit, asyncHandler(async (req, res) => {
+    const gmailService = getGmailService();
+    const url = gmailService.getAuthUrl();
+    logger.info('Gmail auth URL generated');
+    res.json({ url });
+}));
+router.post('/gmail/callback', authRateLimit, authMiddleware, validateBody(schemas.gmailCallback), asyncHandler(async (req, res) => {
+    const { code } = req.body;
+    const gmailService = getGmailService();
+    // Exchange code for tokens
+    const tokens = await gmailService.exchangeCode(code);
+    if (!tokens.access_token) {
+        throw new ValidationError('Failed to obtain access token');
+    }
+    // Get email address from Gmail profile
+    const tempAccount = {
+        id: '',
+        user_id: req.user.id,
+        provider: 'gmail',
+        email_address: '',
+        access_token: tokens.access_token,
+        refresh_token: tokens.refresh_token || null,
+        token_expires_at: tokens.expiry_date ? new Date(tokens.expiry_date).toISOString() : null,
+        scopes: tokens.scope?.split(' ') || [],
+        is_active: true,
+        created_at: '',
+        updated_at: '',
+    };
+    const profile = await gmailService.getProfile(tempAccount);
+    // Save account
+    const account = await gmailService.saveAccount(req.supabase, req.user.id, profile.emailAddress, tokens);
+    logger.info('Gmail account connected', {
+        userId: req.user.id,
+        email: profile.emailAddress
+    });
+    res.json({
+        success: true,
+        account: {
+            id: account.id,
+            email_address: account.email_address,
+            provider: account.provider,
+        }
+    });
+}));
+// Microsoft OAuth (Device Code Flow)
+router.post('/microsoft/device-flow', authRateLimit, authMiddleware, asyncHandler(async (req, res) => {
+    const microsoftService = getMicrosoftService();
+    // Start device code flow
+    const result = await microsoftService.acquireTokenByDeviceCode((response) => {
+        // This callback is called when the device code is ready
+        res.json({
+            userCode: response.userCode,
+            verificationUri: response.verificationUri,
+            message: response.message,
+        });
+    });
+    // If we get here, the user completed the flow
+    if (result) {
+        const account = await microsoftService.saveAccount(req.supabase, req.user.id, result.account?.username || '', result);
+        logger.info('Microsoft account connected', {
+            userId: req.user.id,
+            email: account.email_address,
+        });
+    }
+}));
+router.post('/microsoft/complete', authRateLimit, authMiddleware, validateBody(schemas.deviceFlow), asyncHandler(async (_req, res) => {
+    // Device flow completion is handled in the device-flow endpoint
+    // This is kept for backwards compatibility
+    res.json({ success: true });
+}));
+// Disconnect account
+router.delete('/accounts/:accountId', authMiddleware, asyncHandler(async (req, res) => {
+    const { accountId } = req.params;
+    const { error } = await req.supabase
+        .from('email_accounts')
+        .delete()
+        .eq('id', accountId)
+        .eq('user_id', req.user.id);
+    if (error)
+        throw error;
+    logger.info('Account disconnected', { accountId, userId: req.user.id });
+    res.json({ success: true });
+}));
+// List connected accounts
+router.get('/accounts', authMiddleware, asyncHandler(async (req, res) => {
+    const { data, error } = await req.supabase
+        .from('email_accounts')
+        .select('id, provider, email_address, is_active, created_at, updated_at')
+        .eq('user_id', req.user.id)
+        .order('created_at', { ascending: false });
+    if (error)
+        throw error;
+    res.json({ accounts: data || [] });
+}));
+export default router;

package/dist/api/src/routes/emails.js

@@ -0,0 +1,100 @@
+import { Router } from 'express';
+import { asyncHandler, NotFoundError } from '../middleware/errorHandler.js';
+import { authMiddleware } from '../middleware/auth.js';
+import { apiRateLimit } from '../middleware/rateLimit.js';
+import { createLogger } from '../utils/logger.js';
+const router = Router();
+const logger = createLogger('EmailsRoutes');
+// List emails with pagination and filters
+router.get('/', authMiddleware, asyncHandler(async (req, res) => {
+    const { limit = '20', offset = '0', category, is_useless, account_id, action_taken, search, } = req.query;
+    let query = req.supabase
+        .from('emails')
+        .select(`
+                *,
+                email_accounts!inner(id, user_id, email_address, provider)
+            `, { count: 'exact' })
+        .eq('email_accounts.user_id', req.user.id)
+        .order('date', { ascending: false })
+        .range(parseInt(offset, 10), parseInt(offset, 10) + parseInt(limit, 10) - 1);
+    // Apply filters
+    if (category) {
+        query = query.eq('category', category);
+    }
+    if (is_useless !== undefined) {
+        query = query.eq('is_useless', is_useless === 'true');
+    }
+    if (account_id) {
+        query = query.eq('account_id', account_id);
+    }
+    if (action_taken) {
+        query = query.eq('action_taken', action_taken);
+    }
+    if (search) {
+        query = query.or(`subject.ilike.%${search}%,sender.ilike.%${search}%`);
+    }
+    const { data, error, count } = await query;
+    if (error)
+        throw error;
+    res.json({
+        emails: data || [],
+        total: count || 0,
+        limit: parseInt(limit, 10),
+        offset: parseInt(offset, 10),
+    });
+}));
+// Get single email
+router.get('/:emailId', authMiddleware, asyncHandler(async (req, res) => {
+    const { emailId } = req.params;
+    const { data, error } = await req.supabase
+        .from('emails')
+        .select(`
+                *,
+                email_accounts!inner(id, user_id, email_address, provider)
+            `)
+        .eq('id', emailId)
+        .eq('email_accounts.user_id', req.user.id)
+        .single();
+    if (error || !data) {
+        throw new NotFoundError('Email');
+    }
+    res.json({ email: data });
+}));
+// Delete email record (not the actual email from provider)
+router.delete('/:emailId', apiRateLimit, authMiddleware, asyncHandler(async (req, res) => {
+    const { emailId } = req.params;
+    // Verify ownership first
+    const { data: email } = 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 (!email) {
+        throw new NotFoundError('Email');
+    }
+    const { error } = await req.supabase
+        .from('emails')
+        .delete()
+        .eq('id', emailId);
+    if (error)
+        throw error;
+    logger.info('Email record deleted', { emailId, userId: req.user.id });
+    res.json({ success: true });
+}));
+// Get email categories summary
+router.get('/summary/categories', authMiddleware, asyncHandler(async (req, res) => {
+    const { data, error } = await req.supabase
+        .from('emails')
+        .select('category, email_accounts!inner(user_id)')
+        .eq('email_accounts.user_id', req.user.id);
+    if (error)
+        throw error;
+    const summary = {};
+    for (const email of data || []) {
+        const cat = email.category || 'uncategorized';
+        summary[cat] = (summary[cat] || 0) + 1;
+    }
+    res.json({ categories: summary });
+}));
+export default router;

package/dist/api/src/routes/health.js

@@ -0,0 +1,33 @@
+import { Router } from 'express';
+import { getServerSupabase } from '../services/supabase.js';
+import { config } from '../config/index.js';
+const router = Router();
+router.get('/', async (_req, res) => {
+    const supabase = getServerSupabase();
+    let dbStatus = 'unknown';
+    if (supabase) {
+        try {
+            const { error } = await supabase.from('email_accounts').select('id').limit(1);
+            dbStatus = error ? 'error' : 'connected';
+        }
+        catch {
+            dbStatus = 'error';
+        }
+    }
+    else {
+        dbStatus = 'not_configured';
+    }
+    res.json({
+        status: 'healthy',
+        timestamp: new Date().toISOString(),
+        version: '1.0.0',
+        environment: config.nodeEnv,
+        services: {
+            database: dbStatus,
+            llm: config.llm.apiKey ? 'configured' : 'not_configured',
+            gmail: config.gmail.clientId ? 'configured' : 'not_configured',
+            microsoft: config.microsoft.clientId ? 'configured' : 'not_configured',
+        },
+    });
+});
+export default router;

package/dist/api/src/routes/index.js

@@ -0,0 +1,19 @@
+import { Router } from 'express';
+import healthRoutes from './health.js';
+import authRoutes from './auth.js';
+import syncRoutes from './sync.js';
+import actionsRoutes from './actions.js';
+import rulesRoutes from './rules.js';
+import settingsRoutes from './settings.js';
+import emailsRoutes from './emails.js';
+import migrateRoutes from './migrate.js';
+const router = Router();
+router.use('/health', healthRoutes);
+router.use('/auth', authRoutes);
+router.use('/sync', syncRoutes);
+router.use('/actions', actionsRoutes);
+router.use('/rules', rulesRoutes);
+router.use('/settings', settingsRoutes);
+router.use('/emails', emailsRoutes);
+router.use('/migrate', migrateRoutes);
+export default router;

package/dist/api/src/routes/migrate.js

@@ -0,0 +1,61 @@
+import { Router } from 'express';
+import { spawn } from 'child_process';
+import { asyncHandler } from '../middleware/errorHandler.js';
+import { validateBody, schemas } from '../middleware/validation.js';
+import { config } from '../config/index.js';
+import { createLogger } from '../utils/logger.js';
+import { join } from 'path';
+const router = Router();
+const logger = createLogger('MigrateRoutes');
+// Run database migration
+router.post('/', validateBody(schemas.migrate), asyncHandler(async (req, res) => {
+    const { projectRef, dbPassword, accessToken } = req.body;
+    logger.info('Starting migration', { projectRef });
+    res.setHeader('Content-Type', 'text/plain');
+    res.setHeader('Transfer-Encoding', 'chunked');
+    const sendLog = (message) => {
+        res.write(message + '\n');
+    };
+    try {
+        sendLog('🔧 Starting migration...');
+        const scriptPath = join(config.scriptsDir, 'migrate.sh');
+        const env = {
+            ...process.env,
+            SUPABASE_PROJECT_ID: projectRef,
+            SUPABASE_DB_PASSWORD: dbPassword || '',
+            SUPABASE_ACCESS_TOKEN: accessToken || '',
+        };
+        const child = spawn('bash', [scriptPath], {
+            env,
+            cwd: config.rootDir,
+        });
+        child.stdout.on('data', (data) => {
+            sendLog(data.toString().trim());
+        });
+        child.stderr.on('data', (data) => {
+            sendLog(`⚠️  ${data.toString().trim()}`);
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                sendLog('✅ Migration successful!');
+                logger.info('Migration completed successfully', { projectRef });
+            }
+            else {
+                sendLog(`❌ Migration failed with code ${code}`);
+                logger.error('Migration failed', new Error(`Exit code: ${code}`), { projectRef });
+            }
+            res.end();
+        });
+        child.on('error', (error) => {
+            sendLog(`❌ Failed to run migration: ${error.message}`);
+            logger.error('Migration spawn error', error);
+            res.end();
+        });
+    }
+    catch (error) {
+        sendLog(`❌ Server error: ${error.message}`);
+        logger.error('Migration error', error);
+        res.end();
+    }
+}));
+export default router;

package/dist/api/src/routes/rules.js

@@ -0,0 +1,104 @@
+import { Router } from 'express';
+import { asyncHandler, NotFoundError } from '../middleware/errorHandler.js';
+import { authMiddleware } from '../middleware/auth.js';
+import { apiRateLimit } from '../middleware/rateLimit.js';
+import { validateBody, validateParams, schemas } from '../middleware/validation.js';
+import { z } from 'zod';
+import { createLogger } from '../utils/logger.js';
+const router = Router();
+const logger = createLogger('RulesRoutes');
+// List all rules
+router.get('/', authMiddleware, asyncHandler(async (req, res) => {
+    const { data, error } = await req.supabase
+        .from('rules')
+        .select('*')
+        .eq('user_id', req.user.id)
+        .order('created_at', { ascending: false });
+    if (error)
+        throw error;
+    res.json({ rules: data || [] });
+}));
+// Create rule
+router.post('/', apiRateLimit, authMiddleware, validateBody(schemas.createRule), asyncHandler(async (req, res) => {
+    const { name, condition, action, is_enabled, instructions, attachments } = req.body;
+    const { data, error } = await req.supabase
+        .from('rules')
+        .insert({
+        user_id: req.user.id,
+        name,
+        condition,
+        action,
+        is_enabled,
+        instructions,
+        attachments,
+    })
+        .select()
+        .single();
+    if (error)
+        throw error;
+    logger.info('Rule created', { ruleId: data.id, userId: req.user.id });
+    res.status(201).json({ rule: data });
+}));
+// Update rule
+router.patch('/:ruleId', apiRateLimit, authMiddleware, validateParams(z.object({ ruleId: schemas.uuid })), validateBody(schemas.updateRule), asyncHandler(async (req, res) => {
+    const { ruleId } = req.params;
+    const updates = req.body;
+    const { data, error } = await req.supabase
+        .from('rules')
+        .update(updates)
+        .eq('id', ruleId)
+        .eq('user_id', req.user.id)
+        .select()
+        .single();
+    if (error)
+        throw error;
+    if (!data)
+        throw new NotFoundError('Rule');
+    logger.info('Rule updated', { ruleId, userId: req.user.id });
+    res.json({ rule: data });
+}));
+// Delete rule
+router.delete('/:ruleId', authMiddleware, validateParams(z.object({ ruleId: schemas.uuid })), asyncHandler(async (req, res) => {
+    const { ruleId } = req.params;
+    const { error } = await req.supabase
+        .from('rules')
+        .delete()
+        .eq('id', ruleId)
+        .eq('user_id', req.user.id);
+    if (error)
+        throw error;
+    logger.info('Rule deleted', { ruleId, userId: req.user.id });
+    res.json({ success: true });
+}));
+// Toggle rule enabled/disabled
+router.post('/:ruleId/toggle', authMiddleware, validateParams(z.object({ ruleId: schemas.uuid })), asyncHandler(async (req, res) => {
+    const { ruleId } = req.params;
+    const userId = req.user.id;
+    // Get current state
+    const { data: rule, error: fetchError } = await req.supabase
+        .from('rules')
+        .select('name, is_enabled')
+        .eq('id', ruleId)
+        .eq('user_id', userId)
+        .single();
+    if (fetchError || !rule) {
+        logger.error('Toggle failed: Rule not found', { ruleId, userId });
+        throw new NotFoundError('Rule');
+    }
+    const nextState = !rule.is_enabled;
+    logger.info('Toggling rule', { ruleName: rule.name, from: rule.is_enabled, to: nextState });
+    // Toggle
+    const { data, error } = await req.supabase
+        .from('rules')
+        .update({ is_enabled: nextState })
+        .eq('id', ruleId)
+        .select()
+        .single();
+    if (error) {
+        logger.error('Database error during toggle', error);
+        throw error;
+    }
+    logger.info('Toggle successful', { ruleId, is_enabled: data.is_enabled });
+    res.json({ rule: data });
+}));
+export default router;