@realtimex/email-automator 2.2.1 → 2.3.0

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

@@ -0,0 +1,210 @@
+import { config } from '../config/index.js';
+import { createLogger } from '../utils/logger.js';
+import { EmailProcessorService } from './processor.js';
+import { getServerSupabase } from './supabase.js';
+const logger = createLogger('Scheduler');
+class SyncScheduler {
+    jobs = new Map();
+    supabase = null;
+    constructor() {
+        this.supabase = getServerSupabase();
+    }
+    async start() {
+        if (!this.supabase) {
+            logger.warn('Supabase not configured, scheduler disabled');
+            return;
+        }
+        logger.info('Starting sync scheduler');
+        // Schedule periodic sync for all active accounts
+        this.scheduleGlobalSync();
+        // Schedule cleanup job
+        this.scheduleCleanup();
+    }
+    stop() {
+        logger.info('Stopping sync scheduler');
+        for (const job of this.jobs.values()) {
+            if (job.timer) {
+                clearInterval(job.timer);
+            }
+        }
+        this.jobs.clear();
+    }
+    scheduleGlobalSync() {
+        const jobId = 'global-sync';
+        const interval = config.processing.syncIntervalMs;
+        const job = {
+            id: jobId,
+            name: 'Global Email Sync',
+            interval,
+            lastRun: null,
+            isRunning: false,
+            timer: null,
+        };
+        job.timer = setInterval(async () => {
+            if (job.isRunning) {
+                logger.debug('Global sync already running, skipping');
+                return;
+            }
+            job.isRunning = true;
+            try {
+                await this.runGlobalSync();
+                job.lastRun = new Date();
+            }
+            catch (error) {
+                logger.error('Global sync failed', error);
+            }
+            finally {
+                job.isRunning = false;
+            }
+        }, interval);
+        this.jobs.set(jobId, job);
+        logger.info(`Scheduled global sync every ${interval / 1000}s`);
+    }
+    async runGlobalSync() {
+        if (!this.supabase)
+            return;
+        // Get all active accounts with their user settings
+        const { data: accounts, error } = await this.supabase
+            .from('email_accounts')
+            .select(`
+                id,
+                user_id,
+                provider,
+                is_active
+            `)
+            .eq('is_active', true);
+        if (error) {
+            logger.error('Failed to fetch accounts for sync', error);
+            return;
+        }
+        if (!accounts || accounts.length === 0) {
+            logger.debug('No active accounts to sync');
+            return;
+        }
+        logger.info(`Running global sync for ${accounts.length} accounts`);
+        // Group by user to check their sync interval settings
+        const userAccounts = new Map();
+        for (const account of accounts) {
+            const existing = userAccounts.get(account.user_id) || [];
+            existing.push(account);
+            userAccounts.set(account.user_id, existing);
+        }
+        // Process each user's accounts
+        for (const [userId, userAccountList] of userAccounts) {
+            // Check user's sync interval preference
+            const { data: settings } = await this.supabase
+                .from('user_settings')
+                .select('sync_interval_minutes')
+                .eq('user_id', userId)
+                .single();
+            const syncIntervalMs = (settings?.sync_interval_minutes || 5) * 60 * 1000;
+            // Check last sync time
+            const { data: lastLog } = await this.supabase
+                .from('processing_logs')
+                .select('started_at')
+                .eq('user_id', userId)
+                .eq('status', 'success')
+                .order('started_at', { ascending: false })
+                .limit(1)
+                .single();
+            if (lastLog) {
+                const lastSyncTime = new Date(lastLog.started_at).getTime();
+                const now = Date.now();
+                if (now - lastSyncTime < syncIntervalMs) {
+                    logger.debug(`Skipping sync for user ${userId}, last sync was recent`);
+                    continue;
+                }
+            }
+            // Sync each account
+            const processor = new EmailProcessorService(this.supabase);
+            for (const account of userAccountList) {
+                try {
+                    await processor.syncAccount(account.id, userId);
+                }
+                catch (error) {
+                    logger.error('Account sync failed', error, { accountId: account.id });
+                }
+            }
+        }
+    }
+    scheduleCleanup() {
+        const jobId = 'cleanup';
+        const interval = 24 * 60 * 60 * 1000; // Daily
+        const job = {
+            id: jobId,
+            name: 'Data Cleanup',
+            interval,
+            lastRun: null,
+            isRunning: false,
+            timer: null,
+        };
+        job.timer = setInterval(async () => {
+            if (job.isRunning)
+                return;
+            job.isRunning = true;
+            try {
+                await this.runCleanup();
+                job.lastRun = new Date();
+            }
+            catch (error) {
+                logger.error('Cleanup failed', error);
+            }
+            finally {
+                job.isRunning = false;
+            }
+        }, interval);
+        this.jobs.set(jobId, job);
+        logger.info('Scheduled daily cleanup');
+    }
+    async runCleanup() {
+        if (!this.supabase)
+            return;
+        logger.info('Running cleanup job');
+        // Delete old processing logs (older than 30 days)
+        const thirtyDaysAgo = new Date();
+        thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+        const { error: logsError } = await this.supabase
+            .from('processing_logs')
+            .delete()
+            .lt('started_at', thirtyDaysAgo.toISOString());
+        if (logsError) {
+            logger.error('Failed to cleanup old logs', logsError);
+        }
+        // Delete emails that were trashed more than 7 days ago
+        const sevenDaysAgo = new Date();
+        sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
+        const { error: emailsError } = await this.supabase
+            .from('emails')
+            .delete()
+            .eq('action_taken', 'delete')
+            .lt('created_at', sevenDaysAgo.toISOString());
+        if (emailsError) {
+            logger.error('Failed to cleanup old emails', emailsError);
+        }
+        logger.info('Cleanup completed');
+    }
+    getJobStatus() {
+        return Array.from(this.jobs.values()).map(job => ({
+            id: job.id,
+            name: job.name,
+            lastRun: job.lastRun,
+            isRunning: job.isRunning,
+        }));
+    }
+}
+// Singleton
+let schedulerInstance = null;
+export function getScheduler() {
+    if (!schedulerInstance) {
+        schedulerInstance = new SyncScheduler();
+    }
+    return schedulerInstance;
+}
+export function startScheduler() {
+    getScheduler().start();
+}
+export function stopScheduler() {
+    if (schedulerInstance) {
+        schedulerInstance.stop();
+    }
+}

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

@@ -0,0 +1,59 @@
+import { createClient } from '@supabase/supabase-js';
+import { config } from '../config/index.js';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('SupabaseService');
+let serverClient = null;
+export function isValidUrl(url) {
+    try {
+        return url.startsWith('http://') || url.startsWith('https://');
+    }
+    catch {
+        return false;
+    }
+}
+export function getServerSupabase() {
+    if (serverClient)
+        return serverClient;
+    const url = config.supabase.url;
+    const key = config.supabase.anonKey;
+    if (!url || !key || !isValidUrl(url)) {
+        logger.warn('Supabase not configured or invalid URL - skipping client initialization', {
+            url: url || 'missing'
+        });
+        return null;
+    }
+    try {
+        serverClient = createClient(url, key, {
+            auth: {
+                autoRefreshToken: false,
+                persistSession: false,
+            },
+        });
+        logger.info('Server Supabase client initialized');
+        return serverClient;
+    }
+    catch (error) {
+        logger.error('Failed to initialize Supabase client', error);
+        return null;
+    }
+}
+export function getServiceRoleSupabase() {
+    const url = config.supabase.url;
+    const key = config.supabase.serviceRoleKey;
+    if (!url || !key || !isValidUrl(url)) {
+        logger.warn('Service role Supabase not configured or invalid URL');
+        return null;
+    }
+    try {
+        return createClient(url, key, {
+            auth: {
+                autoRefreshToken: false,
+                persistSession: false,
+            },
+        });
+    }
+    catch (error) {
+        logger.error('Failed to initialize Service Role Supabase client', error);
+        return null;
+    }
+}

package/dist/api/src/utils/contentCleaner.js

@@ -0,0 +1,94 @@
+export class ContentCleaner {
+    /**
+     * Cleans email body by removing noise, quoted replies, and footers.
+     * Ported from Python ContentCleaner.
+     */
+    static cleanEmailBody(text) {
+        if (!text)
+            return "";
+        // 0. Lightweight HTML -> Markdown Conversion
+        // Structure: <br>, <p> -> Newlines
+        text = text.replace(/<br\s*\/?\?>/gi, '\n');
+        text = text.replace(/<\/p>/gi, '\n\n');
+        text = text.replace(/<p.*?>/gi, ''); // Open p tags just gone
+        // Structure: Headers <h1>-<h6> -> # Title
+        text = text.replace(/<h[1-6].*?>(.*?)<\/h[1-6]>/gsi, (match, p1) => `\n# ${p1}\n`);
+        // Structure: Lists <li> -> - Item
+        text = text.replace(/<li.*?>(.*?)<\/li>/gsi, (match, p1) => `\n- ${p1}`);
+        text = text.replace(/<ul.*?>/gi, '');
+        text = text.replace(/<\/ul>/gi, '\n');
+        // Links: <a href=\"...\">text</a> -> [text](href)
+        text = text.replace(/<a\s+(?:[^>]*?\s+)?href=\"([^\"]*)\"[^>]*>(.*?)<\/a>/gsi, (match, href, content) => `[${content}](${href})`);
+        // Images: <img src=\"...\" alt=\"...\"> -> ![alt](src)
+        text = text.replace(/<img\s+(?:[^>]*?\s+)?src=\"([^\"]*)\"(?:[^>]*?\s+)?alt=\"([^\"]*)\"[^>]*>/gsi, (match, src, alt) => `![${alt}](${src})`);
+        // Style/Script removal (strictly remove content)
+        text = text.replace(/<script.*?>.*?<\/script>/gsi, '');
+        text = text.replace(/<style.*?>.*?<\/style>/gsi, '');
+        // Final Strip of remaining tags
+        text = text.replace(/<[^>]+>/g, ' ');
+        // Entity decoding (Basic)
+        text = text.replace(/&nbsp;/gi, ' ');
+        text = text.replace(/&amp;/gi, '&');
+        text = text.replace(/&lt;/gi, '<');
+        text = text.replace(/&gt;/gi, '>');
+        text = text.replace(/&quot;/gi, '"');
+        text = text.replace(/&#39;/gi, "'");
+        const lines = text.split('\n');
+        const cleanedLines = [];
+        // Heuristics for reply headers
+        const replyHeaderPatterns = [
+            /^On .* wrote:$/i,
+            /^From: .*$/i,
+            /^Sent: .*$/i,
+            /^To: .*$/i,
+            /^Subject: .*$/i
+        ];
+        // Heuristics for footers
+        const footerPatterns = [
+            /unsubscribe/i,
+            /privacy policy/i,
+            /terms of service/i,
+            /view in browser/i,
+            /copyright \d{4}/i
+        ];
+        for (let line of lines) {
+            let lineStripped = line.trim();
+            // 2. Quoted text removal (lines starting with >)
+            if (lineStripped.startsWith('>')) {
+                continue;
+            }
+            // 3. Check for specific reply separators
+            // If we hit a reply header, we truncate the rest (Aggressive strategy per Python code)
+            if (/^On .* wrote:$/i.test(lineStripped)) {
+                break;
+            }
+            // 4. Footer removal (simple check on short lines)
+            if (lineStripped.length < 100) {
+                let isFooter = false;
+                for (const pattern of footerPatterns) {
+                    if (pattern.test(lineStripped)) {
+                        isFooter = true;
+                        break;
+                    }
+                }
+                if (isFooter) {
+                    continue;
+                }
+            }
+            cleanedLines.push(line);
+        }
+        // Reassemble
+        text = cleanedLines.join('\n');
+        // Collapse multiple newlines
+        text = text.replace(/\n{3,}/g, '\n\n');
+        // Sanitize LLM Special Tokens (Prevent Prompt Injection/Confusion)
+        // Break sequences like <|channel|>, [INST], <s>
+        text = text.replace(/<\|/g, '< |');
+        text = text.replace(/\|>/g, '| >');
+        text = text.replace(/\[INST\]/gi, '[ INST ]');
+        text = text.replace(/\[\/INST\]/gi, '[ /INST ]');
+        text = text.replace(/<s>/gi, '&lt;s&gt;');
+        text = text.replace(/<\/s>/gi, '&lt;/s&gt;');
+        return text.trim();
+    }
+}

package/dist/api/src/utils/crypto.js

@@ -0,0 +1,68 @@
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'crypto';
+import { config } from '../config/index.js';
+// Edge Functions compatible encryption (matching supabase/functions/_shared/encryption.ts)
+const ALGORITHM = 'aes-256-gcm';
+const IV_LENGTH = 12; // Match Edge Functions
+const KEY_LENGTH = 32;
+function getKey() {
+    const secret = config.security.encryptionKey || 'dev-key-not-secure';
+    // Match Edge Functions key derivation: pad/slice to 32 chars
+    return Buffer.from(secret.padEnd(32, '0').slice(0, 32), 'utf8');
+}
+export function encryptToken(plaintext) {
+    if (!plaintext)
+        return '';
+    const iv = randomBytes(IV_LENGTH);
+    const key = getKey();
+    const cipher = createCipheriv(ALGORITHM, key, iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    // Format: base64(iv + ciphertext + tag) - compatible with Edge Functions
+    const combined = Buffer.concat([iv, encrypted, tag]);
+    return combined.toString('base64');
+}
+export function decryptToken(encrypted) {
+    if (!encrypted)
+        return '';
+    try {
+        // Try Edge Functions format first: base64(iv + ciphertext + tag)
+        const combined = Buffer.from(encrypted, 'base64');
+        if (combined.length < IV_LENGTH + 16) {
+            // Too short, might be plaintext
+            return encrypted;
+        }
+        const iv = combined.subarray(0, IV_LENGTH);
+        const tag = combined.subarray(combined.length - 16);
+        const data = combined.subarray(IV_LENGTH, combined.length - 16);
+        const key = getKey();
+        const decipher = createDecipheriv(ALGORITHM, key, iv);
+        decipher.setAuthTag(tag);
+        return Buffer.concat([decipher.update(data), decipher.final()]).toString('utf8');
+    }
+    catch (error) {
+        // Try legacy format: salt:iv:tag:encrypted
+        try {
+            const parts = encrypted.split(':');
+            if (parts.length === 4) {
+                const [saltB64, ivB64, tagB64, dataB64] = parts;
+                const salt = Buffer.from(saltB64, 'base64');
+                const iv = Buffer.from(ivB64, 'base64');
+                const tag = Buffer.from(tagB64, 'base64');
+                const data = Buffer.from(dataB64, 'base64');
+                const secret = config.security.encryptionKey || 'dev-key-not-secure';
+                const key = scryptSync(secret, salt, KEY_LENGTH);
+                const decipher = createDecipheriv(ALGORITHM, key, iv);
+                decipher.setAuthTag(tag);
+                return Buffer.concat([decipher.update(data), decipher.final()]).toString('utf8');
+            }
+        }
+        catch {
+            // Fall through to plaintext
+        }
+        // If all decryption fails, assume plaintext (for migration)
+        return encrypted;
+    }
+}
+export function generateSecureToken(length = 32) {
+    return randomBytes(length).toString('hex');
+}

package/dist/api/src/utils/logger.js

@@ -0,0 +1,119 @@
+import { config } from '../config/index.js';
+const LOG_COLORS = {
+    debug: '\x1b[36m', // cyan
+    info: '\x1b[32m', // green
+    warn: '\x1b[33m', // yellow
+    error: '\x1b[31m', // red
+    reset: '\x1b[0m',
+};
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+export class Logger {
+    minLevel;
+    context;
+    static supabaseClient = null;
+    static currentUserId = null;
+    constructor(context) {
+        this.minLevel = config.isProduction ? 'info' : 'debug';
+        this.context = context;
+    }
+    /**
+     * Set the Supabase client and current user ID for DB persistence.
+     * This is called by the auth middleware or server initialization.
+     */
+    static setPersistence(client, userId = null) {
+        Logger.supabaseClient = client;
+        Logger.currentUserId = userId;
+    }
+    shouldLog(level) {
+        return LOG_LEVELS[level] >= LOG_LEVELS[this.minLevel];
+    }
+    async saveToSupabase(level, message, meta) {
+        // Only persist warn and error levels to DB to prevent bloat
+        // unless explicitly forced via meta
+        const persistLevels = ['warn', 'error'];
+        const shouldPersist = persistLevels.includes(level) || meta?._persist === true;
+        if (shouldPersist && Logger.supabaseClient) {
+            try {
+                // Remove internal flags from meta before saving
+                const { _persist, ...cleanMeta } = meta || {};
+                await Logger.supabaseClient.from('system_logs').insert({
+                    user_id: Logger.currentUserId,
+                    level,
+                    source: this.context || 'System',
+                    message,
+                    metadata: cleanMeta,
+                    created_at: new Date().toISOString()
+                });
+            }
+            catch (err) {
+                // Fail silently to avoid infinite loops if logging fails
+                console.error('[Logger] Failed to persist log to Supabase:', err);
+            }
+        }
+    }
+    formatMessage(level, message, meta) {
+        const timestamp = new Date().toISOString();
+        const contextStr = this.context ? `[${this.context}]` : '';
+        const { _persist, ...cleanMeta } = meta || {};
+        const metaStr = Object.keys(cleanMeta).length > 0 ? ` ${JSON.stringify(cleanMeta)}` : '';
+        if (config.isProduction) {
+            return JSON.stringify({
+                timestamp,
+                level,
+                context: this.context,
+                message,
+                ...cleanMeta,
+            });
+        }
+        const color = LOG_COLORS[level];
+        const reset = LOG_COLORS.reset;
+        return `${timestamp} ${color}${level.toUpperCase().padEnd(5)}${reset} ${contextStr} ${message}${metaStr}`;
+    }
+    debug(message, meta) {
+        if (this.shouldLog('debug')) {
+            console.debug(this.formatMessage('debug', message, meta));
+            this.saveToSupabase('debug', message, meta);
+        }
+    }
+    info(message, meta) {
+        if (this.shouldLog('info')) {
+            console.info(this.formatMessage('info', message, meta));
+            this.saveToSupabase('info', message, meta);
+        }
+    }
+    warn(message, meta) {
+        if (this.shouldLog('warn')) {
+            console.warn(this.formatMessage('warn', message, meta));
+            this.saveToSupabase('warn', message, meta);
+        }
+    }
+    error(message, error, meta) {
+        if (this.shouldLog('error')) {
+            const errorMeta = { ...meta };
+            if (error instanceof Error) {
+                errorMeta.errorName = error.name;
+                errorMeta.errorMessage = error.message;
+                errorMeta.stack = error.stack;
+            }
+            else if (error) {
+                errorMeta.error = error;
+            }
+            console.error(this.formatMessage('error', message, errorMeta));
+            this.saveToSupabase('error', message, errorMeta);
+        }
+    }
+    child(context) {
+        return new Logger(this.context ? `${this.context}:${context}` : context);
+    }
+}
+// Default logger instance
+export const logger = new Logger();
+// Factory for creating contextual loggers
+export function createLogger(context) {
+    return new Logger(context);
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@realtimex/email-automator",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "type": "module",
-  "main": "api/server.ts",
+  "main": "dist/api/server.js",
   "bin": {
     "email-automator": "./bin/email-automator.js",
     "email-automator-setup": "./bin/email-automator-setup.js",
@@ -30,10 +30,11 @@
   "scripts": {
     "dev": "vite",
     "dev:api": "tsx watch api/server.ts",
-    "build": "tsc && vite build",
+    "build": "npm run build:ui && npm run build:api",
+    "build:ui": "vite build",
     "build:api": "tsc -p tsconfig.api.json",
     "preview": "vite preview",
-    "serve": "tsx api/server.ts",
+    "serve": "node dist/api/server.js",
     "start": "node dist/api/server.js",
     "test": "vitest",
     "test:run": "vitest run",