@realtimex/email-automator 2.11.2 → 2.12.0

package/api/src/routes/index.ts

@@ -8,6 +8,7 @@ import settingsRoutes from './settings.js';
 import emailsRoutes from './emails.js';
 import migrateRoutes from './migrate.js';
 import sdkRoutes from './sdk.js';
+import rulePacksRoutes from './rulePacks.js';
 
 const router = Router();
 
@@ -20,5 +21,6 @@ router.use('/settings', settingsRoutes);
 router.use('/emails', emailsRoutes);
 router.use('/migrate', migrateRoutes);
 router.use('/sdk', sdkRoutes);
+router.use('/rule-packs', rulePacksRoutes);
 
 export default router;

package/api/src/routes/rulePacks.ts

@@ -0,0 +1,204 @@
+/**
+ * Rule Pack Routes - Zero-Configuration UX
+ *
+ * Endpoints for managing rule pack installations and user role selection
+ */
+
+import { Router, Request, Response } from 'express';
+import { createLogger } from '../utils/logger.js';
+import { RulePackService } from '../services/RulePackService.js';
+import { getAllPacks, getPackById, getPacksForRole } from '../services/rulePacks/index.js';
+import type { UserRole } from '../services/rulePacks/types.js';
+
+const router = Router();
+const logger = createLogger('RulePackRoutes');
+
+/**
+ * GET /api/rule-packs
+ * List all available rule packs
+ */
+router.get('/', async (req: Request, res: Response) => {
+  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: any) {
+    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: Request, res: Response) => {
+  try {
+    const packId = req.params.packId as string;
+    const pack = getPackById(packId);
+
+    if (!pack) {
+      return res.status(404).json({ success: false, error: 'Pack not found' });
+    }
+
+    res.json({ success: true, pack });
+  } catch (error: any) {
+    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: Request, res: Response) => {
+  try {
+    const { packId } = req.body;
+    const supabase = (req as any).supabase;
+    const userId = (req as any).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: any) {
+    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: Request, res: Response) => {
+  try {
+    const { packId } = req.body;
+    const supabase = (req as any).supabase;
+    const userId = (req as any).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: any) {
+    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: Request, res: Response) => {
+  try {
+    const supabase = (req as any).supabase;
+    const userId = (req as any).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: any) {
+    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: Request, res: Response) => {
+  try {
+    const { role } = req.body;
+    const supabase = (req as any).supabase;
+    const userId = (req as any).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: UserRole[] = ['executive', 'developer', 'sales', 'operations', 'marketing', 'other'];
+    if (!validRoles.includes(role as UserRole)) {
+      return res.status(400).json({ success: false, error: 'Invalid role' });
+    }
+
+    const service = new RulePackService(supabase);
+    const result = await service.updateUserRole(userId, role as UserRole, 'onboarding');
+
+    logger.info(`User ${userId} set role to ${role}, installed ${result.packsInstalled.length} packs`);
+
+    res.json(result);
+  } catch (error: any) {
+    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: Request, res: Response) => {
+  try {
+    const { role } = req.params;
+    const packs = getPacksForRole(role as UserRole);
+
+    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: any) {
+    logger.error('Failed to get packs for role', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+export default router;

package/api/src/services/RulePackService.ts

@@ -0,0 +1,354 @@
+/**
+ * Rule Pack Service - Zero-Configuration Email Automation
+ *
+ * Handles installation, management, and tracking of rule packs for users.
+ */
+
+import { SupabaseClient } from '@supabase/supabase-js';
+import { createLogger } from '../utils/logger.js';
+import { getPackById, getPacksForRole, ALL_PACKS } from './rulePacks/index.js';
+import type { RulePack, RuleTemplate, UserRole } from './rulePacks/types.js';
+import type { Rule, PackInstallation } from './supabase.js';
+
+const logger = createLogger('RulePackService');
+
+export class RulePackService {
+  constructor(private supabase: SupabaseClient) {}
+
+  /**
+   * Install a rule pack for a user
+   * Creates all rules from the pack and tracks installation
+   */
+  async installPack(userId: string, packId: string): Promise<{ success: boolean; rulesCreated: number; error?: string }> {
+    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 as any,
+            actions: template.actions as any,
+            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: any) {
+      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: string, packId: string): Promise<{ success: boolean; error?: string }> {
+    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: any) {
+      logger.error(`Error uninstalling pack '${packId}'`, error);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Get all installed packs for a user
+   */
+  async getInstalledPacks(userId: string): Promise<PackInstallation[]> {
+    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: string,
+    role: UserRole,
+    source: 'onboarding' | 'manual' = 'onboarding'
+  ): Promise<{ success: boolean; packsInstalled: string[]; error?: string }> {
+    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: string[] = [];
+
+      // 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: any) {
+      logger.error(`Error updating user role`, error);
+      return { success: false, packsInstalled: [], error: error.message };
+    }
+  }
+
+  /**
+   * Install a pack with a specific source tracking
+   */
+  private async installPackWithSource(
+    userId: string,
+    packId: string,
+    source: 'onboarding' | 'manual' | 'auto'
+  ): Promise<{ success: boolean; rulesCreated: number; error?: string }> {
+    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 as any,
+          actions: template.actions as any,
+          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: string): Promise<{
+    totalInstallations: number;
+    activeInstallations: number;
+    uninstallations: number;
+  }> {
+    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: string): Promise<{ success: boolean; installed: boolean }> {
+    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: any) {
+      logger.error('Failed to ensure universal pack', error);
+      return { success: false, installed: false };
+    }
+  }
+}
+
+/**
+ * Get singleton instance (convenience)
+ */
+let defaultInstance: RulePackService | null = null;
+
+export function getRulePackService(supabase: SupabaseClient): RulePackService {
+  if (!defaultInstance) {
+    defaultInstance = new RulePackService(supabase);
+  }
+  return defaultInstance;
+}

package/api/src/services/SDKService.ts

@@ -161,9 +161,10 @@ export class SDKService {
 
                 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;
             }
 
@@ -172,7 +173,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;
@@ -221,9 +223,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;
                 }
             }
@@ -245,7 +248,11 @@ export class SDKService {
     static async resolveChatProvider(settings: { llm_provider?: string; llm_model?: string }): Promise<ProviderResult> {
         // 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
@@ -258,7 +265,11 @@ export class SDKService {
     static async resolveEmbedProvider(settings: { embedding_provider?: string; embedding_model?: string }): Promise<ProviderResult> {
         // 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