@realtimex/email-automator 2.2.0 → 2.3.0

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

@@ -0,0 +1,178 @@
+import { Router } from 'express';
+import { asyncHandler } from '../middleware/errorHandler.js';
+import { authMiddleware } from '../middleware/auth.js';
+import { apiRateLimit } from '../middleware/rateLimit.js';
+import { validateBody, schemas } from '../middleware/validation.js';
+import { createLogger } from '../utils/logger.js';
+const router = Router();
+const logger = createLogger('SettingsRoutes');
+// Get user settings
+router.get('/', authMiddleware, asyncHandler(async (req, res) => {
+    // Fetch settings and integrations in parallel
+    const [settingsResult, integrationsResult] = await Promise.all([
+        req.supabase
+            .from('user_settings')
+            .select('*')
+            .eq('user_id', req.user.id)
+            .single(),
+        req.supabase
+            .from('integrations')
+            .select('*')
+            .eq('user_id', req.user.id)
+    ]);
+    const settingsData = settingsResult.data;
+    const integrationsData = integrationsResult.data || [];
+    // Return defaults if no settings exist
+    const settings = settingsData || {
+        llm_model: null,
+        llm_base_url: null,
+        sync_interval_minutes: 5,
+    };
+    // Merge integration credentials back into settings for frontend compatibility
+    const googleIntegration = integrationsData.find((i) => i.provider === 'google');
+    if (googleIntegration?.credentials) {
+        settings.google_client_id = googleIntegration.credentials.client_id;
+        settings.google_client_secret = googleIntegration.credentials.client_secret;
+    }
+    const microsoftIntegration = integrationsData.find((i) => i.provider === 'microsoft');
+    if (microsoftIntegration?.credentials) {
+        settings.microsoft_client_id = microsoftIntegration.credentials.client_id;
+        settings.microsoft_client_secret = microsoftIntegration.credentials.client_secret;
+        settings.microsoft_tenant_id = microsoftIntegration.credentials.tenant_id;
+    }
+    res.json({ settings });
+}));
+// Update user settings
+router.patch('/', apiRateLimit, authMiddleware, validateBody(schemas.updateSettings), asyncHandler(async (req, res) => {
+    const { google_client_id, google_client_secret, microsoft_client_id, microsoft_client_secret, microsoft_tenant_id, ...userSettingsUpdates } = req.body;
+    const userId = req.user.id;
+    // 1. Update user_settings
+    const { data: updatedSettings, error: settingsError } = await req.supabase
+        .from('user_settings')
+        .upsert({
+        user_id: userId,
+        ...userSettingsUpdates,
+        updated_at: new Date().toISOString(),
+    }, { onConflict: 'user_id' })
+        .select()
+        .single();
+    if (settingsError)
+        throw settingsError;
+    // 2. Handle Google Integration
+    if (google_client_id || google_client_secret) {
+        const { data: existing } = await req.supabase
+            .from('integrations')
+            .select('credentials')
+            .eq('user_id', userId)
+            .eq('provider', 'google')
+            .single();
+        const credentials = {};
+        if (google_client_id)
+            credentials.client_id = google_client_id;
+        if (google_client_secret)
+            credentials.client_secret = google_client_secret;
+        const newCredentials = { ...(existing?.credentials || {}), ...credentials };
+        await req.supabase
+            .from('integrations')
+            .upsert({
+            user_id: userId,
+            provider: 'google',
+            credentials: newCredentials,
+            updated_at: new Date().toISOString()
+        }, { onConflict: 'user_id, provider' });
+    }
+    // 3. Handle Microsoft Integration
+    if (microsoft_client_id || microsoft_client_secret || microsoft_tenant_id) {
+        const { data: existing } = await req.supabase
+            .from('integrations')
+            .select('credentials')
+            .eq('user_id', userId)
+            .eq('provider', 'microsoft')
+            .single();
+        const credentials = {};
+        if (microsoft_client_id)
+            credentials.client_id = microsoft_client_id;
+        if (microsoft_client_secret)
+            credentials.client_secret = microsoft_client_secret;
+        if (microsoft_tenant_id)
+            credentials.tenant_id = microsoft_tenant_id;
+        const newCredentials = { ...(existing?.credentials || {}), ...credentials };
+        await req.supabase
+            .from('integrations')
+            .upsert({
+            user_id: userId,
+            provider: 'microsoft',
+            credentials: newCredentials,
+            updated_at: new Date().toISOString()
+        }, { onConflict: 'user_id, provider' });
+    }
+    // Construct response with merged values
+    const finalSettings = {
+        ...updatedSettings,
+        // Re-inject the values from request if they were present
+        ...(google_client_id ? { google_client_id } : {}),
+        ...(google_client_secret ? { google_client_secret } : {}),
+        ...(microsoft_client_id ? { microsoft_client_id } : {}),
+        ...(microsoft_client_secret ? { microsoft_client_secret } : {}),
+        ...(microsoft_tenant_id ? { microsoft_tenant_id } : {}),
+    };
+    logger.info('Settings updated', { userId });
+    res.json({ settings: finalSettings });
+}));
+// Test LLM Connection
+router.post('/test-llm', apiRateLimit, authMiddleware, asyncHandler(async (req, res) => {
+    const { llm_model, llm_base_url, llm_api_key } = req.body;
+    const { getIntelligenceService } = await import('../services/intelligence.js');
+    const intelligence = getIntelligenceService({
+        model: llm_model,
+        baseUrl: llm_base_url,
+        apiKey: llm_api_key,
+    });
+    const result = await intelligence.testConnection();
+    res.json(result);
+}));
+// Get analytics/stats
+router.get('/stats', authMiddleware, asyncHandler(async (req, res) => {
+    const userId = req.user.id;
+    // Get email counts by category
+    const { data: emailStats } = await req.supabase
+        .from('emails')
+        .select('category, is_useless, action_taken')
+        .eq('email_accounts.user_id', userId);
+    // Get account counts
+    const { data: accounts } = await req.supabase
+        .from('email_accounts')
+        .select('id, provider')
+        .eq('user_id', userId);
+    // Get recent processing logs
+    const { data: recentLogs } = await req.supabase
+        .from('processing_logs')
+        .select('*')
+        .eq('user_id', userId)
+        .order('started_at', { ascending: false })
+        .limit(5);
+    // Calculate stats
+    const stats = {
+        totalEmails: emailStats?.length || 0,
+        categoryCounts: {},
+        actionCounts: {},
+        uselessCount: emailStats?.filter(e => e.is_useless).length || 0,
+        accountCount: accounts?.length || 0,
+        accountsByProvider: {},
+        recentSyncs: recentLogs || [],
+    };
+    // Count by category
+    for (const email of emailStats || []) {
+        const cat = email.category || 'uncategorized';
+        stats.categoryCounts[cat] = (stats.categoryCounts[cat] || 0) + 1;
+        const action = email.action_taken || 'none';
+        stats.actionCounts[action] = (stats.actionCounts[action] || 0) + 1;
+    }
+    // Count by provider
+    for (const account of accounts || []) {
+        stats.accountsByProvider[account.provider] =
+            (stats.accountsByProvider[account.provider] || 0) + 1;
+    }
+    res.json({ stats });
+}));
+export default router;

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

@@ -0,0 +1,118 @@
+import { Router } from 'express';
+import { asyncHandler } from '../middleware/errorHandler.js';
+import { authMiddleware } from '../middleware/auth.js';
+import { syncRateLimit } from '../middleware/rateLimit.js';
+import { validateBody, schemas } from '../middleware/validation.js';
+import { EmailProcessorService } from '../services/processor.js';
+import { createLogger } from '../utils/logger.js';
+const router = Router();
+const logger = createLogger('SyncRoutes');
+// Trigger sync for an account
+router.post('/', syncRateLimit, authMiddleware, validateBody(schemas.syncRequest), asyncHandler(async (req, res) => {
+    const { accountId } = req.body;
+    const userId = req.user.id;
+    if (!req.supabase) {
+        return res.status(503).json({
+            error: 'Supabase service is not configured. Please set your SUPABASE_URL and SUPABASE_ANON_KEY in the .env file and restart the server.'
+        });
+    }
+    // Verify account ownership
+    const { data: account, error } = await req.supabase
+        .from('email_accounts')
+        .select('id')
+        .eq('id', accountId)
+        .eq('user_id', userId)
+        .single();
+    if (error || !account) {
+        return res.status(404).json({ error: 'Account not found' });
+    }
+    // Run sync and wait for result
+    const processor = new EmailProcessorService(req.supabase);
+    try {
+        const result = await processor.syncAccount(accountId, userId);
+        logger.info('Sync completed', { accountId, ...result });
+        res.json({
+            message: 'Sync completed',
+            accountId,
+            ...result,
+        });
+    }
+    catch (err) {
+        logger.error('Sync failed', err, { accountId });
+        const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+        res.status(500).json({
+            error: errorMessage,
+            accountId,
+        });
+    }
+}));
+// Sync all accounts for user
+router.post('/all', syncRateLimit, authMiddleware, asyncHandler(async (req, res) => {
+    const userId = req.user.id;
+    if (!req.supabase) {
+        return res.status(503).json({
+            error: 'Supabase service is not configured. Please set your SUPABASE_URL and SUPABASE_ANON_KEY in the .env file and restart the server.'
+        });
+    }
+    const { data: accounts, error } = await req.supabase
+        .from('email_accounts')
+        .select('id')
+        .eq('user_id', userId)
+        .eq('is_active', true);
+    if (error)
+        throw error;
+    if (!accounts || accounts.length === 0) {
+        return res.status(400).json({ error: 'No connected accounts' });
+    }
+    const processor = new EmailProcessorService(req.supabase);
+    // Sync all accounts and collect results
+    const results = await Promise.allSettled(accounts.map(account => processor.syncAccount(account.id, userId)));
+    const summary = {
+        total: accounts.length,
+        success: 0,
+        failed: 0,
+        errors: [],
+    };
+    results.forEach((result, index) => {
+        if (result.status === 'fulfilled') {
+            summary.success++;
+            logger.info('Sync completed', { accountId: accounts[index].id, ...result.value });
+        }
+        else {
+            summary.failed++;
+            const errorMessage = result.reason instanceof Error ? result.reason.message : 'Unknown error';
+            summary.errors.push({ accountId: accounts[index].id, error: errorMessage });
+            logger.error('Sync failed', result.reason, { accountId: accounts[index].id });
+        }
+    });
+    // Return error status if all syncs failed
+    if (summary.failed === summary.total) {
+        return res.status(500).json({
+            message: 'All syncs failed',
+            ...summary,
+        });
+    }
+    res.json({
+        message: summary.failed > 0 ? 'Sync completed with errors' : 'Sync completed',
+        ...summary,
+    });
+}));
+// Get sync history/logs
+router.get('/logs', authMiddleware, asyncHandler(async (req, res) => {
+    const { limit = '10' } = req.query;
+    if (!req.supabase) {
+        return res.status(503).json({
+            error: 'Supabase service is not configured. Please set your SUPABASE_URL and SUPABASE_ANON_KEY in the .env file and restart the server.'
+        });
+    }
+    const { data, error } = await req.supabase
+        .from('processing_logs')
+        .select('*')
+        .eq('user_id', req.user.id)
+        .order('started_at', { ascending: false })
+        .limit(parseInt(limit, 10));
+    if (error)
+        throw error;
+    res.json({ logs: data || [] });
+}));
+export default router;

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

@@ -0,0 +1,41 @@
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('EventLogger');
+export class EventLogger {
+    supabase;
+    runId;
+    constructor(supabase, runId) {
+        this.supabase = supabase;
+        this.runId = runId;
+    }
+    async log(eventType, agentState, details, emailId) {
+        try {
+            const { error } = await this.supabase.from('processing_events').insert({
+                run_id: this.runId,
+                email_id: emailId || null,
+                event_type: eventType,
+                agent_state: agentState,
+                details: details || {},
+                created_at: new Date().toISOString()
+            });
+            if (error) {
+                console.error('[EventLogger] Supabase Insert Error:', error);
+            }
+        }
+        catch (error) {
+            // Non-blocking error logging - don't fail the job because logging failed
+            logger.error('Failed to write processing event', error);
+        }
+    }
+    async info(state, message, details, emailId) {
+        await this.log('info', state, { message, ...details }, emailId);
+    }
+    async analysis(state, emailId, analysis) {
+        await this.log('analysis', state, analysis, emailId);
+    }
+    async action(state, emailId, action, reason) {
+        await this.log('action', state, { action, reason }, emailId);
+    }
+    async error(state, error, emailId) {
+        await this.log('error', state, { error: error.message || error }, emailId);
+    }
+}

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

@@ -0,0 +1,350 @@
+import { google } from 'googleapis';
+import { config } from '../config/index.js';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('GmailService');
+export class GmailService {
+    createOAuth2Client(credentials) {
+        return new google.auth.OAuth2(credentials?.clientId || config.gmail.clientId, credentials?.clientSecret || config.gmail.clientSecret, credentials?.redirectUri || config.gmail.redirectUri);
+    }
+    async getProviderCredentials(supabase, userId) {
+        const { data: integration } = await supabase
+            .from('integrations')
+            .select('credentials')
+            .eq('user_id', userId)
+            .eq('provider', 'google')
+            .single();
+        const creds = integration?.credentials;
+        if (creds?.client_id && creds?.client_secret) {
+            return {
+                clientId: creds.client_id,
+                clientSecret: creds.client_secret,
+                redirectUri: config.gmail.redirectUri
+            };
+        }
+        if (config.gmail.clientId && config.gmail.clientSecret) {
+            return {
+                clientId: config.gmail.clientId,
+                clientSecret: config.gmail.clientSecret,
+                redirectUri: config.gmail.redirectUri
+            };
+        }
+        throw new Error('Gmail OAuth credentials not configured (Database or Env)');
+    }
+    getAuthUrl(scopes = ['https://www.googleapis.com/auth/gmail.modify']) {
+        const client = this.createOAuth2Client();
+        return client.generateAuthUrl({
+            access_type: 'offline',
+            scope: scopes,
+            prompt: 'consent',
+        });
+    }
+    async exchangeCode(code) {
+        const client = this.createOAuth2Client();
+        const { tokens } = await client.getToken(code);
+        return {
+            access_token: tokens.access_token,
+            refresh_token: tokens.refresh_token ?? undefined,
+            expiry_date: tokens.expiry_date ?? undefined,
+            scope: tokens.scope ?? undefined,
+        };
+    }
+    async saveAccount(supabase, userId, emailAddress, tokens) {
+        const { data, error } = await supabase
+            .from('email_accounts')
+            .upsert({
+            user_id: userId,
+            email_address: emailAddress,
+            provider: 'gmail',
+            access_token: tokens.access_token,
+            refresh_token: tokens.refresh_token || null,
+            token_expires_at: tokens.expiry_date ? new Date(tokens.expiry_date).toISOString() : null,
+            scopes: tokens.scope?.split(' ') || [],
+            is_active: true,
+            updated_at: new Date().toISOString(),
+        }, { onConflict: 'user_id, email_address' })
+            .select()
+            .single();
+        if (error)
+            throw error;
+        return data;
+    }
+    async getAuthenticatedClient(account) {
+        const accessToken = account.access_token || '';
+        const refreshToken = account.refresh_token || '';
+        const client = this.createOAuth2Client();
+        client.setCredentials({
+            access_token: accessToken,
+            refresh_token: refreshToken,
+            expiry_date: account.token_expires_at ? new Date(account.token_expires_at).getTime() : undefined,
+        });
+        return google.gmail({ version: 'v1', auth: client });
+    }
+    async refreshTokenIfNeeded(supabase, account) {
+        if (!account.token_expires_at)
+            return account;
+        const expiresAt = new Date(account.token_expires_at).getTime();
+        const now = Date.now();
+        const bufferMs = 5 * 60 * 1000; // 5 minutes buffer
+        if (expiresAt > now + bufferMs) {
+            return account; // Token still valid
+        }
+        logger.info('Refreshing Gmail token', { accountId: account.id });
+        const refreshToken = account.refresh_token;
+        if (!refreshToken) {
+            throw new Error('No refresh token available');
+        }
+        const credentials = await this.getProviderCredentials(supabase, account.user_id);
+        const client = this.createOAuth2Client(credentials);
+        client.setCredentials({ refresh_token: refreshToken });
+        const { credentials: newTokens } = await client.refreshAccessToken();
+        const { data, error } = await supabase
+            .from('email_accounts')
+            .update({
+            access_token: newTokens.access_token,
+            token_expires_at: newTokens.expiry_date
+                ? new Date(newTokens.expiry_date).toISOString()
+                : null,
+            updated_at: new Date().toISOString(),
+        })
+            .eq('id', account.id)
+            .select()
+            .single();
+        if (error)
+            throw error;
+        return data;
+    }
+    async fetchMessages(account, options = {}) {
+        const gmail = await this.getAuthenticatedClient(account);
+        const { maxResults = config.processing.batchSize, query, pageToken } = options;
+        const response = await gmail.users.messages.list({
+            userId: 'me',
+            maxResults,
+            q: query,
+            pageToken,
+        });
+        const messages = [];
+        for (const msg of response.data.messages || []) {
+            if (!msg.id)
+                continue;
+            try {
+                const detail = await gmail.users.messages.get({
+                    userId: 'me',
+                    id: msg.id,
+                    format: 'full',
+                });
+                const parsed = this.parseMessage(detail.data);
+                if (parsed) {
+                    messages.push(parsed);
+                }
+            }
+            catch (error) {
+                logger.warn('Failed to fetch message details', { messageId: msg.id, error });
+            }
+        }
+        return {
+            messages,
+            nextPageToken: response.data.nextPageToken ?? undefined,
+        };
+    }
+    parseMessage(message) {
+        if (!message.id || !message.threadId)
+            return null;
+        const headers = message.payload?.headers || [];
+        const getHeader = (name) => headers.find(h => h.name?.toLowerCase() === name.toLowerCase())?.value || '';
+        let body = '';
+        const payload = message.payload;
+        if (payload?.parts) {
+            // Multipart message
+            const textPart = payload.parts.find(p => p.mimeType === 'text/plain');
+            const htmlPart = payload.parts.find(p => p.mimeType === 'text/html');
+            const part = textPart || htmlPart || payload.parts[0];
+            body = this.decodeBody(part?.body?.data);
+        }
+        else if (payload?.body?.data) {
+            body = this.decodeBody(payload.body.data);
+        }
+        return {
+            id: message.id,
+            threadId: message.threadId,
+            subject: getHeader('Subject') || 'No Subject',
+            sender: getHeader('From'),
+            recipient: getHeader('To'),
+            date: getHeader('Date'),
+            body,
+            snippet: message.snippet || '',
+            headers: {
+                importance: getHeader('Importance') || getHeader('X-Priority'),
+                listUnsubscribe: getHeader('List-Unsubscribe'),
+                autoSubmitted: getHeader('Auto-Submitted'),
+                mailer: getHeader('X-Mailer'),
+            }
+        };
+    }
+    decodeBody(data) {
+        if (!data)
+            return '';
+        try {
+            return Buffer.from(data, 'base64').toString('utf-8');
+        }
+        catch {
+            return '';
+        }
+    }
+    async trashMessage(account, messageId) {
+        const gmail = await this.getAuthenticatedClient(account);
+        await gmail.users.messages.trash({ userId: 'me', id: messageId });
+        logger.debug('Message trashed', { messageId });
+    }
+    async archiveMessage(account, messageId) {
+        const gmail = await this.getAuthenticatedClient(account);
+        await gmail.users.messages.modify({
+            userId: 'me',
+            id: messageId,
+            requestBody: { removeLabelIds: ['INBOX'] },
+        });
+        logger.debug('Message archived', { messageId });
+    }
+    async createDraft(account, originalMessageId, replyContent, supabase, attachments) {
+        const gmail = await this.getAuthenticatedClient(account);
+        // Fetch original message to get threadId and Message-ID for threading
+        const original = await gmail.users.messages.get({ userId: 'me', id: originalMessageId });
+        const headers = original.data.payload?.headers || [];
+        const getHeader = (name) => headers.find(h => h.name?.toLowerCase() === name.toLowerCase())?.value || '';
+        const toAddress = getHeader('From');
+        const originalSubject = getHeader('Subject');
+        const originalMsgId = getHeader('Message-ID');
+        const threadId = original.data.threadId;
+        // Ensure subject has Re: prefix
+        const subject = originalSubject.toLowerCase().startsWith('re:')
+            ? originalSubject
+            : `Re: ${originalSubject}`;
+        logger.info('Creating draft', { threadId, toAddress, subject });
+        // Threading headers: In-Reply-To should be the Message-ID of the mail we reply to
+        const replyHeaders = [];
+        if (originalMsgId) {
+            replyHeaders.push(`In-Reply-To: ${originalMsgId}`);
+            replyHeaders.push(`References: ${originalMsgId}`);
+        }
+        let rawMessage = '';
+        const boundary = `----=_Part_${Math.random().toString(36).substring(2)}`;
+        if (attachments && attachments.length > 0 && supabase) {
+            // Multipart message
+            rawMessage = [
+                `To: ${toAddress}`,
+                `Subject: ${subject}`,
+                ...replyHeaders,
+                'MIME-Version: 1.0',
+                `Content-Type: multipart/mixed; boundary="${boundary}"`,
+                '',
+                `--${boundary}`,
+                'Content-Type: text/plain; charset="UTF-8"',
+                'Content-Transfer-Encoding: 7bit',
+                '',
+                replyContent,
+                '',
+            ].join('\r\n');
+            for (const attachment of attachments) {
+                try {
+                    const content = await this.fetchAttachment(supabase, attachment.path);
+                    const base64Content = Buffer.from(content).toString('base64');
+                    rawMessage += [
+                        `--${boundary}`,
+                        `Content-Type: ${attachment.type}; name="${attachment.name}"`,
+                        `Content-Disposition: attachment; filename="${attachment.name}"`,
+                        'Content-Transfer-Encoding: base64',
+                        '',
+                        base64Content,
+                        '',
+                    ].join('\r\n');
+                }
+                catch (err) {
+                    logger.error('Failed to attach file', err, { path: attachment.path });
+                }
+            }
+            rawMessage += `--${boundary}--`;
+        }
+        else {
+            // Simple plain text message
+            rawMessage = [
+                `To: ${toAddress}`,
+                `Subject: ${subject}`,
+                ...replyHeaders,
+                'MIME-Version: 1.0',
+                'Content-Type: text/plain; charset="UTF-8"',
+                '',
+                replyContent,
+            ].join('\r\n');
+        }
+        const encodedMessage = Buffer.from(rawMessage)
+            .toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+        try {
+            const draft = await gmail.users.drafts.create({
+                userId: 'me',
+                requestBody: {
+                    message: {
+                        threadId,
+                        raw: encodedMessage,
+                    },
+                },
+            });
+            const draftId = draft.data.id || 'unknown';
+            logger.info('Draft created successfully', { draftId, threadId });
+            return draftId;
+        }
+        catch (error) {
+            logger.error('Gmail API Error creating draft', error);
+            throw error;
+        }
+    }
+    async addLabel(account, messageId, labelIds) {
+        const gmail = await this.getAuthenticatedClient(account);
+        await gmail.users.messages.modify({
+            userId: 'me',
+            id: messageId,
+            requestBody: { addLabelIds: labelIds },
+        });
+    }
+    async removeLabel(account, messageId, labelIds) {
+        const gmail = await this.getAuthenticatedClient(account);
+        await gmail.users.messages.modify({
+            userId: 'me',
+            id: messageId,
+            requestBody: { removeLabelIds: labelIds },
+        });
+    }
+    async markAsRead(account, messageId) {
+        await this.removeLabel(account, messageId, ['UNREAD']);
+        logger.debug('Message marked as read', { messageId });
+    }
+    async starMessage(account, messageId) {
+        await this.addLabel(account, messageId, ['STARRED']);
+        logger.debug('Message starred', { messageId });
+    }
+    async fetchAttachment(supabase, path) {
+        const { data, error } = await supabase.storage
+            .from('rule-attachments')
+            .download(path);
+        if (error)
+            throw error;
+        return new Uint8Array(await data.arrayBuffer());
+    }
+    async getProfile(account) {
+        const gmail = await this.getAuthenticatedClient(account);
+        const profile = await gmail.users.getProfile({ userId: 'me' });
+        return {
+            emailAddress: profile.data.emailAddress || '',
+            messagesTotal: profile.data.messagesTotal || 0,
+        };
+    }
+}
+// Singleton
+let instance = null;
+export function getGmailService() {
+    if (!instance) {
+        instance = new GmailService();
+    }
+    return instance;
+}