flow-frame-core 0.1.0

package/dist/filter-gmail-poller/filter-gmail-poller.js

@@ -0,0 +1,1048 @@
+import { google } from 'googleapis';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { authenticate } from '@google-cloud/local-auth';
+import express from 'express';
+import cors from 'cors';
+import os from 'os';
+import { extractPdf } from '../services/extractPdf.js';
+import { ensureDir, get } from '../utils.js';
+import { KEYS } from '../constants.js';
+// ES module equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Gmail API scopes
+const DEFAULT_SCOPES = [
+    'https://www.googleapis.com/auth/gmail.readonly',
+    'https://www.googleapis.com/auth/gmail.modify',
+    'https://www.googleapis.com/auth/gmail.labels'
+];
+const TEXT_MIME_PREFIXES = ['text/', 'application/json', 'application/xml'];
+const TEXT_EXTENSIONS = ['.txt', '.md', '.csv', '.json', '.xml', '.log'];
+class FilterGmailPoller {
+    static instance = null;
+    constructor(configPath = './config.json') {
+        this.configPath = configPath;
+        this.config = null;
+        this.gmail = null;
+        this.isAuthenticated = false;
+        this.pollingInterval = null;
+        this.emails = []; // In-memory storage for filtered emails
+        this.app = null;
+        this.server = null;
+    }
+    /**
+     * Load configuration from JSON file
+     */
+    async loadConfig() {
+        try {
+            const configData = await fs.readFile(this.configPath, 'utf8');
+            this.config = JSON.parse(configData);
+            console.log('✅ Configuration loaded successfully');
+            return this.config;
+        }
+        catch (error) {
+            console.error('❌ Error loading configuration:', error);
+            throw error;
+        }
+    }
+    /**
+     * Authenticate with Gmail API
+     */
+    async authenticate() {
+        try {
+            const credentialsPath = path.resolve(__dirname, this.config.gmail.credentialsPath);
+            const auth = await authenticate({
+                keyfilePath: credentialsPath,
+                scopes: this.config.gmail.scopes || DEFAULT_SCOPES,
+            });
+            this.gmail = google.gmail({ version: 'v1', auth });
+            this.isAuthenticated = true;
+            console.log('✅ Gmail authentication successful');
+        }
+        catch (error) {
+            console.error('❌ Gmail authentication failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Check if email subject starts with the configured prefix
+     */
+    matchesFilter(email) {
+        const subject = this.getEmailSubject(email);
+        const prefix = this.config.filter.subjectPrefix;
+        return subject && subject.startsWith(prefix);
+    }
+    /**
+     * Extract and decode email body from Gmail message
+     * @param {Object} email - Gmail message object
+     * @param {string} [preferredType='text/plain'] - Preferred MIME type ('text/plain' or 'text/html')
+     * @returns {string} - Decoded email body as string
+     */
+    extractEmailBody(email, preferredType = 'text/plain') {
+        if (!email || !email.payload) {
+            return '';
+        }
+        try {
+            // Function to recursively find body in message parts
+            const findBodyInParts = (parts, preferredType) => {
+                for (const part of parts) {
+                    // Check if this part has the body we want
+                    if (part.mimeType === preferredType && part.body && part.body.data) {
+                        return part.body.data;
+                    }
+                    // If this part has sub-parts, search recursively
+                    if (part.parts && part.parts.length > 0) {
+                        const found = findBodyInParts(part.parts, preferredType);
+                        if (found)
+                            return found;
+                    }
+                }
+                return null;
+            };
+            let bodyData = null;
+            // First try to find the preferred type
+            if (email.payload.parts && email.payload.parts.length > 0) {
+                bodyData = findBodyInParts(email.payload.parts, preferredType);
+            }
+            // If preferred type not found and we want plain text, try HTML as fallback
+            if (!bodyData && preferredType === 'text/plain') {
+                if (email.payload.parts && email.payload.parts.length > 0) {
+                    bodyData = findBodyInParts(email.payload.parts, 'text/html');
+                }
+            }
+            // If still not found, check the root payload body
+            if (!bodyData && email.payload.body && email.payload.body.data) {
+                bodyData = email.payload.body.data;
+            }
+            // If we found body data, decode it
+            if (bodyData) {
+                // Gmail uses URL-safe base64, convert to regular base64 first
+                const regularBase64 = bodyData.replace(/-/g, '+').replace(/_/g, '/');
+                // Decode from base64 to string
+                const decodedBody = Buffer.from(regularBase64, 'base64').toString('utf-8');
+                return decodedBody;
+            }
+            return '';
+        }
+        catch (error) {
+            console.error('❌ Error extracting email body:', error);
+            return '';
+        }
+    }
+    /**
+     * Extract subject from email headers
+     */
+    getEmailSubject(email) {
+        if (!email.payload || !email.payload.headers)
+            return '';
+        const subjectHeader = email.payload.headers.find(header => header.name.toLowerCase() === 'subject');
+        return subjectHeader ? subjectHeader.value : '';
+    }
+    /**
+     * Resolve a Gmail label ID by its display name
+     */
+    async getLabelIdByName(labelName) {
+        if (!labelName) {
+            return null;
+        }
+        const labels = await this.getLabels();
+        const lower = labelName.toLowerCase();
+        const match = labels.find(label => label.name.toLowerCase() === lower);
+        if (!match) {
+            console.warn(`⚠️ Label not found: ${labelName}`);
+            return null;
+        }
+        return match.id;
+    }
+    /**
+     * Determine which label IDs to use when querying Gmail
+     */
+    async getFilterLabelIds() {
+        if (!this.config || !this.config.filter) {
+            return ['INBOX'];
+        }
+        const { labelIds, labelNames, labelName } = this.config.filter;
+        if (Array.isArray(labelIds) && labelIds.length > 0) {
+            return labelIds;
+        }
+        const names = [];
+        if (labelName) {
+            names.push(labelName);
+        }
+        if (Array.isArray(labelNames)) {
+            names.push(...labelNames);
+        }
+        if (names.length === 0) {
+            return ['INBOX'];
+        }
+        const availableLabels = await this.getLabels();
+        const lookup = new Map(availableLabels.map(label => [label.name.toLowerCase(), label.id]));
+        const resolved = names
+            .map(name => {
+            const id = lookup.get(name.toLowerCase());
+            if (!id) {
+                console.warn(`⚠️ Configured label "${name}" not found in Gmail`);
+            }
+            return id;
+        })
+            .filter(Boolean);
+        return resolved.length > 0 ? resolved : ['INBOX'];
+    }
+    /**
+     * Get all labels
+     */
+    async getLabels() {
+        if (!this.isAuthenticated) {
+            throw new Error('Not authenticated with Gmail');
+        }
+        try {
+            const response = await this.gmail.users.labels.list({
+                userId: 'me'
+            });
+            return response.data.labels || [];
+        }
+        catch (error) {
+            console.error('❌ Error getting labels:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create new label/folder
+     */
+    async createLabel(labelName) {
+        if (!this.isAuthenticated) {
+            throw new Error('Not authenticated with Gmail');
+        }
+        try {
+            // Add human delay
+            await this.delay(this.getHumanDelay());
+            const response = await this.gmail.users.labels.create({
+                userId: 'me',
+                requestBody: {
+                    name: labelName,
+                    labelListVisibility: 'labelShow',
+                    messageListVisibility: 'show'
+                }
+            });
+            console.log(`📁 Created label: ${labelName}`);
+            return response.data;
+        }
+        catch (error) {
+            console.error('❌ Error creating label:', error);
+            throw error;
+        }
+    }
+    /**
+     * Find or create label
+     */
+    async findOrCreateLabel(labelName) {
+        const labels = await this.getLabels();
+        const existingLabel = labels.find(label => label.name === labelName);
+        if (existingLabel) {
+            return existingLabel;
+        }
+        return await this.createLabel(labelName);
+    }
+    /**
+     * Get human-like delay
+     */
+    getHumanDelay() {
+        const min = 1000; // 1 second minimum delay
+        const max = 3000; // 3 seconds maximum delay
+        return Math.random() * (max - min) + min;
+    }
+    /**
+     * Get full email details
+     */
+    async getEmailDetails(messageId) {
+        if (!this.isAuthenticated) {
+            throw new Error('Not authenticated with Gmail');
+        }
+        try {
+            // Add human delay
+            await this.delay(this.getHumanDelay());
+            const response = await this.gmail.users.messages.get({
+                userId: 'me',
+                id: messageId,
+                format: 'full'
+            });
+            const enriched = await this.includeAttachmentsInBody(response.data);
+            return enriched;
+        }
+        catch (error) {
+            console.error('❌ Error getting email details:', error);
+            throw error;
+        }
+    }
+    /**
+     * Move email to different label/folder
+     */
+    async moveEmail(messageId, targetLabelId, removeLabelIds = []) {
+        if (!this.isAuthenticated) {
+            throw new Error('Not authenticated with Gmail');
+        }
+        try {
+            // Add human delay
+            await this.delay(this.getHumanDelay());
+            const response = await this.gmail.users.messages.modify({
+                userId: 'me',
+                id: messageId,
+                requestBody: {
+                    addLabelIds: [targetLabelId],
+                    removeLabelIds: removeLabelIds
+                }
+            });
+            console.log(`📦 Moved email ${messageId} to label ${targetLabelId}`);
+            return response.data;
+        }
+        catch (error) {
+            console.error('❌ Error moving email:', error);
+            throw error;
+        }
+    }
+    /**
+     * Utility delay function
+     */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Ensure a folder/label exists by name
+     * Returns the label object (existing or newly created)
+     */
+    async ensureFolderExists(folderName) {
+        if (!this.isAuthenticated) {
+            console.log('🔐 Not authenticated, authenticating now...');
+            await this.authenticate();
+        }
+        try {
+            const label = await this.findOrCreateLabel(folderName);
+            console.log(`📁 Folder "${folderName}" is ready (ID: ${label.id})`);
+            return label;
+        }
+        catch (error) {
+            console.error(`❌ Error ensuring folder "${folderName}" exists:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Move an email to a specific folder by name
+     * Automatically ensures the folder exists before moving
+     */
+    async moveEmailToFolder(messageId, folderName, removeFromInbox = true) {
+        if (!this.isAuthenticated) {
+            console.log('🔐 Not authenticated, authenticating now...');
+            await this.authenticate();
+        }
+        try {
+            // Ensure the folder exists
+            const targetLabel = await this.ensureFolderExists(folderName);
+            // Prepare label IDs to remove (typically INBOX if requested)
+            const removeLabelIds = removeFromInbox ? ['INBOX'] : [];
+            // Move the email
+            const result = await this.moveEmail(messageId, targetLabel.id, removeLabelIds);
+            console.log(`📦 Moved email ${messageId} to folder "${folderName}"`);
+            return result;
+        }
+        catch (error) {
+            console.error(`❌ Error moving email ${messageId} to folder "${folderName}":`, error);
+            throw error;
+        }
+    }
+    /**
+     * Step through emails manually with pagination
+     * Ensures authentication and allows controlled processing of emails
+     * Honors the configured filter (subject prefix)
+     */
+    async stepThroughEmails(options = {}) {
+        // Ensure authentication
+        if (!this.isAuthenticated) {
+            console.log('🔐 Not authenticated, authenticating now...');
+            await this.authenticate();
+        }
+        const { query = '', labelIds = null, folderName = null, maxResults = 10, pageToken = null, includeDetails = true } = options;
+        let effectiveLabelIds = labelIds;
+        if (!effectiveLabelIds || effectiveLabelIds.length === 0) {
+            if (folderName) {
+                const labelId = await this.getLabelIdByName(folderName);
+                if (!labelId) {
+                    throw new Error(`Label "${folderName}" not found`);
+                }
+                effectiveLabelIds = [labelId];
+            }
+            else {
+                effectiveLabelIds = await this.getFilterLabelIds();
+            }
+        }
+        try {
+            // Get message list with pagination
+            const listOptions = {
+                userId: 'me',
+                q: query,
+                maxResults: maxResults,
+                pageToken: pageToken
+            };
+            if (effectiveLabelIds && effectiveLabelIds.length > 0) {
+                listOptions.labelIds = effectiveLabelIds;
+            }
+            const listResponse = await this.gmail.users.messages.list(listOptions);
+            const messages = listResponse.data.messages || [];
+            console.log(`📧 Found ${messages.length} messages (page token: ${listResponse.data.nextPageToken || 'none'})`);
+            let emailDetails = [];
+            let filteredCount = 0;
+            if (includeDetails && messages.length > 0) {
+                // Get full details for each message and apply filter
+                for (const message of messages) {
+                    const details = await this.getEmailDetails(message.id);
+                    // Check if email matches our filter
+                    if (this.matchesFilter(details)) {
+                        emailDetails.push(details);
+                        filteredCount++;
+                        if (this.config.logging.enableConsole) {
+                            console.log(`✅ Filtered email matches: ${this.getEmailSubject(details)}`);
+                        }
+                    }
+                    else {
+                        if (this.config.logging.enableConsole) {
+                            console.log(`❌ Filtered email doesn't match: ${this.getEmailSubject(details)}`);
+                        }
+                    }
+                }
+            }
+            console.log(`🎯 After filtering: ${filteredCount} emails match the prefix "${this.config.filter.subjectPrefix}"`);
+            return {
+                messages: includeDetails ? emailDetails : messages, // Note: if includeDetails=false, we can't filter
+                nextPageToken: listResponse.data.nextPageToken,
+                hasMore: !!listResponse.data.nextPageToken,
+                totalMessages: messages.length,
+                filteredMessages: filteredCount,
+                subjectPrefix: this.config.filter.subjectPrefix
+            };
+        }
+        catch (error) {
+            console.error('❌ Error stepping through emails:', error);
+            throw error;
+        }
+    }
+    /**
+     * Add email to memory (keeping only the most recent N emails)
+     */
+    addEmailToMemory(email) {
+        // Add timestamp for sorting
+        const emailWithTimestamp = {
+            ...email,
+            filteredAt: new Date().toISOString(),
+            subject: this.getEmailSubject(email)
+        };
+        // Add to beginning of array (most recent first)
+        this.emails.unshift(emailWithTimestamp);
+        // Keep only the configured maximum number of emails
+        if (this.emails.length > this.config.filter.maxEmailsInMemory) {
+            this.emails = this.emails.slice(0, this.config.filter.maxEmailsInMemory);
+        }
+        if (this.config.logging.enableConsole) {
+            console.log(`📧 Added filtered email: ${emailWithTimestamp.subject}`);
+        }
+    }
+    /**
+     * Poll for new emails and filter them
+     */
+    async pollAndFilter() {
+        if (!this.isAuthenticated) {
+            throw new Error('Not authenticated with Gmail');
+        }
+        try {
+            const labelIds = await this.getFilterLabelIds();
+            // Poll for recent emails (last 24 hours to avoid too much data)
+            const query = `newer_than:1d`;
+            const listOptions = {
+                userId: 'me',
+                q: query,
+                maxResults: 50
+            };
+            if (labelIds && labelIds.length > 0) {
+                listOptions.labelIds = labelIds;
+            }
+            const response = await this.gmail.users.messages.list(listOptions);
+            const messages = response.data.messages || [];
+            if (this.config.logging.enableConsole) {
+                console.log(`📧 Found ${messages.length} recent messages`);
+            }
+            // Process each message
+            for (const message of messages) {
+                try {
+                    const emailDetails = await this.gmail.users.messages.get({
+                        userId: 'me',
+                        id: message.id,
+                        format: 'full'
+                    });
+                    // Check if email matches our filter
+                    if (this.matchesFilter(emailDetails.data)) {
+                        this.addEmailToMemory(emailDetails.data);
+                    }
+                }
+                catch (error) {
+                    console.error(`❌ Error processing message ${message.id}:`, error);
+                }
+                // Small delay between processing emails
+                await this.delay(100);
+            }
+        }
+        catch (error) {
+            console.error('❌ Error polling emails:', error);
+            throw error;
+        }
+    }
+    /**
+     * Start the polling process
+     */
+    async startPolling() {
+        // Authenticate on first polling start if not already authenticated
+        if (!this.isAuthenticated) {
+            console.log('🔐 Authenticating with Gmail...');
+            await this.authenticateOnce();
+        }
+        console.log('🚀 Starting Filter Gmail Poller...');
+        console.log(`📧 Filtering emails with prefix: "${this.config.filter.subjectPrefix}"`);
+        console.log(`⏰ Polling interval: ${this.config.filter.pollingIntervalMs}ms`);
+        console.log(`💾 Max emails in memory: ${this.config.filter.maxEmailsInMemory}`);
+        const poll = async () => {
+            try {
+                await this.pollAndFilter();
+            }
+            catch (error) {
+                console.error('❌ Polling error:', error);
+            }
+            // Schedule next poll
+            this.pollingInterval = setTimeout(poll, this.config.filter.pollingIntervalMs);
+        };
+        // Start polling immediately
+        await poll();
+    }
+    /**
+     * Stop the polling process
+     */
+    stopPolling() {
+        if (this.pollingInterval) {
+            clearTimeout(this.pollingInterval);
+            this.pollingInterval = null;
+            console.log('⏹️ Polling stopped');
+        }
+    }
+    /**
+     * Start the API server or integrate with existing Express app
+     * @param {Object} [existingApp] - Optional existing Express app to integrate with
+     */
+    async startAPIServer(existingApp = null) {
+        // Use existing app or create new one
+        this.app = existingApp || express();
+        // Only add middleware if we created the app (to avoid conflicts)
+        if (!existingApp) {
+            this.app.use(cors());
+            this.app.use(express.json());
+        }
+        console.log('🔧 Setting up API routes...');
+        // API Routes
+        this.app.get('/api/emails', (req, res) => {
+            try {
+                const limit = parseInt(req.query.limit) || this.config.filter.maxEmailsInMemory;
+                const emails = this.emails.slice(0, limit);
+                res.json({
+                    success: true,
+                    count: emails.length,
+                    emails: emails,
+                    config: {
+                        subjectPrefix: this.config.filter.subjectPrefix,
+                        maxEmailsInMemory: this.config.filter.maxEmailsInMemory
+                    }
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    success: false,
+                    error: error.message
+                });
+            }
+        });
+        this.app.get('/api/emails/:id', (req, res) => {
+            try {
+                const email = this.emails.find(e => e.id === req.params.id);
+                if (!email) {
+                    return res.status(404).json({
+                        success: false,
+                        error: 'Email not found'
+                    });
+                }
+                res.json({
+                    success: true,
+                    email: email
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    success: false,
+                    error: error.message
+                });
+            }
+        });
+        this.app.get('/api/stats', (req, res) => {
+            res.json({
+                success: true,
+                stats: {
+                    totalEmails: this.emails.length,
+                    maxEmails: this.config.filter.maxEmailsInMemory,
+                    subjectPrefix: this.config.filter.subjectPrefix,
+                    pollingInterval: this.config.filter.pollingIntervalMs,
+                    isPolling: this.pollingInterval !== null,
+                    lastPoll: new Date().toISOString()
+                }
+            });
+        });
+        this.app.get('/api/health', (req, res) => {
+            res.json({
+                success: true,
+                status: 'healthy',
+                timestamp: new Date().toISOString()
+            });
+        });
+        // GET endpoint to read current configuration
+        this.app.get('/api/config', (req, res) => {
+            res.json({
+                success: true,
+                config: this.config,
+                timestamp: new Date().toISOString()
+            });
+        });
+        // POST endpoint to start polling
+        this.app.post('/api/polling/start', async (req, res) => {
+            try {
+                await this.startPolling();
+                res.json({
+                    success: true,
+                    message: 'Polling started successfully',
+                    isPolling: true,
+                    timestamp: new Date().toISOString()
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    success: false,
+                    error: error.message
+                });
+            }
+        });
+        // POST endpoint to stop polling
+        this.app.post('/api/polling/stop', (req, res) => {
+            try {
+                this.stopPolling();
+                res.json({
+                    success: true,
+                    message: 'Polling stopped successfully',
+                    isPolling: false,
+                    timestamp: new Date().toISOString()
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    success: false,
+                    error: error.message
+                });
+            }
+        });
+        // GET endpoint to check polling status
+        this.app.get('/api/polling/status', (req, res) => {
+            res.json({
+                success: true,
+                isPolling: this.pollingInterval !== null,
+                isAuthenticated: this.isAuthenticated,
+                timestamp: new Date().toISOString()
+            });
+        });
+        // GET endpoint to check if polling is active (simple boolean response)
+        this.app.get('/api/polling', (req, res) => {
+            res.json({
+                isPolling: this.pollingInterval !== null,
+                // return number of emails in memory for convenience
+                numEmailsInMemory: this.emails.length
+            });
+        });
+        // PUT endpoint to update filter configuration
+        this.app.put('/api/config/filter', async (req, res) => {
+            try {
+                const updates = req.body;
+                // Validate input
+                const allowedFields = ['subjectPrefix', 'maxEmailsInMemory', 'pollingIntervalMs', 'labelIds', 'labelNames', 'labelName'];
+                const invalidFields = Object.keys(updates).filter(key => !allowedFields.includes(key));
+                if (invalidFields.length > 0) {
+                    return res.status(400).json({
+                        success: false,
+                        error: `Invalid fields: ${invalidFields.join(', ')}. Allowed: ${allowedFields.join(', ')}`
+                    });
+                }
+                // Update configuration
+                const result = await this.updateFilterConfig(updates);
+                if (result.success) {
+                    res.json({
+                        success: true,
+                        message: 'Filter configuration updated successfully',
+                        updated: result.updated,
+                        pollingRestarted: result.pollingRestarted,
+                        newConfig: result.newConfig
+                    });
+                }
+                else {
+                    res.status(500).json(result);
+                }
+            }
+            catch (error) {
+                res.status(500).json({
+                    success: false,
+                    error: error.message
+                });
+            }
+        });
+        // Only start server if we created the app (not using existing app)
+        if (!existingApp) {
+            return new Promise((resolve, reject) => {
+                try {
+                    this.server = this.app.listen(this.config.api.port, this.config.api.host, () => {
+                        console.log(`🌐 API server started on http://${this.config.api.host}:${this.config.api.port}`);
+                        console.log(`📊 Available endpoints:`);
+                        console.log(`   GET /api/emails - Get filtered emails`);
+                        console.log(`   GET /api/emails/:id - Get specific email`);
+                        console.log(`   GET /api/stats - Get poller statistics`);
+                        console.log(`   GET /api/health - Health check`);
+                        console.log(`   PUT /api/config/filter - Update filter configuration`);
+                        resolve();
+                    });
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+        else {
+            console.log(`🔗 Filter Gmail Poller routes added to existing Express app`);
+            console.log(`📊 Available endpoints:`);
+            console.log(`   GET /api/emails - Get filtered emails`);
+            console.log(`   GET /api/emails/:id - Get specific email`);
+            console.log(`   GET /api/stats - Get poller statistics`);
+            console.log(`   GET /api/health - Health check`);
+            console.log(`   PUT /api/config/filter - Update filter configuration`);
+            return Promise.resolve();
+        }
+    }
+    /**
+     * Stop the API server (only if we created it)
+     */
+    stopAPIServer() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+            console.log('🌐 API server stopped');
+        }
+        else if (this.app) {
+            console.log('🔗 Filter Gmail Poller routes removed from Express app');
+            // Note: We don't remove routes from existing apps as Express doesn't provide
+            // a built-in way to remove routes. The routes will remain active.
+        }
+    }
+    /**
+     * Authenticate with Gmail API (only once)
+     */
+    async authenticateOnce() {
+        if (this.isAuthenticated) {
+            console.log('✅ Already authenticated');
+            return;
+        }
+        try {
+            await this.authenticate();
+        }
+        catch (error) {
+            console.error('❌ Authentication failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Initialize and start everything (without auto-starting polling)
+     * @param {Object} [existingApp] - Optional existing Express app to integrate with
+     */
+    async initialize(existingApp = null) {
+        try {
+            console.log('🎯 Initializing Filter Gmail Poller...');
+            // Load configuration
+            await this.loadConfig();
+            // Start API server (pass existing app if provided)
+            await this.startAPIServer(existingApp);
+            console.log('✅ Filter Gmail Poller initialized successfully!');
+            console.log('💡 Use startPolling() to begin polling (authentication will occur then)');
+            // Handle graceful shutdown (only if we created our own server)
+            if (!existingApp) {
+                process.on('SIGINT', () => {
+                    console.log('\n🛑 Shutting down...');
+                    this.stopPolling();
+                    this.stopAPIServer();
+                    process.exit(0);
+                });
+            }
+        }
+        catch (error) {
+            console.error('❌ Failed to initialize Filter Gmail Poller:', error);
+            throw error;
+        }
+    }
+    /**
+     * Initialize and start everything (legacy method - now calls initialize)
+     * @param {Object} [existingApp] - Optional existing Express app to integrate with
+     */
+    async start(existingApp = null) {
+        await this.initialize(existingApp);
+        // Optionally start polling immediately for backward compatibility
+        await this.startPolling();
+    }
+    /**
+     * Utility delay function
+     */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Get current emails (for testing/debugging)
+     */
+    getEmails() {
+        return this.emails;
+    }
+    /**
+     * Update filter configuration parameters
+     * @param {Object} updates - Configuration updates
+     * @param {string} [updates.subjectPrefix] - New subject prefix
+     * @param {number} [updates.maxEmailsInMemory] - New maximum emails in memory
+     * @param {number} [updates.pollingIntervalMs] - New polling interval in milliseconds
+     */
+    async updateFilterConfig(updates) {
+        try {
+            const oldConfig = { ...this.config.filter };
+            let configChanged = false;
+            let pollingRestartNeeded = false;
+            // Update subject prefix
+            if (updates.subjectPrefix !== undefined) {
+                this.config.filter.subjectPrefix = updates.subjectPrefix;
+                configChanged = true;
+                // Clear existing emails since they may no longer match the new filter
+                this.clearEmails();
+                console.log(`📧 Updated subject prefix to: "${updates.subjectPrefix}" (cleared existing emails)`);
+            }
+            // Update max emails in memory
+            if (updates.maxEmailsInMemory !== undefined) {
+                const newMax = Math.max(1, updates.maxEmailsInMemory); // Ensure at least 1
+                this.config.filter.maxEmailsInMemory = newMax;
+                configChanged = true;
+                // Trim existing emails if necessary
+                if (this.emails.length > newMax) {
+                    this.emails = this.emails.slice(0, newMax);
+                    console.log(`🧹 Trimmed emails to ${newMax} (removed ${this.emails.length - newMax} old emails)`);
+                }
+                console.log(`💾 Updated max emails in memory to: ${newMax}`);
+            }
+            // Update label IDs explicitly
+            if (updates.labelIds !== undefined) {
+                const newLabelIds = Array.isArray(updates.labelIds) ? updates.labelIds : [updates.labelIds];
+                this.config.filter.labelIds = newLabelIds.filter(Boolean);
+                configChanged = true;
+                console.log(`🏷️ Updated label IDs to: ${this.config.filter.labelIds.join(', ') || 'none'}`);
+            }
+            // Update label names
+            if (updates.labelNames !== undefined) {
+                const newLabelNames = Array.isArray(updates.labelNames) ? updates.labelNames : [updates.labelNames];
+                this.config.filter.labelNames = newLabelNames.filter(Boolean);
+                configChanged = true;
+                console.log(`🏷️ Updated label names to: ${this.config.filter.labelNames.join(', ') || 'none'}`);
+            }
+            if (updates.labelName !== undefined) {
+                this.config.filter.labelName = updates.labelName || '';
+                configChanged = true;
+                console.log(`🏷️ Updated label name to: ${this.config.filter.labelName || 'none'}`);
+            }
+            // Update polling interval
+            if (updates.pollingIntervalMs !== undefined) {
+                const newInterval = Math.max(5000, updates.pollingIntervalMs); // Minimum 5 seconds
+                this.config.filter.pollingIntervalMs = newInterval;
+                configChanged = true;
+                pollingRestartNeeded = true;
+                console.log(`⏰ Updated polling interval to: ${newInterval}ms`);
+            }
+            // Save updated config to file
+            if (configChanged) {
+                await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2));
+                console.log('💾 Configuration saved to file');
+                // Restart polling if interval changed
+                if (pollingRestartNeeded && this.pollingInterval) {
+                    console.log('🔄 Restarting polling with new interval...');
+                    this.stopPolling();
+                    await this.startPolling();
+                }
+            }
+            return {
+                success: true,
+                updated: configChanged,
+                pollingRestarted: pollingRestartNeeded,
+                newConfig: this.config.filter
+            };
+        }
+        catch (error) {
+            console.error('❌ Error updating filter config:', error);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Clear all emails from memory
+     */
+    clearEmails() {
+        this.emails = [];
+        console.log('🧹 Cleared all emails from memory');
+    }
+    isTextMimeType(mimeType = '') {
+        return TEXT_MIME_PREFIXES.some(prefix => mimeType.startsWith(prefix));
+    }
+    isTextExtension(filename = '') {
+        const lower = filename.toLowerCase();
+        return TEXT_EXTENSIONS.some(ext => lower.endsWith(ext));
+    }
+    decodeToBuffer(data = '') {
+        const normalized = data.replace(/-/g, '+').replace(/_/g, '/');
+        return Buffer.from(normalized, 'base64');
+    }
+    encodeToBase64Url(str = '') {
+        return Buffer.from(str, 'utf8')
+            .toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/g, '');
+    }
+    collectAttachmentParts(part, attachments = []) {
+        if (!part) {
+            return attachments;
+        }
+        if (part.filename && part.body && (part.body.attachmentId || part.body.data)) {
+            attachments.push(part);
+        }
+        if (Array.isArray(part.parts)) {
+            part.parts.forEach(child => this.collectAttachmentParts(child, attachments));
+        }
+        return attachments;
+    }
+    async fetchAttachmentBuffer(messageId, attachmentId) {
+        if (!attachmentId) {
+            return Buffer.alloc(0);
+        }
+        const attachment = await this.gmail.users.messages.attachments.get({
+            userId: 'me',
+            messageId,
+            id: attachmentId
+        });
+        return this.decodeToBuffer(attachment.data?.data || '');
+    }
+    async parsePdfAttachment(buffer, messageId, filename = 'attachment.pdf') {
+        try {
+            const pdfFolder = get(KEYS.pdf_folder_path);
+            // Use configured folder or a temp folder for extraction
+            const outDir = pdfFolder
+                ? path.join(pdfFolder, messageId)
+                : path.join(os.tmpdir(), 'story-gen-pdf', messageId);
+            // Ensure directory exists
+            await ensureDir(outDir);
+            // Save the original PDF if we have a configured folder
+            if (pdfFolder) {
+                const savePath = path.join(outDir, filename);
+                try {
+                    await fs.access(savePath);
+                    console.log(`⚠️ PDF file already exists at: ${savePath}, skipping save.`);
+                }
+                catch {
+                    await fs.writeFile(savePath, buffer);
+                    console.log(`💾 Saved PDF attachment to: ${savePath}`);
+                }
+            }
+            console.log(`📄 Extracting PDF content to: ${outDir}`);
+            const result = await extractPdf({
+                pdfBuffer: buffer,
+                outDir: outDir,
+                extractText: true,
+                extractImages: false,
+                renderPages: false
+            });
+            const fullText = Object.values(result.textByPage || {}).join('\n');
+            console.log(`📄 Extracted ${result.numPages} pages and ${result.images?.length || 0} images`);
+            return fullText.trim() || null;
+        }
+        catch (error) {
+            console.warn(`Failed to parse PDF attachment ${filename}:`, error);
+            return null;
+        }
+    }
+    async extractAttachmentText(messageId, part) {
+        const mimeType = part.mimeType || '';
+        const filename = part.filename || '';
+        console.log(`📎 Extracting attachment: ${filename} (${mimeType}) from message ${messageId}`);
+        let buffer;
+        if (part.body?.data) {
+            buffer = this.decodeToBuffer(part.body.data);
+        }
+        else if (part.body?.attachmentId) {
+            buffer = await this.fetchAttachmentBuffer(messageId, part.body.attachmentId);
+        }
+        if (!buffer || !buffer.length) {
+            return null;
+        }
+        if (this.isTextMimeType(mimeType) || this.isTextExtension(filename)) {
+            return buffer.toString('utf8').trim();
+        }
+        if (mimeType === 'application/pdf' || filename.toLowerCase().endsWith('.pdf')) {
+            console.log(`📄 Parsing PDF attachment: ${filename}`);
+            return await this.parsePdfAttachment(buffer, messageId, filename || 'attachment.pdf');
+        }
+        return null;
+    }
+    async includeAttachmentsInBody(message) {
+        if (!message || !message.payload) {
+            return message;
+        }
+        const attachments = this.collectAttachmentParts(message.payload, []);
+        if (!attachments.length) {
+            return message;
+        }
+        const attachmentSections = [];
+        for (const attachment of attachments) {
+            const text = await this.extractAttachmentText(message.id, attachment);
+            if (text) {
+                attachmentSections.push(`Attachment: ${attachment.filename || attachment.mimeType}\n${text}`);
+            }
+        }
+        if (!attachmentSections.length) {
+            return message;
+        }
+        const combined = attachmentSections.join('\n\n');
+        message.attachmentText = combined;
+        const textPart = {
+            mimeType: 'text/plain',
+            filename: 'attachments.txt',
+            body: {
+                data: this.encodeToBase64Url(`\n\n--- Attachments ---\n${combined}`)
+            }
+        };
+        if (Array.isArray(message.payload.parts)) {
+            message.payload.parts.push(textPart);
+        }
+        else {
+            message.payload.parts = [textPart];
+        }
+        return message;
+    }
+}
+export default FilterGmailPoller;
+//# sourceMappingURL=filter-gmail-poller.js.map