@realtimex/email-automator 2.11.3 → 2.12.1

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/gmail.ts

@@ -441,6 +441,74 @@ export class GmailService {
         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: EmailAccount, labelPath: string): Promise<string> {
+        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: string | undefined;
+
+        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: EmailAccount, messageId: string, labelName: string): Promise<void> {
+        const labelId = await this.getOrCreateLabel(account, labelName);
+        await this.addLabel(account, messageId, [labelId]);
+        logger.debug('Applied label to message', { messageId, labelName, labelId });
+    }
+
     private async fetchAttachment(supabase: SupabaseClient, path: string): Promise<Uint8Array> {
         const { data, error } = await supabase.storage
             .from('rule-attachments')