@realtimex/email-automator 2.1.1 → 2.2.1

package/src/context/AppContext.tsx

@@ -1,422 +0,0 @@
-import { createContext, useContext, useReducer, useEffect, ReactNode } from 'react';
-import { supabase } from '../lib/supabase';
-import { api, initializeApi } from '../lib/api';
-import { Email, EmailAccount, Rule, UserSettings, Stats, Profile } from '../lib/types';
-import { getSupabaseConfig } from '../lib/supabase-config';
-
-// Helper to extract error message from API response error
-function getErrorMessage(error: { message?: string; code?: string } | string | undefined, fallback: string): string {
-    if (!error) return fallback;
-    if (typeof error === 'string') return error;
-    return error.message || fallback;
-}
-
-// State
-interface AppState {
-    // Auth
-    user: any | null;
-    isAuthenticated: boolean;
-
-    // Data
-    profile: Profile | null;
-    emails: Email[];
-    accounts: EmailAccount[];
-    rules: Rule[];
-    settings: UserSettings | null;
-    stats: Stats | null;
-
-    // UI
-    isLoading: boolean;
-    isInitialized: boolean;
-    error: string | null;
-    selectedEmailId: string | null;
-
-    // Pagination
-    emailsTotal: number;
-    emailsOffset: number;
-}
-
-const initialState: AppState = {
-    user: null,
-    isAuthenticated: false,
-    profile: null,
-    emails: [],
-    accounts: [],
-    rules: [],
-    settings: null,
-    stats: null,
-    isLoading: true,
-    isInitialized: false,
-    error: null,
-    selectedEmailId: null,
-    emailsTotal: 0,
-    emailsOffset: 0,
-};
-
-// Actions
-type Action =
-    | { type: 'SET_USER'; payload: any }
-    | { type: 'SET_LOADING'; payload: boolean }
-    | { type: 'SET_INITIALIZED'; payload: boolean }
-    | { type: 'SET_ERROR'; payload: string | null }
-    | { type: 'SET_EMAILS'; payload: { emails: Email[]; total: number; offset: number } }
-    | { type: 'ADD_EMAIL'; payload: Email }
-    | { type: 'UPDATE_EMAIL'; payload: Email }
-    | { type: 'SET_PROFILE'; payload: Profile }
-    | { type: 'UPDATE_PROFILE'; payload: Profile }
-    | { type: 'SET_ACCOUNTS'; payload: EmailAccount[] }
-    | { type: 'ADD_ACCOUNT'; payload: EmailAccount }
-    | { type: 'REMOVE_ACCOUNT'; payload: string }
-    | { type: 'SET_RULES'; payload: Rule[] }
-    | { type: 'ADD_RULE'; payload: Rule }
-    | { type: 'UPDATE_RULE'; payload: Rule }
-    | { type: 'REMOVE_RULE'; payload: string }
-    | { type: 'SET_SETTINGS'; payload: UserSettings }
-    | { type: 'SET_STATS'; payload: Stats }
-    | { type: 'SET_SELECTED_EMAIL'; payload: string | null }
-    | { type: 'CLEAR_DATA' };
-
-function reducer(state: AppState, action: Action): AppState {
-    switch (action.type) {
-        case 'SET_USER':
-            return {
-                ...state,
-                user: action.payload,
-                isAuthenticated: !!action.payload,
-                isLoading: false,
-            };
-        case 'SET_LOADING':
-            return { ...state, isLoading: action.payload };
-        case 'SET_INITIALIZED':
-            return { ...state, isInitialized: action.payload };
-        case 'SET_ERROR':
-            return { ...state, error: action.payload, isLoading: false };
-        case 'SET_EMAILS':
-            return {
-                ...state,
-                emails: action.payload.emails,
-                emailsTotal: action.payload.total,
-                emailsOffset: action.payload.offset,
-            };
-        case 'ADD_EMAIL':
-            return {
-                ...state,
-                emails: [action.payload, ...state.emails],
-                emailsTotal: state.emailsTotal + 1,
-            };
-        case 'UPDATE_EMAIL':
-            return {
-                ...state,
-                emails: state.emails.map(e =>
-                    e.id === action.payload.id ? action.payload : e
-                ),
-            };
-        case 'SET_PROFILE':
-            return { ...state, profile: action.payload };
-        case 'UPDATE_PROFILE':
-            return { ...state, profile: action.payload };
-        case 'SET_ACCOUNTS':
-            return { ...state, accounts: action.payload };
-        case 'ADD_ACCOUNT':
-            return { ...state, accounts: [action.payload, ...state.accounts] };
-        case 'REMOVE_ACCOUNT':
-            return {
-                ...state,
-                accounts: state.accounts.filter(a => a.id !== action.payload),
-            };
-        case 'SET_RULES':
-            return { ...state, rules: action.payload };
-        case 'ADD_RULE':
-            return { ...state, rules: [action.payload, ...state.rules] };
-        case 'UPDATE_RULE':
-            return {
-                ...state,
-                rules: state.rules.map(r =>
-                    r.id === action.payload.id ? action.payload : r
-                ),
-            };
-        case 'REMOVE_RULE':
-            return {
-                ...state,
-                rules: state.rules.filter(r => r.id !== action.payload),
-            };
-        case 'SET_SETTINGS':
-            return { ...state, settings: action.payload };
-        case 'SET_STATS':
-            return { ...state, stats: action.payload };
-        case 'SET_SELECTED_EMAIL':
-            return { ...state, selectedEmailId: action.payload };
-        case 'CLEAR_DATA':
-            return { ...initialState, isLoading: false, isInitialized: true };
-        default:
-            return state;
-    }
-}
-
-// Context
-interface AppContextType {
-    state: AppState;
-    dispatch: React.Dispatch<Action>;
-    actions: {
-        fetchEmails: (params?: { category?: string; search?: string; offset?: number }) => Promise<void>;
-        fetchAccounts: () => Promise<void>;
-        fetchRules: () => Promise<void>;
-        fetchSettings: () => Promise<void>;
-        fetchProfile: () => Promise<void>;
-        fetchStats: () => Promise<void>;
-        executeAction: (emailId: string, action: string, draftContent?: string) => Promise<boolean>;
-        triggerSync: (accountId?: string) => Promise<boolean>;
-        disconnectAccount: (accountId: string) => Promise<boolean>;
-        updateSettings: (settings: Partial<UserSettings>) => Promise<boolean>;
-        updateProfile: (updates: { first_name?: string; last_name?: string; avatar_url?: string }) => Promise<boolean>;
-        updateAccount: (accountId: string, updates: Partial<EmailAccount>) => Promise<boolean>;
-        createRule: (rule: Omit<Rule, 'id' | 'user_id' | 'created_at'>) => Promise<boolean>;
-        deleteRule: (ruleId: string) => Promise<boolean>;
-        toggleRule: (ruleId: string) => Promise<boolean>;
-    };
-}
-
-const AppContext = createContext<AppContextType | null>(null);
-
-export function AppProvider({ children }: { children: ReactNode }) {
-    const [state, dispatch] = useReducer(reducer, initialState);
-
-    // Initialize auth
-    useEffect(() => {
-        async function init() {
-            // Check if we have valid Supabase config
-            const config = getSupabaseConfig();
-            if (!config) {
-                // No config - mark as initialized but not authenticated
-                // App.tsx will show SetupWizard
-                dispatch({ type: 'SET_INITIALIZED', payload: true });
-                return;
-            }
-
-            try {
-                // Validate connection before proceeding
-                // This catches cases where env vars are present but invalid
-                const { error: pingError } = await supabase.from('init_state').select('count', { count: 'exact', head: true });
-
-                // If we get an auth error (401/403) or connection error, the config is likely bad.
-                // However, RLS might deny access, which counts as a success connectivity-wise but a 403.
-                // WE MUST distinguishing between "Bad Key" (401) and "RLS Denied" (401/403?? usually 401 is bad key).
-                // Actually, init_state view is public or has specific RLS. 
-                // A bad key comes as a PostgrestError with code 'PGRST301' or similar, or just a 401 response.
-
-                if (pingError && pingError.message === 'Invalid API key') {
-                    console.error('[AppContext] Invalid API Key detected during init');
-                    // Clear invalid config if it was from storage? 
-                    // If it's env vars, we can't clear them, but we can ignore them?
-                    // App.tsx needs to know to show SetupWizard.
-                    // We can signal this by setting error or specific state.
-                    dispatch({ type: 'SET_INITIALIZED', payload: true }); // Let App render, but it might fail.
-                    return;
-                }
-
-                await initializeApi(supabase);
-
-                const { data: { session } } = await supabase.auth.getSession();
-                dispatch({ type: 'SET_USER', payload: session?.user || null });
-                dispatch({ type: 'SET_INITIALIZED', payload: true });
-
-                // Listen for auth changes
-                const { data: { subscription } } = supabase.auth.onAuthStateChange(
-                    (_event, session) => {
-                        dispatch({ type: 'SET_USER', payload: session?.user || null });
-                        if (!session) {
-                            dispatch({ type: 'CLEAR_DATA' });
-                        }
-                    }
-                );
-
-                return () => subscription.unsubscribe();
-            } catch (error) {
-                console.error('[AppContext] Init error:', error);
-
-                // If valid config exists but basic connection fails, we should probably let the user know 
-                // or fall back to setup.
-                // For now, just mark initialized so UI shows error state if needed.
-                dispatch({ type: 'SET_ERROR', payload: 'Failed to initialize' });
-                dispatch({ type: 'SET_INITIALIZED', payload: true });
-            }
-        }
-        init();
-    }, []);
-
-    // Actions
-    const actions = {
-        fetchEmails: async (params: { category?: string; search?: string; offset?: number } = {}) => {
-            const response = await api.getEmails({
-                limit: 20,
-                offset: params.offset || 0,
-                category: params.category,
-                search: params.search,
-            });
-            if (response.data) {
-                dispatch({
-                    type: 'SET_EMAILS',
-                    payload: {
-                        emails: response.data.emails,
-                        total: response.data.total,
-                        offset: params.offset || 0,
-                    }
-                });
-            }
-        },
-
-        fetchAccounts: async () => {
-            const response = await api.getAccounts();
-            if (response.data) {
-                dispatch({ type: 'SET_ACCOUNTS', payload: response.data.accounts });
-            }
-        },
-
-        fetchRules: async () => {
-            const response = await api.getRules();
-            if (response.data) {
-                dispatch({ type: 'SET_RULES', payload: response.data.rules });
-            }
-        },
-
-        fetchSettings: async () => {
-            const response = await api.getSettings();
-            if (response.data) {
-                dispatch({ type: 'SET_SETTINGS', payload: response.data.settings });
-            }
-        },
-
-        fetchProfile: async () => {
-            const response = await api.getProfile();
-            if (response.data) {
-                dispatch({ type: 'SET_PROFILE', payload: response.data });
-            }
-        },
-
-        fetchStats: async () => {
-            const response = await api.getStats();
-            if (response.data) {
-                dispatch({ type: 'SET_STATS', payload: response.data.stats });
-            }
-        },
-
-        executeAction: async (emailId: string, action: string, draftContent?: string) => {
-            const response = await api.executeAction(emailId, action, draftContent);
-            if (response.data?.success) {
-                // Update local state
-                const email = state.emails.find(e => e.id === emailId);
-                if (email) {
-                    dispatch({
-                        type: 'UPDATE_EMAIL',
-                        payload: { ...email, action_taken: action as any }
-                    });
-                }
-                return true;
-            }
-            dispatch({ type: 'SET_ERROR', payload: getErrorMessage(response.error, 'Action failed') });
-            return false;
-        },
-
-        triggerSync: async (accountId?: string) => {
-            const response = accountId
-                ? await api.triggerSync(accountId)
-                : await api.syncAll();
-            
-            // Always refresh accounts to show updated sync status
-            await actions.fetchAccounts();
-            
-            if (response.error) {
-                dispatch({ type: 'SET_ERROR', payload: getErrorMessage(response.error, 'Sync failed') });
-                return false;
-            }
-            return true;
-        },
-
-        disconnectAccount: async (accountId: string) => {
-            const response = await api.disconnectAccount(accountId);
-            if (response.data?.success) {
-                dispatch({ type: 'REMOVE_ACCOUNT', payload: accountId });
-                return true;
-            }
-            dispatch({ type: 'SET_ERROR', payload: getErrorMessage(response.error, 'Failed to disconnect') });
-            return false;
-        },
-
-        updateSettings: async (settings: Partial<UserSettings>) => {
-            const response = await api.updateSettings(settings);
-            if (response.data) {
-                dispatch({ type: 'SET_SETTINGS', payload: response.data.settings });
-                return true;
-            }
-            dispatch({ type: 'SET_ERROR', payload: getErrorMessage(response.error, 'Failed to update settings') });
-            return false;
-        },
-
-        updateProfile: async (updates: { first_name?: string; last_name?: string; avatar_url?: string }) => {
-            const response = await api.updateProfile(updates);
-            if (response.data) {
-                dispatch({ type: 'UPDATE_PROFILE', payload: response.data });
-                return true;
-            }
-            dispatch({ type: 'SET_ERROR', payload: getErrorMessage(response.error, 'Failed to update profile') });
-            return false;
-        },
-
-        updateAccount: async (accountId: string, updates: Partial<EmailAccount>) => {
-            const response = await api.updateAccount(accountId, updates);
-            if (response.data) {
-                dispatch({
-                    type: 'SET_ACCOUNTS',
-                    payload: state.accounts.map(a => a.id === accountId ? { ...a, ...updates } : a)
-                });
-                return true;
-            }
-            dispatch({ type: 'SET_ERROR', payload: getErrorMessage(response.error, 'Failed to update account') });
-            return false;
-        },
-
-        createRule: async (rule: Omit<Rule, 'id' | 'user_id' | 'created_at'>) => {
-            const response = await api.createRule(rule);
-            if (response.data) {
-                dispatch({ type: 'ADD_RULE', payload: response.data.rule });
-                return true;
-            }
-            dispatch({ type: 'SET_ERROR', payload: getErrorMessage(response.error, 'Failed to create rule') });
-            return false;
-        },
-
-        deleteRule: async (ruleId: string) => {
-            const response = await api.deleteRule(ruleId);
-            if (response.data?.success) {
-                dispatch({ type: 'REMOVE_RULE', payload: ruleId });
-                return true;
-            }
-            dispatch({ type: 'SET_ERROR', payload: getErrorMessage(response.error, 'Failed to delete rule') });
-            return false;
-        },
-
-        toggleRule: async (ruleId: string) => {
-            const response = await api.toggleRule(ruleId);
-            if (response.data) {
-                dispatch({ type: 'UPDATE_RULE', payload: response.data.rule });
-                return true;
-            }
-            dispatch({ type: 'SET_ERROR', payload: getErrorMessage(response.error, 'Failed to toggle rule') });
-            return false;
-        },
-    };
-
-    return (
-        <AppContext.Provider value={{ state, dispatch, actions }}>
-            {children}
-        </AppContext.Provider>
-    );
-}
-
-export function useApp() {
-    const context = useContext(AppContext);
-    if (!context) {
-        throw new Error('useApp must be used within AppProvider');
-    }
-    return context;
-}

package/src/context/MigrationContext.tsx

@@ -1,53 +0,0 @@
-import { createContext, useContext, type ReactNode } from "react";
-import type { MigrationStatus } from "../lib/migration-check";
-
-interface MigrationContextValue {
-    /** Current migration status */
-    migrationStatus: MigrationStatus | null;
-    /** Whether the migration banner is currently showing */
-    showMigrationBanner: boolean;
-    /** Whether the migration modal is currently showing */
-    showMigrationModal: boolean;
-    /** Open the migration modal */
-    openMigrationModal: () => void;
-    /** Whether the migration banner should be suppressed (e.g., when showing Setup Guide) */
-    suppressMigrationBanner: boolean;
-    /** Set whether to suppress the migration banner */
-    setSuppressMigrationBanner: (suppress: boolean) => void;
-}
-
-const MigrationContext = createContext<MigrationContextValue | undefined>(
-    undefined,
-);
-
-export function MigrationProvider({
-    children,
-    value,
-}: {
-    children: ReactNode;
-    value: MigrationContextValue;
-}) {
-    return (
-        <MigrationContext.Provider value={value}>
-            {children}
-        </MigrationContext.Provider>
-    );
-}
-
-export function useMigrationContext() {
-    const context = useContext(MigrationContext);
-    if (context === undefined) {
-        throw new Error(
-            "useMigrationContext must be used within a MigrationProvider",
-        );
-    }
-    return context;
-}
-
-/**
- * Safe version that returns null if used outside provider
- * Useful for components that may render outside the provider
- */
-export function useMigrationContextSafe() {
-    return useContext(MigrationContext);
-}

package/src/context/TerminalContext.tsx

@@ -1,31 +0,0 @@
-import { createContext, useContext, useState, ReactNode } from 'react';
-
-interface TerminalContextType {
-    isExpanded: boolean;
-    setIsExpanded: (expanded: boolean) => void;
-    openTerminal: () => void;
-    closeTerminal: () => void;
-}
-
-const TerminalContext = createContext<TerminalContextType | null>(null);
-
-export function TerminalProvider({ children }: { children: ReactNode }) {
-    const [isExpanded, setIsExpanded] = useState(false);
-
-    const openTerminal = () => setIsExpanded(true);
-    const closeTerminal = () => setIsExpanded(false);
-
-    return (
-        <TerminalContext.Provider value={{ isExpanded, setIsExpanded, openTerminal, closeTerminal }}>
-            {children}
-        </TerminalContext.Provider>
-    );
-}
-
-export function useTerminal() {
-    const context = useContext(TerminalContext);
-    if (!context) {
-        throw new Error('useTerminal must be used within a TerminalProvider');
-    }
-    return context;
-}

package/src/core/actions.ts

@@ -1,76 +0,0 @@
-import { google } from 'googleapis';
-
-export class EmailActions {
-    private supabase: any;
-
-    constructor(supabaseClient?: any) {
-        this.supabase = supabaseClient;
-    }
-
-    async executeAction(emailId: string, action: 'delete' | 'archive' | 'draft', draftContent?: string) {
-        if (!this.supabase) throw new Error('Supabase client not configured');
-
-        // 1. Fetch email and account details
-        const { data: email, error: emailError } = await this.supabase
-            .from('emails')
-            .select('*, email_accounts(*)')
-            .eq('id', emailId)
-            .single();
-
-        if (emailError || !email) throw new Error('Email not found');
-        const account = email.email_accounts;
-
-        if (account.provider === 'gmail') {
-            await this.executeGmailAction(account, email.external_id, action, draftContent);
-        } else {
-            console.log('Outlook actions not implemented yet');
-        }
-
-        // 2. Update status in Supabase
-        await this.supabase.from('emails').update({ action_taken: action }).eq('id', emailId);
-    }
-
-    private async executeGmailAction(account: any, messageId: string, action: string, draftContent?: string) {
-        const auth = new google.auth.OAuth2(
-            process.env.GMAIL_CLIENT_ID,
-            process.env.GMAIL_CLIENT_SECRET
-        );
-        auth.setCredentials({
-            access_token: account.access_token,
-            refresh_token: account.refresh_token,
-            expiry_date: account.token_expires_at ? new Date(account.token_expires_at).getTime() : undefined
-        });
-
-        const gmail = google.gmail({ version: 'v1', auth });
-
-        if (action === 'delete') {
-            await gmail.users.messages.trash({ userId: 'me', id: messageId });
-        } else if (action === 'archive') {
-            await gmail.users.messages.modify({
-                userId: 'me',
-                id: messageId,
-                requestBody: { removeLabelIds: ['INBOX'] }
-            });
-        } else if (action === 'draft' && draftContent) {
-            // Get original message for thread continuity (optional but better)
-            const original = await gmail.users.messages.get({ userId: 'me', id: messageId });
-            const threadId = original.data.threadId;
-
-            await gmail.users.drafts.create({
-                userId: 'me',
-                requestBody: {
-                    message: {
-                        threadId: threadId,
-                        raw: Buffer.from(
-                            `To: ${original.data.payload?.headers?.find(h => h.name === 'From')?.value || ''} \r\n` +
-                            `Subject: Re: ${original.data.payload?.headers?.find(h => h.name === 'Subject')?.value || ''} \r\n` +
-                            `In - Reply - To: ${messageId} \r\n` +
-                            `References: ${messageId} \r\n\r\n` +
-                            `${draftContent} `
-                        ).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
-                    }
-                }
-            });
-        }
-    }
-}

package/src/core/auth.ts

@@ -1,108 +0,0 @@
-import { google } from 'googleapis';
-import * as msal from '@azure/msal-node';
-
-export class GmailHandler {
-    private oauth2Client;
-
-    constructor() {
-        this.oauth2Client = new google.auth.OAuth2(
-            process.env.GMAIL_CLIENT_ID,
-            process.env.GMAIL_CLIENT_SECRET,
-            'urn:ietf:wg:oauth:2.0:oob'
-        );
-    }
-
-    async getAuthUrl() {
-        const scopes = ['https://www.googleapis.com/auth/gmail.readonly'];
-        return this.oauth2Client.generateAuthUrl({
-            access_type: 'offline',
-            scope: scopes,
-            prompt: 'consent'
-        });
-    }
-
-    async handleCallback(code: string) {
-        const { tokens } = await this.oauth2Client.getToken(code);
-        this.oauth2Client.setCredentials(tokens);
-
-        // Return tokens for the caller to save
-        return tokens;
-    }
-
-    async authenticate(code: string, userId: string, emailAddress: string, supabaseClient: any) {
-        const { tokens } = await this.oauth2Client.getToken(code);
-        this.oauth2Client.setCredentials(tokens);
-
-        // Save tokens to Supabase
-        const { error } = await supabaseClient
-            .from('email_accounts')
-            .upsert({
-                user_id: userId,
-                email_address: emailAddress,
-                provider: 'gmail',
-                access_token: tokens.access_token,
-                refresh_token: tokens.refresh_token,
-                token_expires_at: tokens.expiry_date ? new Date(tokens.expiry_date).toISOString() : null,
-                scopes: tokens.scope ? tokens.scope.split(' ') : [],
-                is_active: true
-            }, { onConflict: 'user_id, email_address' });
-
-        if (error) throw error;
-        return tokens;
-    }
-}
-
-export class MicrosoftGraphHandler {
-    private cca;
-
-    constructor() {
-        const config = {
-            auth: {
-                clientId: process.env.MS_GRAPH_CLIENT_ID || '',
-                authority: `https://login.microsoftonline.com/${process.env.MS_GRAPH_TENANT_ID || 'common'}`,
-            }
-        };
-        this.cca = new msal.PublicClientApplication(config);
-    }
-
-    async initiateDeviceFlow() {
-        const scopes = ['https://graph.microsoft.com/Mail.Read'];
-        const deviceCodeRequest = {
-            deviceCodeCallback: (response: any) => {
-                return response;
-            },
-            scopes: scopes,
-        };
-
-        const response = await this.cca.acquireTokenByDeviceCode(deviceCodeRequest);
-        return {
-            device_code: (response as any).deviceCode,
-            user_code: (response as any).userCode,
-            message: (response as any).message
-        };
-    }
-
-    async completeDeviceFlow(deviceCode: string) {
-        // The device flow is already handled by acquireTokenByDeviceCode
-        // This is a placeholder for completing the flow
-        // In practice, you'd poll or wait for the user to complete auth
-        return { success: true };
-    }
-
-    async saveToken(userId: string, emailAddress: string, response: msal.AuthenticationResult, supabaseClient: any) {
-        const { error } = await supabaseClient
-            .from('email_accounts')
-            .upsert({
-                user_id: userId,
-                email_address: emailAddress,
-                provider: 'outlook',
-                access_token: response.accessToken,
-                refresh_token: (response as any).refreshToken || null, // msal-node handles refresh tokens in cache, but we might want to store it
-                token_expires_at: response.expiresOn ? response.expiresOn.toISOString() : null,
-                scopes: response.scopes,
-                is_active: true
-            }, { onConflict: 'user_id, email_address' });
-
-        if (error) throw error;
-    }
-}