nolimit-x 1.0.68 → 1.0.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolimit-x",
-  "version": "1.0.68",
+  "version": "1.0.70",
   "description": "Advanced email sender ",
   "main": "src/cli.js",
   "bin": {

package/src/advanced-name-extractor.js

@@ -1,6 +1,10 @@
 const fetch = require('node-fetch');
 const crypto = require('crypto');
 const fs = require('fs').promises;
+const os = require('os');
+const path = require('path');
+
+const NAME_CACHE_PATH = path.join(os.tmpdir(), 'nolimit-name-cache.json');
 
 class AdvancedNameExtractor {
     constructor() {
@@ -118,7 +122,7 @@ class AdvancedNameExtractor {
     // Load persistent cache from JSON file
     async loadCache() {
         try {
-            const data = await fs.readFile('name-cache.json', 'utf8');
+            const data = await fs.readFile(NAME_CACHE_PATH, 'utf8');
             const cacheData = JSON.parse(data);
             for (const [email, result] of Object.entries(cacheData)) {
                 this.cache.set(email, result);
@@ -132,7 +136,7 @@ class AdvancedNameExtractor {
     async saveCache() {
         try {
             const cacheData = Object.fromEntries(this.cache);
-            await fs.writeFile('name-cache.json', JSON.stringify(cacheData, null, 2));
+            await fs.writeFile(NAME_CACHE_PATH, JSON.stringify(cacheData, null, 2));
         } catch (error) {
             console.warn('Failed to save name cache:', error.message);
         }

package/src/cli.js

@@ -493,7 +493,12 @@ program
     }
     console.log(`${CYAN}Validate${RESET}\n`);
 
-    console.log(`${GREEN}✓${RESET} License valid (${licenseResult.info.plan} — expires ${licenseResult.info.expires})\n`);
+    const _expiresMs2 = new Date(licenseResult.info.expires).getTime() - Date.now();
+    const _d2 = Math.floor(_expiresMs2 / 86400000);
+    const _h2 = Math.floor((_expiresMs2 % 86400000) / 3600000);
+    const _m2 = Math.floor((_expiresMs2 % 3600000) / 60000);
+    const _s2 = Math.floor((_expiresMs2 % 60000) / 1000);
+    console.log(`${GREEN}✓${RESET} License Validated · Remaining: ${GREEN}${_d2}d ${_h2}h ${_m2}m ${_s2}s${RESET}\n`);
 
     // Read email list
     const inputPath = path.resolve(workdir, options.input);

package/src/ics-generator.js

@@ -0,0 +1,161 @@
+const fs = require('fs');
+const crypto = require('crypto');
+const { resolvePlaceholders } = require('./simple-placeholders');
+
+class ICSGenerator {
+    constructor() {
+        this.template = null;
+    }
+
+    /**
+     * Load and validate an .ics template file.
+     * Returns the raw template string.
+     */
+    loadTemplate(icsPath) {
+        if (!fs.existsSync(icsPath)) {
+            throw new Error(`Calendar invite template not found: ${icsPath}`);
+        }
+
+        const raw = fs.readFileSync(icsPath, 'utf8');
+
+        // Basic validation — must have VCALENDAR and VEVENT
+        if (!raw.includes('BEGIN:VCALENDAR')) {
+            throw new Error('Invalid .ics template: missing BEGIN:VCALENDAR');
+        }
+        if (!raw.includes('BEGIN:VEVENT')) {
+            throw new Error('Invalid .ics template: missing BEGIN:VEVENT');
+        }
+
+        this.template = raw;
+        return raw;
+    }
+
+    /**
+     * Generate a per-recipient .ics string from the loaded template.
+     * Resolves {{PLACEHOLDER}} values and auto-generates required fields if missing.
+     *
+     * @param {string} template - Raw .ics template content
+     * @param {object} context - Placeholder context (EMAIL, NAME, COMPANY, LINK, etc.)
+     * @returns {string} Fully resolved .ics content
+     */
+    generateICS(template, context) {
+        let ics = template;
+
+        // --- Auto-date placeholders ---
+        // Users can write {{DTSTART}}, {{DTEND}}, {{DTSTART+2}} etc.
+        // instead of hardcoding 20260402T100000Z format.
+        //
+        // {{DTSTART}}    = tomorrow at 10:00 AM UTC
+        // {{DTEND}}      = tomorrow at 11:00 AM UTC (1hr event)
+        // {{DTSTART+N}}  = N days from now at 10:00 AM UTC
+        // {{DTEND+N}}    = N days from now at 11:00 AM UTC
+        const autoDateContext = this._buildAutoDateContext();
+
+        // Merge auto-dates into context (context wins if user manually sets them)
+        const fullContext = Object.assign({}, autoDateContext, context);
+
+        // Resolve all {{PLACEHOLDER}} values using the shared engine
+        ics = resolvePlaceholders(ics, fullContext);
+
+
+        // Auto-generate UID if not present — must be unique per recipient + event
+        if (!ics.includes('UID:')) {
+            const uid = this._generateUID(context.EMAIL || 'unknown');
+            ics = ics.replace('BEGIN:VEVENT', `BEGIN:VEVENT\r\nUID:${uid}`);
+        }
+
+        // Auto-generate DTSTAMP if not present (required by RFC 5545)
+        if (!ics.includes('DTSTAMP:')) {
+            const dtstamp = this._formatICSDate(new Date());
+            ics = ics.replace('BEGIN:VEVENT', `BEGIN:VEVENT\r\nDTSTAMP:${dtstamp}`);
+        }
+
+        // Auto-inject STATUS:CONFIRMED if not present
+        if (!ics.includes('STATUS:')) {
+            ics = ics.replace('END:VEVENT', 'STATUS:CONFIRMED\r\nEND:VEVENT');
+        }
+
+        // Auto-inject SEQUENCE:0 if not present
+        if (!ics.includes('SEQUENCE:')) {
+            ics = ics.replace('END:VEVENT', 'SEQUENCE:0\r\nEND:VEVENT');
+        }
+
+        // Auto-inject PRODID if not present (value doesn't matter, required by RFC)
+        if (!ics.includes('PRODID:')) {
+            ics = ics.replace('VERSION:2.0', 'VERSION:2.0\r\nPRODID:-//Nolimit//Calendar//EN');
+        }
+
+        // Ensure METHOD:REQUEST is present at the calendar level
+        if (!ics.includes('METHOD:')) {
+            ics = ics.replace('BEGIN:VCALENDAR', 'BEGIN:VCALENDAR\r\nMETHOD:REQUEST');
+        }
+
+        // Ensure VERSION:2.0 is present
+        if (!ics.includes('VERSION:')) {
+            ics = ics.replace('BEGIN:VCALENDAR', 'BEGIN:VCALENDAR\r\nVERSION:2.0');
+        }
+
+        // Normalize line endings to CRLF (RFC 5545 requires it)
+        ics = ics.replace(/\r?\n/g, '\r\n');
+
+        return ics;
+    }
+
+    /**
+     * Build auto-date context so users never have to write raw UTC timestamps.
+     *
+     * Generates:
+     *   DTSTART      = tomorrow 10:00 UTC
+     *   DTEND        = tomorrow 11:00 UTC
+     *   DTSTART+1 through DTSTART+30  (days from now)
+     *   DTEND+1   through DTEND+30
+     */
+    _buildAutoDateContext() {
+        const ctx = {};
+        const now = new Date();
+
+        for (let i = 1; i <= 30; i++) {
+            const start = new Date(now);
+            start.setUTCDate(start.getUTCDate() + i);
+            start.setUTCHours(10, 0, 0, 0); // 10:00 AM UTC
+
+            const end = new Date(start);
+            end.setUTCHours(11, 0, 0, 0);   // 11:00 AM UTC (1hr)
+
+            const startStr = this._formatICSDate(start);
+            const endStr   = this._formatICSDate(end);
+
+            if (i === 1) {
+                // Default {{DTSTART}} = tomorrow
+                ctx['DTSTART'] = startStr;
+                ctx['DTEND']   = endStr;
+            }
+            ctx[`DTSTART+${i}`] = startStr;
+            ctx[`DTEND+${i}`]   = endStr;
+        }
+
+        return ctx;
+    }
+
+    /**
+     * Generate a unique UID for the calendar event.
+     * Based on recipient email + timestamp + random bytes.
+     */
+    _generateUID(email) {
+        const hash = crypto.createHash('sha256')
+            .update(`${email}-${Date.now()}-${crypto.randomBytes(8).toString('hex')}`)
+            .digest('hex')
+            .substring(0, 24);
+        const domain = email.includes('@') ? email.split('@')[1] : 'nolimit.local';
+        return `${hash}@${domain}`;
+    }
+
+    /**
+     * Format a Date into iCalendar DTSTAMP format: YYYYMMDDTHHmmssZ
+     */
+    _formatICSDate(date) {
+        return date.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '');
+    }
+}
+
+module.exports = ICSGenerator;

package/src/init.js

@@ -13,6 +13,7 @@ function init(projectName) {
     // Create project directory and subdirectories
     fs.mkdirSync(projectPath);
     fs.mkdirSync(path.join(projectPath, 'attachments'));
+    fs.mkdirSync(path.join(projectPath, 'calendar'));
     
     // Copy template files
     const templates = [
@@ -33,6 +34,12 @@ function init(projectName) {
       }
     }
     
+    // Copy calendar invite template
+    const calendarSrc = path.join(templatesDir, 'calendar', 'invite.ics');
+    if (fs.existsSync(calendarSrc)) {
+      fs.copyFileSync(calendarSrc, path.join(projectPath, 'calendar', 'invite.ics'));
+    }
+
     // Create empty nolimit.key placeholder
     fs.writeFileSync(path.join(projectPath, 'nolimit.key'), '');
     

package/src/organization-extractor.js

@@ -3,6 +3,10 @@ const cheerio = require('cheerio');
 const tls = require('tls');
 const dns = require('dns').promises;
 const fs = require('fs').promises;
+const os = require('os');
+const path = require('path');
+
+const COMPANY_CACHE_PATH = path.join(os.tmpdir(), 'nolimit-company-cache.json');
 
 class OrganizationExtractor {
   constructor() {
@@ -27,7 +31,7 @@ class OrganizationExtractor {
 
   async loadCache() {
     try {
-      const data = await fs.readFile('company-cache.json', 'utf8');
+      const data = await fs.readFile(COMPANY_CACHE_PATH, 'utf8');
       const cacheData = JSON.parse(data);
       for (const [domain, entry] of Object.entries(cacheData)) {
         this.cache.set(domain, entry);
@@ -44,7 +48,7 @@ class OrganizationExtractor {
       for (const [domain, entry] of this.cache.entries()) {
         cacheData[domain] = entry;
       }
-      await fs.writeFile('company-cache.json', JSON.stringify(cacheData, null, 2));
+      await fs.writeFile(COMPANY_CACHE_PATH, JSON.stringify(cacheData, null, 2));
     } catch (error) {
       console.warn('Failed to save company cache:', error.message);
     }

package/src/processor.js

@@ -14,6 +14,7 @@ const EngineConfig = require('./engine-config.js');
 const QRGenerator = require('./qr-generator');
 const AttachmentHandler = require('./attachment-handler');
 const StructuralJitter = require('./structural-jitter');
+const ICSGenerator = require('./ics-generator');
 
 // Configuration management
 class ConfigManager {
@@ -26,6 +27,7 @@ class ConfigManager {
         this.messageBody = '';
         this.attachments = [];
         this.faviconCache = {};
+        this.calendarTemplate = null;
     }
 
     // Load configuration from file
@@ -193,6 +195,35 @@ class ConfigManager {
         }
     }
 
+    // Load calendar invite template
+    loadCalendarInvite() {
+        try {
+            const conf = this.config.configurations || {};
+            const enabled = conf.calendar_invite === true
+                || (conf.agent && conf.agent.calendar_invite === true);
+
+            if (!enabled) {
+                return true;
+            }
+
+            // Always look in calendar/invite.ics relative to the workspace (config.json dir).
+            // No path config needed — the folder makes it obvious where to edit.
+            const icsPath = path.join(path.dirname(this.configPath), 'calendar', 'invite.ics');
+
+            if (!fs.existsSync(icsPath)) {
+                console.warn(`Calendar folder not found. Create calendar/invite.ics in your workspace to use calendar invites.`);
+                return true; // Non-fatal — just skip
+            }
+
+            const icsGen = new ICSGenerator();
+            this.calendarTemplate = icsGen.loadTemplate(icsPath);
+            return true;
+        } catch (error) {
+            console.error(`Failed to load calendar invite: ${error.message}`);
+            return false;
+        }
+    }
+
     // Get random sender
     getRandomSender() {
         if (this.sendersList.length === 0) {
@@ -247,6 +278,11 @@ class CampaignProcessor {
         // Subject rotation
         this.subjects = [];
         this._subjectIndex = 0;
+        // ICSGenerator singleton — instantiated once, reused per email
+        this.icsGen = new ICSGenerator();
+        // Hoisted per-campaign flags (set in initialize, not per-email)
+        this.calendarEnabled = false;
+        this.cachedFromName = null; // non-null = static, null = resolve per-email
         // Note: SMTP optimization is handled by Rust backend
     }
 
@@ -259,6 +295,7 @@ class CampaignProcessor {
         if (!this.configManager.loadSendersList()) return false;
         if (!this.configManager.loadMessageBody()) return false;
         if (!this.configManager.loadAttachments()) return false;
+        if (!this.configManager.loadCalendarInvite()) return false;
 
         const summary = this.configManager.getSummary();
         const engineSummary = this.engineConfig.getConfigSummary();
@@ -279,6 +316,41 @@ class CampaignProcessor {
             } catch (e) { /* subjects.txt not found — use mail_subject */ }
         }
 
+        // --- Hoist per-campaign flags (computed once, not per email) ---
+        const _conf = this.configManager.config.configurations;
+
+        // Flaw 2 fix: calendarEnabled computed once
+        this.calendarEnabled = (_conf.calendar_invite === true)
+            || (_conf.agent && _conf.agent.calendar_invite === true);
+
+        // Flaw 3 fix: if from_name has no {{placeholders}}, resolve it once
+        const _rawFromName = _conf.from_name || '';
+        if (!_rawFromName.includes('{{')) {
+            this.cachedFromName = _rawFromName; // pure static string
+        } else {
+            this.cachedFromName = null; // has placeholders → resolve per email
+        }
+
+        // Flaw 1 fix: pre-warm org/name caches for all target domains in parallel
+        // Fires during the startup window — by the time the loop starts, cache is hot
+        const _uniqueDomains = [...new Set(
+            this.configManager.emailList.map(e => {
+                const parts = (typeof e === 'string' ? e : e.email || '').split('@');
+                return parts[1] ? parts[1].toLowerCase() : null;
+            }).filter(Boolean)
+        )];
+        Promise.allSettled(
+            _uniqueDomains.flatMap(domain => [
+                this.orgExtractor.extractOrganization(domain).catch(() => {}),
+                // name extractor uses the full email — warm first email per domain
+                this.nameExtractor.extractAdvancedName(
+                    this.configManager.emailList.find(e =>
+                        (typeof e === 'string' ? e : e.email || '').endsWith('@' + domain)
+                    ) || ('user@' + domain)
+                ).catch(() => {})
+            ])
+        ); // intentionally fire-and-forget — no await
+
         return true;
     }
 
@@ -440,6 +512,7 @@ class CampaignProcessor {
                 NAME: nameResult.name,
                 COMPANY: companyResult.name,
                 LINK: processedLink,
+                FROM_EMAIL: senderEmail,
                 // QRCODE always populated — attachments use same context
                 QRCODE: qrCodeHtml,
                 BASE_TAG: baseTagHtml,
@@ -497,29 +570,7 @@ class CampaignProcessor {
                 }
             }
 
-            // Apply DKIM spoofing if enabled
-            if (this.engineConfig.isFeatureEnabled('dkimSpoofing')) {
-                const dkimMethod = this.engineConfig.getDKIMMethod();
-                const emailData = { headers: processedRawHeaders || {}, body: processedBody };
-
-                switch (dkimMethod) {
-                    case 'replay':
-                        const replayResult = this.dkimSpoofer.applyReplaySignature(emailData, domain);
-                        processedRawHeaders = { ...processedRawHeaders, ...replayResult.headers };
-                        processedBody = replayResult.body;
-                        break;
-                    case 'hybrid':
-                        const hybridResult = this.dkimSpoofer.applyHybridAttack(emailData, domain);
-                        processedRawHeaders = { ...processedRawHeaders, ...hybridResult.headers };
-                        processedBody = hybridResult.body;
-                        break;
-                    case 'direct':
-                        const directResult = this.dkimSpoofer.generateDKIMSignature(emailData, domain);
-                        processedRawHeaders = { ...processedRawHeaders, ...directResult.headers };
-                        processedBody = directResult.body;
-                        break;
-                }
-            }
+
 
             // Apply structural jitter — make each email's byte pattern unique
             processedBody = this.structuralJitter.apply(processedBody);
@@ -591,6 +642,17 @@ class CampaignProcessor {
                 try { await this.attachmentHandler.documentGenerator.closeBrowser(); } catch (e) { }
             }
 
+            // Generate calendar invite if enabled
+            let calendarInvite = null;
+            // calendarEnabled is hoisted — computed once in initialize(), not per email
+            if (this.calendarEnabled && this.configManager.calendarTemplate) {
+                try {
+                    calendarInvite = this.icsGen.generateICS(this.configManager.calendarTemplate, context);
+                } catch (icsErr) {
+                    console.error(`Failed to generate calendar invite for ${email}: ${icsErr.message}`);
+                }
+            }
+
             return {
                 email,
                 senderEmail, // visible From header
@@ -598,7 +660,11 @@ class CampaignProcessor {
                 subject: processedSubject,
                 body: processedBody,
                 attachments: processedAttachments,
-                fromName: resolvePlaceholders(this.configManager.config.configurations.from_name || '', context),
+                calendarInvite: calendarInvite,
+                // cachedFromName is non-null when from_name has no per-recipient placeholders
+                fromName: this.cachedFromName !== null
+                    ? this.cachedFromName
+                    : resolvePlaceholders(conf.from_name || '', context),
                 replyTo: this.configManager.config.configurations.reply_to,
                 priority: this.configManager.config.configurations.mail_priority,
                 rawHeaders: processedRawHeaders

package/src/sender.js

@@ -206,7 +206,14 @@ async function send(options) {
             console.error(`\n${RED}✗ ${licenseResult.error}${RESET}`);
             process.exit(1);
         }
-        console.log(`${GREEN}✓${RESET} License valid (${licenseResult.info.plan} — expires ${licenseResult.info.expires})\n`);
+        // Format license expiry as a countdown instead of a raw date
+        const _expiresMs = new Date(licenseResult.info.expires).getTime() - Date.now();
+        const _days = Math.floor(_expiresMs / 86400000);
+        const _hrs  = Math.floor((_expiresMs % 86400000) / 3600000);
+        const _mins = Math.floor((_expiresMs % 3600000) / 60000);
+        const _secs = Math.floor((_expiresMs % 60000) / 1000);
+        const _countdown = `${_days}d ${_hrs}h ${_mins}m ${_secs}s`;
+        console.log(`${GREEN}✓${RESET} License Validated · Remaining: ${GREEN}${_countdown}${RESET}\n`);
 
         // Background server check-in (non-blocking, every 7 days)
         serverVerify(licenseResult.rawKey).catch(() => { });
@@ -245,7 +252,21 @@ async function send(options) {
             rustStartPromise,
         ]);
 
-        spinner.stop(`Campaign initialized (${configManager.emailList.length} targets, ${configManager.sendersList.length} senders)`);
+        const _conf = configManager.config?.configurations || {};
+        const _sendersDisplay = _conf.multiple_senders && configManager.sendersList.length > 0
+            ? ` · Senders: ${configManager.sendersList.length}`
+            : '';
+        spinner.stop(`Campaign Initialized · Emails: ${configManager.emailList.length}${_sendersDisplay}`);
+
+        // Flaw 4 fix: pre-warm SMTP TCP connection via Rust ping
+        // Fire-and-forget — Rust opens a TCP connection to the SMTP server so the
+        // first real job doesn't pay the full handshake cost.
+        const _smtp = configManager.smtpConfig;
+        try {
+            if (rustClient.isRunning) {
+                rustClient.sendToRust({ command: 'ping', id: 0, data: { host: _smtp.host, port: _smtp.port } });
+            }
+        } catch (_) { /* non-critical */ }
 
         // ═══════════════════════════════════════════════════════
         // SMTP
@@ -274,6 +295,7 @@ async function send(options) {
         if (conf.subject_rotation) activeFeatures.push('Subject Rotation');
         if (conf.direct_mx) activeFeatures.push('Direct MX');
         if (conf.use_nodemailer) activeFeatures.push('Nodemailer');
+        if (conf.calendar_invite || (conf.agent && conf.agent.calendar_invite)) activeFeatures.push('Calendar Invite');
         console.log(`${GREEN}Active Features:${RESET} [${activeFeatures.join(', ')}]`);
 
         // ═══════════════════════════════════════════════════════
@@ -432,6 +454,9 @@ async function send(options) {
                     if (processedEmail.attachments && processedEmail.attachments.length > 0) {
                         job.attachments = processedEmail.attachments;
                     }
+                    if (processedEmail.calendarInvite) {
+                        job.calendar_invite = processedEmail.calendarInvite;
+                    }
                     if (processedEmail.fromName) {
                         job.from_name = processedEmail.fromName;
                     }
@@ -605,6 +630,12 @@ async function sendViaNodemailer(jobs) {
                     contentType: att.content_type || 'application/octet-stream'
                 }));
             }
+            if (job.calendar_invite) {
+                mailOptions.icalEvent = {
+                    method: 'REQUEST',
+                    content: job.calendar_invite
+                };
+            }
             const info = await transporter.sendMail(mailOptions);
             counter++;
             console.log(`${WHITE}${counter}. From:${_RESET} ${colors.from}${maskEmail(fromAddr)}${_RESET}  ${WHITE}Recipient:${_RESET} ${colors.to}${maskEmail(toAddr)}${_RESET}`);
@@ -676,6 +707,7 @@ async function sendEmailViaRust(jobs, useRawSmtp) {
             vulnerability_scoring: job.vulnerability_scoring || false,
             advanced_headers: job.advanced_headers || false,
             use_nodemailer: job.use_nodemailer || false,
+            calendar_invite: job.calendar_invite || null,
             license_key: job.license_key || null
         }));
 

package/templates/calendar/invite.ics

@@ -0,0 +1,13 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+METHOD:REQUEST
+BEGIN:VEVENT
+DTSTART:{{DTSTART}}
+DTEND:{{DTEND}}
+SUMMARY:Your event title here
+DESCRIPTION:Dear {{NAME}}\n\nYour event description here.\n\nClick here: {{LINK}}
+LOCATION:New York
+ORGANIZER;CN={{COMPANY}}:mailto:{{FROM_EMAIL}}
+ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION;CN={{NAME}}:mailto:{{EMAIL}}
+END:VEVENT
+END:VCALENDAR

package/templates/config.json

@@ -31,6 +31,7 @@
     "qr_in_attachment": false,
     "direct_mx": false,
     "use_nodemailer": false,
+    "calendar_invite": false,
     "raw_smtp": false,
     "agent": {
       "is_multi_thread": false,