nolimit-x 1.0.0

package/src/processor.js

@@ -0,0 +1,542 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const utils = require('./utils');
+const placeholders = require('./placeholders');
+const MessageEncryption = require('./encryption');
+const MultiHandler = require('./multi-handler');
+const AttachmentHandler = require('./attachment-handler');
+const DocumentGenerator = require('./document-generator');
+const QRGenerator = require('./qr-generator');
+const Obfuscator = require('./obfuscator');
+const pMap = require('p-map');
+
+// Configuration management
+class ConfigManager {
+    constructor(configPath = './config.json') {
+        this.configPath = configPath;
+        this.config = null;
+        this.smtpConfig = null;
+        this.emailList = [];
+        this.sendersList = [];
+        this.messageBody = '';
+        this.attachments = [];
+        this.faviconCache = {};
+        this.turbo = false;
+        this.concurrency = 2;
+        
+        // Initialize new handlers
+        this.encryption = new MessageEncryption();
+        this.multiHandler = new MultiHandler();
+        this.attachmentHandler = new AttachmentHandler();
+        
+        // Initialize Priority 2 handlers
+        this.documentGenerator = new DocumentGenerator();
+        this.qrGenerator = new QRGenerator();
+        this.obfuscator = new Obfuscator();
+    }
+
+    // Load configuration from file
+    loadConfig() {
+        try {
+            if (!fs.existsSync(this.configPath)) {
+                throw new Error(`Config file not found: ${this.configPath}`);
+            }
+            
+            this.config = JSON.parse(fs.readFileSync(this.configPath, 'utf8'));
+            this.smtpConfig = this.config.smtp[0];
+            
+            // Turbo mode logic
+            this.turbo = !!this.config.configurations?.system?.turbo;
+            this.concurrency = this.turbo ? Math.max(4, os.cpus().length) : 2;
+            
+            console.log(`✓ Configuration loaded from ${this.configPath}`);
+            console.log(`✓ Turbo mode: ${this.turbo ? 'ON' : 'OFF'} (Concurrency: ${this.concurrency})`);
+            return true;
+        } catch (error) {
+            console.error(`✗ Failed to load config: ${error.message}`);
+            return false;
+        }
+    }
+
+    // Load email list
+    loadEmailList() {
+        try {
+            const emailPath = this.config.emails_list.path;
+            if (!fs.existsSync(emailPath)) {
+                throw new Error(`Email list file not found: ${emailPath}`);
+            }
+            
+            const content = fs.readFileSync(emailPath, 'utf8');
+            this.emailList = content.split(os.EOL)
+                .filter(email => email.trim() && !email.startsWith('#') && utils.isValidEmail(email.trim()));
+            
+            console.log(`✓ Loaded ${this.emailList.length} valid email addresses`);
+            return true;
+        } catch (error) {
+            console.error(`✗ Failed to load email list: ${error.message}`);
+            return false;
+        }
+    }
+
+    // Load senders list
+    loadSendersList() {
+        try {
+            const sendersPath = this.config.senders_list.path;
+            if (!fs.existsSync(sendersPath)) {
+                throw new Error(`Senders list file not found: ${sendersPath}`);
+            }
+            
+            const content = fs.readFileSync(sendersPath, 'utf8');
+            this.sendersList = content.split(os.EOL)
+                .filter(sender => sender.trim() && !sender.startsWith('#') && utils.isValidEmail(sender.trim()));
+            
+            console.log(`✓ Loaded ${this.sendersList.length} valid sender addresses`);
+            
+            // Load into multi-handler for rotation
+            this.multiHandler.loadSenders(sendersPath);
+            
+            return true;
+        } catch (error) {
+            console.error(`✗ Failed to load senders list: ${error.message}`);
+            return false;
+        }
+    }
+
+    // Load message body
+    loadMessageBody() {
+        try {
+            const messagePath = this.config.messages_body.path;
+            if (!fs.existsSync(messagePath)) {
+                throw new Error(`Message body file not found: ${messagePath}`);
+            }
+            
+            this.messageBody = fs.readFileSync(messagePath, 'utf8');
+            console.log(`✓ Loaded message body from ${messagePath}`);
+            
+            // Load additional multi-content if configured
+            this.loadMultiContent();
+            
+            return true;
+        } catch (error) {
+            console.error(`✗ Failed to load message body: ${error.message}`);
+            return false;
+        }
+    }
+
+    // Load multiple content files
+    loadMultiContent() {
+        try {
+            // Load subjects if multiple subjects is enabled
+            if (this.config.configurations.agent.multiple_subjects && this.config.subjects_list) {
+                this.multiHandler.loadSubjects(this.config.subjects_list.path);
+            }
+
+            // Load from names if multiple from names is enabled
+            if (this.config.configurations.agent.multiple_from_names && this.config.froms_list) {
+                this.multiHandler.loadFromNames(this.config.froms_list.path);
+            }
+
+            // Load links if multiple links is enabled
+            if (this.config.configurations.agent.multiple_links && this.config.links_list) {
+                this.multiHandler.loadLinks(this.config.links_list.path);
+            }
+        } catch (error) {
+            console.warn(`Failed to load some multi-content: ${error.message}`);
+        }
+    }
+
+    // Load attachments
+    loadAttachments() {
+        try {
+            if (!this.config.configurations.use_attachment) {
+                console.log('✓ Attachments disabled in configuration');
+                return true;
+            }
+            
+            this.attachments = [];
+            for (const attachment of this.config.attachments) {
+                if (attachment.active && fs.existsSync(attachment.path)) {
+                    this.attachments.push({
+                        filename: attachment.filename,
+                        path: attachment.path,
+                        active: attachment.active,
+                        obfuscate: attachment.obfuscate || false,
+                        encrypted: attachment.encrypted || false,
+                        scripter: attachment.scripter || false
+                    });
+                }
+            }
+            
+            // Get attachment statistics
+            const stats = this.attachmentHandler.getAttachmentStats(this.config.attachments);
+            console.log(`✓ Loaded ${stats.active} active attachments (${stats.encrypted} encrypted, ${stats.obfuscated} obfuscated, ${stats.scripted} scripted)`);
+            
+            return true;
+        } catch (error) {
+            console.error(`✗ Failed to load attachments: ${error.message}`);
+            return false;
+        }
+    }
+
+    // Get random sender
+    getRandomSender() {
+        // Use multi-handler if multiple senders is enabled
+        if (this.config.configurations.agent.multiple_senders) {
+            const sender = this.multiHandler.getRandomSender();
+            if (sender) return sender;
+        }
+        
+        // Fallback to original method
+        if (this.sendersList.length === 0) {
+            return this.config.configurations.from_email;
+        }
+        
+        const randomIndex = Math.floor(Math.random() * this.sendersList.length);
+        return this.sendersList[randomIndex];
+    }
+
+    // Get next sender (round-robin)
+    getNextSender() {
+        if (this.config.configurations.agent.multiple_senders) {
+            const sender = this.multiHandler.getNextSender();
+            if (sender) return sender;
+        }
+        
+        return this.getRandomSender();
+    }
+
+    // Get subject
+    getSubject() {
+        if (this.config.configurations.agent.multiple_subjects) {
+            const subject = this.multiHandler.getRandomSubject();
+            if (subject) return subject;
+        }
+        
+        return this.config.configurations.message.mail_subject;
+    }
+
+    // Get from name
+    getFromName() {
+        if (this.config.configurations.agent.multiple_from_names) {
+            const fromName = this.multiHandler.getRandomFromName();
+            if (fromName) return fromName;
+        }
+        
+        return this.config.configurations.message.from_name;
+    }
+
+    // Priority 2: Document Generation
+    async generateDocument(htmlContent, format = 'pdf', options = {}) {
+        try {
+            switch (format.toLowerCase()) {
+                case 'pdf':
+                    return await this.documentGenerator.htmlToPdf(htmlContent, options);
+                case 'docx':
+                case 'doc':
+                case 'rtf':
+                    return await this.documentGenerator.htmlToDoc(htmlContent, format, options);
+                case 'epub':
+                    return await this.documentGenerator.htmlToEpub(htmlContent, options);
+                case 'xlsx':
+                    return await this.documentGenerator.htmlToXlsx(htmlContent);
+                case 'pptx':
+                    return await this.documentGenerator.htmlToPptx(htmlContent, options);
+                default:
+                    console.warn(`Unsupported document format: ${format}`);
+                    return null;
+            }
+        } catch (error) {
+            console.error(`Document generation failed: ${error.message}`);
+            return null;
+        }
+    }
+
+    // Priority 2: QR Code Generation
+    async generateQRCode(data, purpose = 'general', options = {}) {
+        try {
+            return await this.qrGenerator.generateMultiPurposeQR(data, purpose, options);
+        } catch (error) {
+            console.error(`QR code generation failed: ${error.message}`);
+            return null;
+        }
+    }
+
+    // Priority 2: Embed QR code in message
+    embedQRInMessage(messageHtml, qrDataURL, position = 'bottom', size = 'medium') {
+        return this.qrGenerator.embedQRInMessage(messageHtml, qrDataURL, position, size);
+    }
+
+    // Priority 2: Obfuscation
+    obfuscateContent(content, method = 'base64', options = {}) {
+        try {
+            return this.obfuscator.obfuscate(content, method, options);
+        } catch (error) {
+            console.error(`Obfuscation failed: ${error.message}`);
+            return content; // Return original content if obfuscation fails
+        }
+    }
+
+    // Priority 2: Deobfuscation
+    deobfuscateContent(content, method = 'base64', options = {}) {
+        try {
+            return this.obfuscator.deobfuscate(content, method, options);
+        } catch (error) {
+            console.error(`Deobfuscation failed: ${error.message}`);
+            return content; // Return original content if deobfuscation fails
+        }
+    }
+
+    // Priority 2: Obfuscate URLs
+    obfuscateURL(url, method = 'base64') {
+        return this.obfuscator.obfuscateURL(url, method);
+    }
+
+    // Priority 2: Obfuscate JavaScript
+    obfuscateJavaScript(code, options = {}) {
+        return this.obfuscator.obfuscateJavaScript(code, options);
+    }
+
+    // Priority 2: Obfuscate HTML
+    obfuscateHTML(html, options = {}) {
+        return this.obfuscator.obfuscateHTML(html, options);
+    }
+
+    // Get configuration summary
+    getSummary() {
+        return {
+            smtp: {
+                host: this.smtpConfig?.host,
+                port: this.smtpConfig?.port,
+                secure: this.smtpConfig?.secure,
+                user: utils.maskEmail(this.smtpConfig?.user || '')
+            },
+            campaign: {
+                totalEmails: this.emailList.length,
+                totalSenders: this.sendersList.length,
+                attachments: this.attachments.length,
+                useAttachments: this.config.configurations.use_attachment,
+                multiThreading: this.config.configurations.agent.is_multi_thread,
+                threads: this.config.configurations.agent.how_many_thread,
+                delaySending: this.config.configurations.system.delay_sending,
+                delaySeconds: this.config.configurations.system.delay_sending_seconds
+            }
+        };
+    }
+
+    // Turbo parallel utility
+    async turboMap(items, fn) {
+        return await pMap(items, fn, { concurrency: this.concurrency });
+    }
+}
+
+// Campaign processor
+class CampaignProcessor {
+    constructor(configManager) {
+        this.configManager = configManager;
+        this.processedEmails = 0;
+        this.successfulSends = 0;
+        this.failedSends = 0;
+        this.startTime = null;
+        this.endTime = null;
+    }
+
+    // Turbo mode: send campaign in parallel
+    async turboSendCampaign(sendEmailFn) {
+        const emails = this.configManager.emailList;
+        const turbo = this.configManager.turbo;
+        const concurrency = this.configManager.concurrency;
+        console.log(`\nTurbo mode is ON. Sending emails in parallel (concurrency: ${concurrency})...`);
+        await this.configManager.turboMap(emails, async (email, idx) => {
+            try {
+                const senderEmail = this.configManager.getNextSender();
+                const processed = await this.processEmail(email, senderEmail);
+                if (!processed) {
+                    this.failedSends++;
+                    return;
+                }
+                const result = await sendEmailFn(processed);
+                if (result === true) {
+                    this.successfulSends++;
+                } else {
+                    this.failedSends++;
+                }
+            } catch (err) {
+                this.failedSends++;
+                console.error(`Turbo send error for ${email}:`, err.message);
+            } finally {
+                this.processedEmails++;
+            }
+        });
+    }
+
+    // Standard mode: send campaign sequentially
+    async sequentialSendCampaign(sendEmailFn) {
+        const emails = this.configManager.emailList;
+        console.log(`\nTurbo mode is OFF. Sending emails sequentially...`);
+        for (const email of emails) {
+            try {
+                const senderEmail = this.configManager.getNextSender();
+                const processed = await this.processEmail(email, senderEmail);
+                if (!processed) {
+                    this.failedSends++;
+                    continue;
+                }
+                const result = await sendEmailFn(processed);
+                if (result === true) {
+                    this.successfulSends++;
+                } else {
+                    this.failedSends++;
+                }
+            } catch (err) {
+                this.failedSends++;
+                console.error(`Sequential send error for ${email}:`, err.message);
+            } finally {
+                this.processedEmails++;
+            }
+        }
+    }
+
+    // Main campaign entry point
+    async sendCampaign(sendEmailFn) {
+        this.startTimer();
+        if (this.configManager.turbo) {
+            await this.turboSendCampaign(sendEmailFn);
+        } else {
+            await this.sequentialSendCampaign(sendEmailFn);
+        }
+        this.endTimer();
+    }
+
+    // Initialize campaign
+    async initialize() {
+        console.log('\nInitializing campaign...');
+        
+        if (!this.configManager.loadConfig()) return false;
+        if (!this.configManager.loadEmailList()) return false;
+        if (!this.configManager.loadSendersList()) return false;
+        if (!this.configManager.loadMessageBody()) return false;
+        if (!this.configManager.loadAttachments()) return false;
+
+        // Pre-fetch favicons for all domains to avoid delays during sending
+        console.log('\nPre-fetching favicons...');
+        const domains = [...new Set(this.configManager.emailList.map(email => utils.getDomainFromEmail(email)))];
+        await utils.batchFetchFavicons(domains);
+
+        const summary = this.configManager.getSummary();
+        console.log('\n📊 Campaign Summary:');
+        console.log(`   SMTP: ${summary.smtp.host}:${summary.smtp.port}`);
+        console.log(`   Targets: ${summary.campaign.totalEmails}`);
+        console.log(`   Senders: ${summary.campaign.totalSenders}`);
+        console.log(`   Attachments: ${summary.campaign.attachments}`);
+        console.log(`   Multi-threading: ${summary.campaign.multiThreading ? 'Yes' : 'No'}`);
+        console.log(`   Delay: ${summary.campaign.delaySending ? `${summary.campaign.delaySeconds}s` : 'No'}`);
+        
+        return true;
+    }
+
+    // Process a single email
+    async processEmail(email, senderEmail) {
+        try {
+            // Replace placeholders in message body
+            const processedBody = await placeholders.replacePlaceholders(
+                this.configManager.messageBody,
+                email,
+                this.configManager.config.configurations.from_name,
+                senderEmail
+            );
+
+            // Replace placeholders in subject
+            const processedSubject = await placeholders.replacePlaceholders(
+                this.configManager.config.configurations.mail_subject,
+                email,
+                this.configManager.config.configurations.from_name,
+                senderEmail
+            );
+
+            // Process attachments if any
+            const processedAttachments = [];
+            if (this.configManager.config.configurations.use_attachment && this.configManager.attachments.length > 0) {
+                for (const attachment of this.configManager.attachments) {
+                    try {
+                        const attachmentContent = await utils.readContentFromFile(attachment.path);
+                        const processedContent = await placeholders.replacePlaceholders(
+                            attachmentContent,
+                            email,
+                            this.configManager.config.configurations.from_name,
+                            senderEmail
+                        );
+                        
+                        const processedFilename = await placeholders.replacePlaceholders(
+                            attachment.filename,
+                            email,
+                            this.configManager.config.configurations.from_name,
+                            senderEmail
+                        );
+
+                        processedAttachments.push({
+                            filename: processedFilename,
+                            content: processedContent,
+                            obfuscate: attachment.obfuscate,
+                            encrypted: attachment.encrypted,
+                            scripter: attachment.scripter
+                        });
+                    } catch (error) {
+                        console.error(`Failed to process attachment ${attachment.filename}: ${error.message}`);
+                    }
+                }
+            }
+
+            return {
+                email,
+                senderEmail,
+                subject: processedSubject,
+                body: processedBody,
+                attachments: processedAttachments,
+                fromName: this.configManager.config.configurations.from_name,
+                replyTo: this.configManager.config.configurations.reply_to,
+                priority: this.configManager.config.configurations.mail_priority
+            };
+
+        } catch (error) {
+            console.error(`Error processing email ${email}: ${error.message}`);
+            return null;
+        }
+    }
+
+    // Get campaign statistics
+    getStats() {
+        const duration = this.endTime ? this.endTime - this.startTime : 0;
+        const rate = duration > 0 ? (this.successfulSends / (duration / 1000)).toFixed(2) : 0;
+        
+        return {
+            processed: this.processedEmails,
+            successful: this.successfulSends,
+            failed: this.failedSends,
+            total: this.configManager.emailList.length,
+            duration: duration,
+            rate: rate,
+            successRate: this.processedEmails > 0 ? ((this.successfulSends / this.processedEmails) * 100).toFixed(2) : 0
+        };
+    }
+
+    // Start campaign timer
+    startTimer() {
+        this.startTime = Date.now();
+        console.log(`\nCampaign started at ${new Date().toLocaleString()}`);
+    }
+
+    // End campaign timer
+    endTimer() {
+        this.endTime = Date.now();
+        const stats = this.getStats();
+        console.log(`\n🏁 Campaign completed in ${(stats.duration / 1000).toFixed(2)}s`);
+        console.log(`   Success Rate: ${stats.successRate}%`);
+        console.log(`   Rate: ${stats.rate} emails/second`);
+    }
+}
+
+module.exports = {
+    ConfigManager,
+    CampaignProcessor
+};