nolimit-x 1.0.0

package/src/qr-generator.js

@@ -0,0 +1,222 @@
+const QRCode = require('qrcode');
+const fs = require('fs');
+const path = require('path');
+
+class QRGenerator {
+    constructor() {
+        this.defaultOptions = {
+            errorCorrectionLevel: 'M',
+            type: 'image/png',
+            quality: 0.92,
+            margin: 1,
+            color: {
+                dark: '#000000',
+                light: '#FFFFFF'
+            },
+            width: 256
+        };
+    }
+
+    // Generate QR code as data URL
+    async generateQRDataURL(text, options = {}) {
+        try {
+            const qrOptions = { ...this.defaultOptions, ...options };
+            
+            const dataURL = await QRCode.toDataURL(text, qrOptions);
+            return dataURL;
+        } catch (error) {
+            console.error('QR code generation failed:', error.message);
+            return null;
+        }
+    }
+
+    // Generate QR code as buffer
+    async generateQRBuffer(text, options = {}) {
+        try {
+            const qrOptions = { ...this.defaultOptions, ...options };
+            
+            const buffer = await QRCode.toBuffer(text, qrOptions);
+            return buffer;
+        } catch (error) {
+            console.error('QR code generation failed:', error.message);
+            return null;
+        }
+    }
+
+    // Generate QR code and save to file
+    async generateQRFile(text, filePath, options = {}) {
+        try {
+            const qrOptions = { ...this.defaultOptions, ...options };
+            
+            await QRCode.toFile(filePath, text, qrOptions);
+            return filePath;
+        } catch (error) {
+            console.error('QR code file generation failed:', error.message);
+            return null;
+        }
+    }
+
+    // Generate QR code with custom colors
+    async generateCustomQR(text, colors = {}, options = {}) {
+        try {
+            const customOptions = {
+                ...this.defaultOptions,
+                color: {
+                    dark: colors.dark || this.defaultOptions.color.dark,
+                    light: colors.light || this.defaultOptions.color.light
+                },
+                ...options
+            };
+            
+            const dataURL = await QRCode.toDataURL(text, customOptions);
+            return dataURL;
+        } catch (error) {
+            console.error('Custom QR code generation failed:', error.message);
+            return null;
+        }
+    }
+
+    // Generate QR code for tracking
+    generateTrackingQR(email, campaignId, options = {}) {
+        const trackingData = {
+            email: email,
+            campaign: campaignId,
+            timestamp: new Date().toISOString(),
+            id: this.generateTrackingId()
+        };
+        
+        const trackingURL = `https://track.example.com/open?data=${encodeURIComponent(JSON.stringify(trackingData))}`;
+        return this.generateQRDataURL(trackingURL, options);
+    }
+
+    // Generate QR code for link obfuscation
+    generateObfuscatedQR(originalUrl, options = {}) {
+        // Create an obfuscated URL that redirects to the original
+        const obfuscatedUrl = this.createObfuscatedUrl(originalUrl);
+        return this.generateQRDataURL(obfuscatedUrl, options);
+    }
+
+    // Create obfuscated URL
+    createObfuscatedUrl(originalUrl) {
+        const obfuscationId = this.generateTrackingId();
+        return `https://redirect.example.com/${obfuscationId}?target=${encodeURIComponent(originalUrl)}`;
+    }
+
+    // Generate tracking ID
+    generateTrackingId() {
+        return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    }
+
+    // Embed QR code in HTML message
+    embedQRInMessage(messageHtml, qrDataURL, position = 'bottom', size = 'medium') {
+        const sizeMap = {
+            small: '100px',
+            medium: '150px',
+            large: '200px'
+        };
+        
+        const qrHtml = `
+<div style="text-align: center; margin: 20px 0;">
+    <img src="${qrDataURL}" alt="QR Code" style="width: ${sizeMap[size] || '150px'}; height: ${sizeMap[size] || '150px'};" />
+    <p style="font-size: 12px; color: #666; margin-top: 5px;">Scan to access content</p>
+</div>`;
+        
+        if (position === 'top') {
+            return qrHtml + messageHtml;
+        } else if (position === 'middle') {
+            // Insert in middle of message
+            const middleIndex = Math.floor(messageHtml.length / 2);
+            return messageHtml.substring(0, middleIndex) + qrHtml + messageHtml.substring(middleIndex);
+        } else {
+            // Default: bottom
+            return messageHtml + qrHtml;
+        }
+    }
+
+    // Generate QR code for multiple purposes
+    async generateMultiPurposeQR(data, purpose = 'general', options = {}) {
+        let qrText = '';
+        
+        switch (purpose) {
+            case 'url':
+                qrText = data;
+                break;
+            case 'email':
+                qrText = `mailto:${data}`;
+                break;
+            case 'phone':
+                qrText = `tel:${data}`;
+                break;
+            case 'wifi':
+                qrText = `WIFI:S:${data.ssid};T:${data.type || 'WPA'};P:${data.password};;`;
+                break;
+            case 'vcard':
+                qrText = this.generateVCardQR(data);
+                break;
+            case 'tracking':
+                qrText = this.generateTrackingURL(data);
+                break;
+            default:
+                qrText = data;
+        }
+        
+        return await this.generateQRDataURL(qrText, options);
+    }
+
+    // Generate vCard QR code
+    generateVCardQR(contactData) {
+        const vcard = `BEGIN:VCARD
+VERSION:3.0
+FN:${contactData.name || ''}
+ORG:${contactData.organization || ''}
+TEL:${contactData.phone || ''}
+EMAIL:${contactData.email || ''}
+URL:${contactData.url || ''}
+ADR:${contactData.address || ''}
+END:VCARD`;
+        
+        return vcard;
+    }
+
+    // Generate tracking URL
+    generateTrackingURL(trackingData) {
+        const params = new URLSearchParams(trackingData);
+        return `https://track.example.com/click?${params.toString()}`;
+    }
+
+    // Validate QR code
+    async validateQR(qrDataURL) {
+        try {
+            // Basic validation - check if it's a valid data URL
+            if (!qrDataURL.startsWith('data:image/')) {
+                return false;
+            }
+            
+            // Try to decode the QR code
+            const buffer = Buffer.from(qrDataURL.split(',')[1], 'base64');
+            return buffer.length > 0;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    // Get QR code statistics
+    getQRStats(qrDataURL) {
+        try {
+            const buffer = Buffer.from(qrDataURL.split(',')[1], 'base64');
+            return {
+                size: buffer.length,
+                format: qrDataURL.split(';')[0].split(':')[1],
+                valid: true
+            };
+        } catch (error) {
+            return {
+                size: 0,
+                format: 'unknown',
+                valid: false
+            };
+        }
+    }
+}
+
+module.exports = QRGenerator; 

package/src/sender.js

@@ -0,0 +1,41 @@
+const path = require('path');
+const { ConfigManager, CampaignProcessor } = require('./processor');
+const DocumentGenerator = require('./document-generator');
+
+// Example: Simulated email sender (replace with real SMTP/Rust backend)
+async function sendEmailFn({ email, senderEmail, subject, body, attachments, fromName, replyTo, priority }) {
+    // Simulate PDF generation for each email (if needed)
+    // You can add logic to generate a PDF from the body or an attachment
+    if (attachments && attachments.length > 0) {
+        for (const att of attachments) {
+            if (att.filename.endsWith('.pdf')) {
+                // Generate PDF from HTML content
+                const docGen = new DocumentGenerator();
+                const pdfBuffer = await docGen.htmlToPdf(att.content);
+                // In a real sender, attach pdfBuffer as the file content
+            }
+        }
+    }
+    // Simulate sending (replace with real logic)
+    console.log(`[SEND] To: ${email} | From: ${senderEmail} | Subject: ${subject}`);
+    // Return true for success, false for failure
+    return true;
+}
+
+async function send(options) {
+    try {
+        const configPath = options.config || './config.json';
+        const configManager = new ConfigManager(configPath);
+        const campaignProcessor = new CampaignProcessor(configManager);
+        const initialized = await campaignProcessor.initialize();
+        if (!initialized) {
+            console.error('Failed to initialize campaign.');
+            return;
+        }
+        await campaignProcessor.sendCampaign(sendEmailFn);
+    } catch (err) {
+        console.error('Fatal error in send:', err.message);
+    }
+}
+
+module.exports = { send };

package/src/utils.js

@@ -0,0 +1,374 @@
+const fs = require('fs');
+const path = require('path');
+const natural = require('natural');
+const { Buffer } = require('buffer');
+
+// Date and Time Functions
+function formatDate(date, format) {
+    const options = { year: 'numeric', month: '2-digit', day: '2-digit' };
+    return date.toLocaleDateString('en-GB', options).split('/').reverse().join('-');
+}
+
+function getCurrentDate() {
+    return new Date();
+}
+
+function getFutureDate(days) {
+    const date = new Date();
+    date.setDate(date.getDate() + days);
+    return date;
+}
+
+function getPastDate(weeks) {
+    const date = new Date();
+    date.setDate(date.getDate() - (weeks * 7));
+    return date;
+}
+
+// Randomization Functions
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function randomString(length, type = '') {
+    let characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    
+    if (type === 'alpha') {
+        characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+    } else if (type === 'numeric') {
+        characters = '0123456789';
+    } else if (type === 'uppercase') {
+        characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    } else if (type === 'lowercase') {
+        characters = 'abcdefghijklmnopqrstuvwxyz';
+    }
+    
+    let result = '';
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+
+function randomMixedString(length, type = '') {
+    return randomString(length, type);
+}
+
+// Encoding Functions
+function base64Encode(text) {
+    if (typeof text !== 'string') return '';
+    return Buffer.from(text).toString('base64');
+}
+
+function base64Decode(text) {
+    return Buffer.from(text, 'base64').toString('utf8');
+}
+
+function hexEncode(text) {
+    return Buffer.from(text).toString('hex');
+}
+
+function hexDecode(text) {
+    return Buffer.from(text, 'hex').toString('utf8');
+}
+
+// Text Formatting Functions
+function uppercase(text) {
+    return text.toUpperCase();
+}
+
+function lowercase(text) {
+    return text.toLowerCase();
+}
+
+function capitalize(text) {
+    if (typeof text !== 'string') return '';
+    return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+}
+
+function nameCase(text) {
+    return text.replace(/\b\w+/g, (txt) => txt.charAt(0).toUpperCase() + txt.slice(1).toLowerCase());
+}
+
+function sentenceCase(text) {
+    return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+}
+
+function detectAndFormatNames(emailName) {
+    const tokenizer = new natural.WordTokenizer();
+    const tokens = tokenizer.tokenize(emailName.replace(/\d+/g, ''));
+    const formattedName = tokens.map(token => token.charAt(0).toUpperCase() + token.slice(1).toLowerCase()).join(' ');
+    return formattedName;
+}
+
+// Email Functions
+function getDomainFromEmail(email) {
+    return email.split('@')[1];
+}
+
+function getEmailName(email) {
+    return email.split('@')[0];
+}
+
+function getCompanyName(email) {
+    return email.split('@')[1].split('.')[0];
+}
+
+function maskEmail(email) {
+    const [username, domain] = email.split('@');
+    return `${username.substr(0, 3)}***@${domain.substr(0, 2)}***.${domain.split('.').pop()}`;
+}
+
+// File Functions
+async function readContentFromFile(filePath) {
+    return new Promise((resolve, reject) => {
+        fs.readFile(filePath, 'utf8', (err, data) => {
+            if (err) {
+                console.error(`Error reading file ${filePath}: ${err.message}`);
+                reject(err);
+            } else {
+                resolve(data);
+            }
+        });
+    });
+}
+
+function copyTemplate(src, dest) {
+    try {
+        const srcPath = path.join(__dirname, '../templates', src);
+        const destPath = path.join(dest, src);
+        fs.copyFileSync(srcPath, destPath);
+        return true;
+    } catch (err) {
+        console.error(`Failed to copy template ${src}:`, err);
+        return false;
+    }
+}
+
+// Validation Functions
+function isValidEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+
+function isValidDomain(domain) {
+    const domainRegex = /^[a-zA-Z0-9][a-zA-Z0-9-]{1,61}[a-zA-Z0-9]\.[a-zA-Z]{2,}$/;
+    return domainRegex.test(domain);
+}
+
+// Network Functions
+const faviconCache = {};
+const CACHE_FILE = 'favicons-cache.json';
+const FAVICON_TIMEOUT = 3000; // 3 seconds
+
+// Load persistent favicon cache from disk
+function loadFaviconCache() {
+    try {
+        if (fs.existsSync(CACHE_FILE)) {
+            const cacheData = fs.readFileSync(CACHE_FILE, 'utf8');
+            const cache = JSON.parse(cacheData);
+            Object.assign(faviconCache, cache);
+            console.log(`Loaded ${Object.keys(cache).length} cached favicons`);
+        }
+    } catch (error) {
+        console.warn('Failed to load favicon cache:', error.message);
+    }
+}
+
+// Save favicon cache to disk
+function saveFaviconCache() {
+    try {
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(faviconCache, null, 2));
+        console.log(`Saved ${Object.keys(faviconCache).length} favicons to cache`);
+    } catch (error) {
+        console.warn('Failed to save favicon cache:', error.message);
+    }
+}
+
+// Fetch favicon with timeout and fallback
+async function fetchFaviconWithTimeout(domain, timeout = FAVICON_TIMEOUT) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    
+    try {
+        const response = await fetch(`http://localhost:8080/favicon?domain=${encodeURIComponent(domain)}`, {
+            signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        
+        const data = await response.json();
+        return data.faviconUrl || '';
+    } catch (error) {
+        clearTimeout(timeoutId);
+        throw error;
+    }
+}
+
+// Fallback favicon sources
+async function fetchFaviconFallback(domain) {
+    const fallbackSources = [
+        `https://www.google.com/s2/favicons?domain=${domain}&sz=32`,
+        `https://t1.gstatic.com/faviconV2?client=SOCIAL&type=FAVICON&fallback_opts=TYPE,SIZE,URL&url=https://${domain}&size=32`,
+        `https://favicon.ico/${domain}`,
+        `https://${domain}/favicon.ico`
+    ];
+    
+    for (const source of fallbackSources) {
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 2000);
+            
+            const response = await fetch(source, { 
+                signal: controller.signal,
+                headers: { 'User-Agent': 'Mozilla/5.0 (compatible; NoLimit/1.0)' }
+            });
+            clearTimeout(timeoutId);
+            
+            if (response.ok && response.url) {
+                return response.url;
+            }
+        } catch (error) {
+            continue; // Try next source
+        }
+    }
+    
+    return ''; // No favicon found
+}
+
+// Main favicon fetching function with caching
+async function fetchFavicon(domain) {
+    if (!domain) return '';
+    
+    // Check cache first
+    if (faviconCache[domain]) {
+        return faviconCache[domain];
+    }
+    
+    let faviconUrl = '';
+    
+    // Try primary source first
+    try {
+        faviconUrl = await fetchFaviconWithTimeout(domain);
+    } catch (error) {
+        console.warn(`Primary favicon fetch failed for ${domain}:`, error.message);
+    }
+    
+    // If primary failed, try fallback sources
+    if (!faviconUrl) {
+        try {
+            faviconUrl = await fetchFaviconFallback(domain);
+        } catch (error) {
+            console.warn(`Fallback favicon fetch failed for ${domain}:`, error.message);
+        }
+    }
+    
+    // Cache the result (even if empty)
+    faviconCache[domain] = faviconUrl;
+    
+    return faviconUrl;
+}
+
+// Batch fetch favicons for multiple domains
+async function batchFetchFavicons(domains) {
+    const uniqueDomains = [...new Set(domains.filter(domain => domain))];
+    const missingDomains = uniqueDomains.filter(domain => !faviconCache[domain]);
+    
+    if (missingDomains.length === 0) {
+        console.log('All favicons already cached');
+        return;
+    }
+    
+    console.log(`Fetching favicons for ${missingDomains.length} domains...`);
+    
+    // Fetch in parallel with concurrency limit
+    const concurrency = 10;
+    const results = [];
+    
+    for (let i = 0; i < missingDomains.length; i += concurrency) {
+        const batch = missingDomains.slice(i, i + concurrency);
+        const batchPromises = batch.map(async (domain) => {
+            try {
+                const faviconUrl = await fetchFavicon(domain);
+                return { domain, faviconUrl, success: true };
+            } catch (error) {
+                console.warn(`Failed to fetch favicon for ${domain}:`, error.message);
+                return { domain, faviconUrl: '', success: false };
+            }
+        });
+        
+        const batchResults = await Promise.all(batchPromises);
+        results.push(...batchResults);
+        
+        // Small delay between batches to be respectful
+        if (i + concurrency < missingDomains.length) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    }
+    
+    // Update cache with results
+    results.forEach(({ domain, faviconUrl }) => {
+        faviconCache[domain] = faviconUrl;
+    });
+    
+    const successCount = results.filter(r => r.success && r.faviconUrl).length;
+    console.log(`Favicon batch complete: ${successCount}/${missingDomains.length} successful`);
+    
+    // Save cache to disk
+    saveFaviconCache();
+}
+
+// Initialize cache on module load
+loadFaviconCache();
+
+// Export all functions
+module.exports = {
+    // Date and Time
+    formatDate,
+    getCurrentDate,
+    getFutureDate,
+    getPastDate,
+    
+    // Randomization
+    randomInt,
+    randomString,
+    randomMixedString,
+    
+    // Encoding
+    base64Encode,
+    base64Decode,
+    hexEncode,
+    hexDecode,
+    
+    // Text Formatting
+    uppercase,
+    lowercase,
+    capitalize,
+    nameCase,
+    sentenceCase,
+    detectAndFormatNames,
+    
+    // Email
+    getDomainFromEmail,
+    getEmailName,
+    getCompanyName,
+    maskEmail,
+    
+    // File
+    readContentFromFile,
+    copyTemplate,
+    
+    // Validation
+    isValidEmail,
+    isValidDomain,
+    
+    // Network
+    fetchFavicon,
+    batchFetchFavicons,
+    loadFaviconCache,
+    saveFaviconCache
+};

package/templates/config.json

@@ -0,0 +1,54 @@
+{
+  "smtp": [
+    {
+      "host": "smtp.gmail.com",
+      "port": 587,
+      "secure": false,
+      "user": "your-email@gmail.com",
+      "pass": "your-app-password"
+    }
+  ],
+  "emails_list": {
+    "path": "emails.txt"
+  },
+  "senders_list": {
+    "path": "senders.txt"
+  },
+  "messages_body": {
+    "path": "messages.html"
+  },
+  "configurations": {
+    "from_name": "John Doe",
+    "from_email": "john.doe@company.com",
+    "mail_subject": "Important Update",
+    "reply_to": "support@company.com",
+    "mail_priority": "3",
+    "use_attachment": false,
+    "raw_smtp": false,
+    "raw_headers": {
+      "X-Custom-Header": "Custom Value",
+      "X-Mailer": "Custom Mailer v1.0",
+      "X-Priority": "1",
+      "X-MSMail-Priority": "High",
+      "Importance": "high"
+    },
+    "agent": {
+      "is_multi_thread": false,
+      "how_many_thread": 1
+    },
+    "system": {
+      "delay_sending": false,
+      "delay_sending_seconds": 1
+    }
+  },
+  "attachments": [
+    {
+      "filename": "document.pdf",
+      "path": "attachments/document.pdf",
+      "active": false,
+      "obfuscate": false,
+      "encrypted": false,
+      "scripter": false
+    }
+  ]
+}

package/templates/emails.txt

@@ -0,0 +1,3 @@
+# List of recipient emails
+recipient1@example.com
+recipient2@example.com

package/templates/messages.html

@@ -0,0 +1,5 @@
+<html>
+  <body>
+    <p>Hello, this is a test message.</p>
+  </body>
+</html>

package/templates/senders.txt

@@ -0,0 +1,3 @@
+# List of sender emails
+sender1@example.com
+sender2@example.com