@realtimex/email-automator 2.11.2 → 2.12.0

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

@@ -0,0 +1,179 @@
+/**
+ * Rule Pack Routes - Zero-Configuration UX
+ *
+ * Endpoints for managing rule pack installations and user role selection
+ */
+import { Router } from 'express';
+import { createLogger } from '../utils/logger.js';
+import { RulePackService } from '../services/RulePackService.js';
+import { getAllPacks, getPackById, getPacksForRole } from '../services/rulePacks/index.js';
+const router = Router();
+const logger = createLogger('RulePackRoutes');
+/**
+ * GET /api/rule-packs
+ * List all available rule packs
+ */
+router.get('/', async (req, res) => {
+    try {
+        const packs = getAllPacks();
+        res.json({
+            success: true,
+            packs: packs.map(pack => ({
+                id: pack.id,
+                name: pack.name,
+                description: pack.description,
+                icon: pack.icon,
+                ruleCount: pack.rules.length,
+                targetRoles: pack.target_roles
+            }))
+        });
+    }
+    catch (error) {
+        logger.error('Failed to list packs', error);
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+/**
+ * GET /api/rule-packs/:packId
+ * Get details of a specific pack
+ */
+router.get('/:packId', async (req, res) => {
+    try {
+        const packId = req.params.packId;
+        const pack = getPackById(packId);
+        if (!pack) {
+            return res.status(404).json({ success: false, error: 'Pack not found' });
+        }
+        res.json({ success: true, pack });
+    }
+    catch (error) {
+        logger.error('Failed to get pack', error);
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+/**
+ * POST /api/rule-packs/install
+ * Install a rule pack for the authenticated user
+ * Body: { packId: string }
+ */
+router.post('/install', async (req, res) => {
+    try {
+        const { packId } = req.body;
+        const supabase = req.supabase;
+        const userId = req.userId;
+        if (!packId) {
+            return res.status(400).json({ success: false, error: 'packId is required' });
+        }
+        if (!userId) {
+            return res.status(401).json({ success: false, error: 'Unauthorized' });
+        }
+        const service = new RulePackService(supabase);
+        const result = await service.installPack(userId, packId);
+        res.json(result);
+    }
+    catch (error) {
+        logger.error('Failed to install pack', error);
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+/**
+ * POST /api/rule-packs/uninstall
+ * Uninstall a rule pack
+ * Body: { packId: string }
+ */
+router.post('/uninstall', async (req, res) => {
+    try {
+        const { packId } = req.body;
+        const supabase = req.supabase;
+        const userId = req.userId;
+        if (!packId) {
+            return res.status(400).json({ success: false, error: 'packId is required' });
+        }
+        if (!userId) {
+            return res.status(401).json({ success: false, error: 'Unauthorized' });
+        }
+        const service = new RulePackService(supabase);
+        const result = await service.uninstallPack(userId, packId);
+        res.json(result);
+    }
+    catch (error) {
+        logger.error('Failed to uninstall pack', error);
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+/**
+ * GET /api/rule-packs/installed
+ * Get user's installed packs
+ */
+router.get('/installed', async (req, res) => {
+    try {
+        const supabase = req.supabase;
+        const userId = req.userId;
+        if (!userId) {
+            return res.status(401).json({ success: false, error: 'Unauthorized' });
+        }
+        const service = new RulePackService(supabase);
+        const installations = await service.getInstalledPacks(userId);
+        res.json({ success: true, installations });
+    }
+    catch (error) {
+        logger.error('Failed to get installed packs', error);
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+/**
+ * POST /api/rule-packs/set-role
+ * Set user role and install appropriate packs
+ * Body: { role: UserRole }
+ */
+router.post('/set-role', async (req, res) => {
+    try {
+        const { role } = req.body;
+        const supabase = req.supabase;
+        const userId = req.userId;
+        if (!role) {
+            return res.status(400).json({ success: false, error: 'role is required' });
+        }
+        if (!userId) {
+            return res.status(401).json({ success: false, error: 'Unauthorized' });
+        }
+        const validRoles = ['executive', 'developer', 'sales', 'operations', 'marketing', 'other'];
+        if (!validRoles.includes(role)) {
+            return res.status(400).json({ success: false, error: 'Invalid role' });
+        }
+        const service = new RulePackService(supabase);
+        const result = await service.updateUserRole(userId, role, 'onboarding');
+        logger.info(`User ${userId} set role to ${role}, installed ${result.packsInstalled.length} packs`);
+        res.json(result);
+    }
+    catch (error) {
+        logger.error('Failed to set user role', error);
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+/**
+ * GET /api/rule-packs/for-role/:role
+ * Get recommended packs for a specific role
+ */
+router.get('/for-role/:role', async (req, res) => {
+    try {
+        const { role } = req.params;
+        const packs = getPacksForRole(role);
+        res.json({
+            success: true,
+            role,
+            packs: packs.map(pack => ({
+                id: pack.id,
+                name: pack.name,
+                description: pack.description,
+                icon: pack.icon,
+                ruleCount: pack.rules.length
+            }))
+        });
+    }
+    catch (error) {
+        logger.error('Failed to get packs for role', error);
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+export default router;

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

@@ -0,0 +1,296 @@
+/**
+ * Rule Pack Service - Zero-Configuration Email Automation
+ *
+ * Handles installation, management, and tracking of rule packs for users.
+ */
+import { createLogger } from '../utils/logger.js';
+import { getPackById, getPacksForRole } from './rulePacks/index.js';
+const logger = createLogger('RulePackService');
+export class RulePackService {
+    supabase;
+    constructor(supabase) {
+        this.supabase = supabase;
+    }
+    /**
+     * Install a rule pack for a user
+     * Creates all rules from the pack and tracks installation
+     */
+    async installPack(userId, packId) {
+        try {
+            const pack = getPackById(packId);
+            if (!pack) {
+                return { success: false, rulesCreated: 0, error: `Pack '${packId}' not found` };
+            }
+            logger.info(`Installing pack '${packId}' for user ${userId}`);
+            // Check if pack is already installed
+            const { data: existing } = await this.supabase
+                .from('pack_installations')
+                .select('*')
+                .eq('user_id', userId)
+                .eq('pack_id', packId)
+                .is('uninstalled_at', null)
+                .single();
+            if (existing) {
+                logger.info(`Pack '${packId}' already installed for user ${userId}`);
+                return { success: true, rulesCreated: 0 }; // Already installed, no-op
+            }
+            // Create all rules from the pack
+            let rulesCreated = 0;
+            for (const template of pack.rules) {
+                // Check if rule already exists (by rule_template_id)
+                const { data: existingRule } = await this.supabase
+                    .from('rules')
+                    .select('id')
+                    .eq('user_id', userId)
+                    .eq('rule_template_id', template.id)
+                    .single();
+                if (existingRule) {
+                    logger.debug(`Rule '${template.id}' already exists, skipping`);
+                    continue;
+                }
+                // Create rule from template
+                const { error: ruleError } = await this.supabase
+                    .from('rules')
+                    .insert({
+                    user_id: userId,
+                    name: template.name,
+                    description: template.description,
+                    intent: template.intent,
+                    priority: template.priority,
+                    condition: template.condition,
+                    actions: template.actions,
+                    instructions: template.instructions,
+                    is_enabled: template.is_enabled_by_default,
+                    pack: packId,
+                    rule_template_id: template.id,
+                    is_system_managed: true
+                });
+                if (ruleError) {
+                    logger.error(`Failed to create rule '${template.id}'`, ruleError);
+                    continue; // Continue with other rules even if one fails
+                }
+                rulesCreated++;
+            }
+            // Track pack installation
+            const { error: installError } = await this.supabase
+                .from('pack_installations')
+                .insert({
+                user_id: userId,
+                pack_id: packId,
+                source: 'manual'
+            });
+            if (installError) {
+                logger.error(`Failed to track pack installation`, installError);
+                // Don't fail the whole operation if tracking fails
+            }
+            logger.info(`Successfully installed pack '${packId}' with ${rulesCreated} rules`);
+            return { success: true, rulesCreated };
+        }
+        catch (error) {
+            logger.error(`Error installing pack '${packId}'`, error);
+            return { success: false, rulesCreated: 0, error: error.message };
+        }
+    }
+    /**
+     * Uninstall a rule pack for a user
+     * Disables all rules from the pack and marks it as uninstalled
+     */
+    async uninstallPack(userId, packId) {
+        try {
+            logger.info(`Uninstalling pack '${packId}' for user ${userId}`);
+            // Disable all rules from this pack
+            const { error: disableError } = await this.supabase
+                .from('rules')
+                .update({ is_enabled: false })
+                .eq('user_id', userId)
+                .eq('pack', packId);
+            if (disableError) {
+                logger.error(`Failed to disable pack rules`, disableError);
+                return { success: false, error: disableError.message };
+            }
+            // Mark pack as uninstalled
+            const { error: uninstallError } = await this.supabase
+                .from('pack_installations')
+                .update({ uninstalled_at: new Date().toISOString() })
+                .eq('user_id', userId)
+                .eq('pack_id', packId)
+                .is('uninstalled_at', null);
+            if (uninstallError) {
+                logger.error(`Failed to mark pack as uninstalled`, uninstallError);
+                return { success: false, error: uninstallError.message };
+            }
+            logger.info(`Successfully uninstalled pack '${packId}'`);
+            return { success: true };
+        }
+        catch (error) {
+            logger.error(`Error uninstalling pack '${packId}'`, error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Get all installed packs for a user
+     */
+    async getInstalledPacks(userId) {
+        const { data, error } = await this.supabase
+            .from('pack_installations')
+            .select('*')
+            .eq('user_id', userId)
+            .is('uninstalled_at', null)
+            .order('installed_at', { ascending: false });
+        if (error) {
+            logger.error('Failed to fetch installed packs', error);
+            return [];
+        }
+        return data || [];
+    }
+    /**
+     * Update user role and install appropriate packs
+     * This is the main entry point for onboarding
+     */
+    async updateUserRole(userId, role, source = 'onboarding') {
+        try {
+            logger.info(`Updating user role to '${role}' for user ${userId}`);
+            // 1. Update user settings
+            const { error: settingsError } = await this.supabase
+                .from('user_settings')
+                .update({
+                user_role: role,
+                onboarding_completed: true
+            })
+                .eq('user_id', userId);
+            if (settingsError) {
+                logger.error('Failed to update user settings', settingsError);
+                return { success: false, packsInstalled: [], error: settingsError.message };
+            }
+            // 2. Get packs for this role
+            const packs = getPacksForRole(role);
+            const packsInstalled = [];
+            // 3. Install each pack
+            for (const pack of packs) {
+                const result = await this.installPackWithSource(userId, pack.id, source);
+                if (result.success) {
+                    packsInstalled.push(pack.id);
+                }
+            }
+            logger.info(`Successfully set up ${packsInstalled.length} packs for role '${role}'`);
+            return { success: true, packsInstalled };
+        }
+        catch (error) {
+            logger.error(`Error updating user role`, error);
+            return { success: false, packsInstalled: [], error: error.message };
+        }
+    }
+    /**
+     * Install a pack with a specific source tracking
+     */
+    async installPackWithSource(userId, packId, source) {
+        const pack = getPackById(packId);
+        if (!pack) {
+            return { success: false, rulesCreated: 0, error: `Pack '${packId}' not found` };
+        }
+        // Check if already installed
+        const { data: existing } = await this.supabase
+            .from('pack_installations')
+            .select('*')
+            .eq('user_id', userId)
+            .eq('pack_id', packId)
+            .is('uninstalled_at', null)
+            .single();
+        if (existing) {
+            return { success: true, rulesCreated: 0 }; // Already installed
+        }
+        // Create rules
+        let rulesCreated = 0;
+        for (const template of pack.rules) {
+            const { data: existingRule } = await this.supabase
+                .from('rules')
+                .select('id')
+                .eq('user_id', userId)
+                .eq('rule_template_id', template.id)
+                .single();
+            if (existingRule)
+                continue;
+            const { error } = await this.supabase
+                .from('rules')
+                .insert({
+                user_id: userId,
+                name: template.name,
+                description: template.description,
+                intent: template.intent,
+                priority: template.priority,
+                condition: template.condition,
+                actions: template.actions,
+                instructions: template.instructions,
+                is_enabled: template.is_enabled_by_default,
+                pack: packId,
+                rule_template_id: template.id,
+                is_system_managed: true
+            });
+            if (!error)
+                rulesCreated++;
+        }
+        // Track installation
+        await this.supabase
+            .from('pack_installations')
+            .insert({
+            user_id: userId,
+            pack_id: packId,
+            source
+        });
+        return { success: true, rulesCreated };
+    }
+    /**
+     * Get pack metrics (how many users have it installed, etc.)
+     */
+    async getPackMetrics(packId) {
+        const { data: all } = await this.supabase
+            .from('pack_installations')
+            .select('*')
+            .eq('pack_id', packId);
+        const total = all?.length || 0;
+        const active = all?.filter(p => !p.uninstalled_at).length || 0;
+        const uninstalled = all?.filter(p => p.uninstalled_at).length || 0;
+        return {
+            totalInstallations: total,
+            activeInstallations: active,
+            uninstallations: uninstalled
+        };
+    }
+    /**
+     * Auto-install universal pack for new users
+     * Called during signup or first sync
+     */
+    async ensureUniversalPack(userId) {
+        try {
+            // Check if user already has universal pack
+            const { data: existing } = await this.supabase
+                .from('pack_installations')
+                .select('*')
+                .eq('user_id', userId)
+                .eq('pack_id', 'universal')
+                .is('uninstalled_at', null)
+                .single();
+            if (existing) {
+                return { success: true, installed: false }; // Already has it
+            }
+            // Install universal pack
+            const result = await this.installPackWithSource(userId, 'universal', 'auto');
+            logger.info(`Auto-installed Universal Pack for new user ${userId}`);
+            return { success: result.success, installed: true };
+        }
+        catch (error) {
+            logger.error('Failed to ensure universal pack', error);
+            return { success: false, installed: false };
+        }
+    }
+}
+/**
+ * Get singleton instance (convenience)
+ */
+let defaultInstance = null;
+export function getRulePackService(supabase) {
+    if (!defaultInstance) {
+        defaultInstance = new RulePackService(supabase);
+    }
+    return defaultInstance;
+}

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

@@ -133,9 +133,10 @@ export class SDKService {
                 const preferredModel = preferredProvider.models.find(m => m.id === this.DEFAULT_LLM_MODEL) || preferredProvider.models[0];
                 this.defaultChatProvider = {
                     provider: preferredProvider.provider,
-                    model: preferredModel.id
+                    model: preferredModel.id,
+                    isDefaultFallback: false
                 };
-                logger.info(`Using preferred default chat provider: ${this.defaultChatProvider.provider}/${this.defaultChatProvider.model}`);
+                logger.info(`Using preferred chat provider: ${this.defaultChatProvider.provider}/${this.defaultChatProvider.model}`);
                 return this.defaultChatProvider;
             }
             // 2. Fallback to the first provider with available models
@@ -143,7 +144,8 @@ export class SDKService {
                 if (p.models && p.models.length > 0) {
                     this.defaultChatProvider = {
                         provider: p.provider,
-                        model: p.models[0].id
+                        model: p.models[0].id,
+                        isDefaultFallback: true
                     };
                     logger.info(`Defaulting to first available chat provider: ${this.defaultChatProvider.provider}/${this.defaultChatProvider.model}`);
                     return this.defaultChatProvider;
@@ -183,9 +185,10 @@ export class SDKService {
                 if (p.models && p.models.length > 0) {
                     this.defaultEmbedProvider = {
                         provider: p.provider,
-                        model: p.models[0].id
+                        model: p.models[0].id,
+                        isDefaultFallback: true
                     };
-                    logger.info(`Default embed provider: ${this.defaultEmbedProvider.provider}/${this.defaultEmbedProvider.model}`);
+                    logger.info(`Selected embed provider: ${this.defaultEmbedProvider.provider}/${this.defaultEmbedProvider.model}`);
                     return this.defaultEmbedProvider;
                 }
             }
@@ -206,7 +209,11 @@ export class SDKService {
     static async resolveChatProvider(settings) {
         // If both provider and model are set in settings, use them
         if (settings.llm_provider && settings.llm_model) {
-            return { provider: settings.llm_provider, model: settings.llm_model };
+            return {
+                provider: settings.llm_provider,
+                model: settings.llm_model,
+                isDefaultFallback: false
+            };
         }
         // Try to get from SDK discovery first
         return await this.getDefaultChatProvider();
@@ -217,7 +224,11 @@ export class SDKService {
     static async resolveEmbedProvider(settings) {
         // If both provider and model are set in settings, use them
         if (settings.embedding_provider && settings.embedding_model) {
-            return { provider: settings.embedding_provider, model: settings.embedding_model };
+            return {
+                provider: settings.embedding_provider,
+                model: settings.embedding_model,
+                isDefaultFallback: false
+            };
         }
         // Try to get from SDK discovery first
         return await this.getDefaultEmbedProvider();

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

@@ -333,6 +333,62 @@ export class GmailService {
         await this.addLabel(account, messageId, ['STARRED']);
         logger.debug('Message starred', { messageId });
     }
+    /**
+     * Get or create a label by name (supports nested labels like "Finance/Receipts")
+     * Returns the label ID
+     */
+    async getOrCreateLabel(account, labelPath) {
+        const gmail = await this.getAuthenticatedClient(account);
+        // List existing labels
+        const { data: labelsData } = await gmail.users.labels.list({ userId: 'me' });
+        const existingLabels = labelsData.labels || [];
+        // Check if label already exists
+        const existingLabel = existingLabels.find(l => l.name === labelPath);
+        if (existingLabel?.id) {
+            logger.debug('Label already exists', { labelPath, labelId: existingLabel.id });
+            return existingLabel.id;
+        }
+        // Create nested labels if needed (e.g., "Finance/Receipts" creates "Finance" then "Finance/Receipts")
+        const parts = labelPath.split('/');
+        let currentPath = '';
+        let parentId;
+        for (const part of parts) {
+            currentPath = currentPath ? `${currentPath}/${part}` : part;
+            // Check if this level exists
+            const existing = existingLabels.find(l => l.name === currentPath);
+            if (existing?.id) {
+                parentId = existing.id;
+                continue;
+            }
+            // Create this level
+            const { data: newLabel } = await gmail.users.labels.create({
+                userId: 'me',
+                requestBody: {
+                    name: currentPath,
+                    labelListVisibility: 'labelShow',
+                    messageListVisibility: 'show'
+                }
+            });
+            if (!newLabel.id) {
+                throw new Error(`Failed to create label: ${currentPath}`);
+            }
+            logger.info('Created label', { labelPath: currentPath, labelId: newLabel.id });
+            parentId = newLabel.id;
+        }
+        if (!parentId) {
+            throw new Error(`Failed to get or create label: ${labelPath}`);
+        }
+        return parentId;
+    }
+    /**
+     * Apply a label to a message by label name (creates label if needed)
+     * Supports nested labels like "Finance/Receipts"
+     */
+    async applyLabelByName(account, messageId, labelName) {
+        const labelId = await this.getOrCreateLabel(account, labelName);
+        await this.addLabel(account, messageId, [labelId]);
+        logger.debug('Applied label to message', { messageId, labelName, labelId });
+    }
     async fetchAttachment(supabase, path) {
         const { data, error } = await supabase.storage
             .from('rule-attachments')