nolimit-x 1.0.58 → 1.0.61

package/package.json

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

package/src/cli.js

@@ -502,11 +502,21 @@ program
       process.exit(1);
     }
 
-    const emails = fs.readFileSync(inputPath, 'utf8')
+    // Parse lines — support both "email" and "email,Name" formats
+    const rawLines = fs.readFileSync(inputPath, 'utf8')
       .split('\n')
       .map(l => l.trim())
       .filter(l => l && l.includes('@'));
 
+    // Build a map of email → original line (preserving name data)
+    const originalLineMap = new Map();
+    const emails = rawLines.map(line => {
+      const commaIdx = line.indexOf(',');
+      const email = commaIdx !== -1 ? line.substring(0, commaIdx).trim() : line;
+      originalLineMap.set(email, line);
+      return email;
+    });
+
     const threshold = parseInt(options.threshold);
     const concurrency = parseInt(options.concurrency);
 
@@ -550,8 +560,9 @@ program
     const safePath = path.join(validateDir, 'safe.txt');
     const unsafePath = path.join(validateDir, 'unsafe.txt');
 
-    fs.writeFileSync(safePath, results.safe.map(r => r.email).join('\n') + '\n');
-    fs.writeFileSync(unsafePath, results.rejected.map(r => `${r.email} ; ${r.reasons.join(', ')}`).join('\n') + '\n');
+    // Write back original lines (with name if present) to preserve lead data
+    fs.writeFileSync(safePath, results.safe.map(r => originalLineMap.get(r.email) || r.email).join('\n') + '\n');
+    fs.writeFileSync(unsafePath, results.rejected.map(r => `${originalLineMap.get(r.email) || r.email} ; ${r.reasons.join(', ')}`).join('\n') + '\n');
 
     console.log(`\n${WHITE}Total:${RESET}   ${BOLD}${results.stats.total}${RESET}`);
     console.log(`${WHITE}Time:${RESET}    ${BOLD}${elapsed}s${RESET}`);

package/src/email-validator.js

@@ -26,44 +26,58 @@ const {
 // ═══════════════════════════════════════════════════════════
 const domainCache = new Map();
 
+/**
+ * Retry wrapper with exponential backoff for DNS queries.
+ * Retries up to `maxRetries` times on transient failures.
+ */
+async function withRetry(fn, maxRetries = 3, baseDelay = 300) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        } catch (e) {
+            // ENOTFOUND / ENODATA = domain genuinely doesn't exist, no point retrying
+            if (e.code === 'ENOTFOUND' || e.code === 'ENODATA') return null;
+            if (attempt === maxRetries) return null;
+            // Exponential backoff with jitter
+            const delay = baseDelay * Math.pow(2, attempt) + Math.random() * 100;
+            await new Promise(r => setTimeout(r, delay));
+        }
+    }
+    return null;
+}
+
 /**
  * Resolve MX records for a domain.
  * Returns the lowest-priority MX hostname (primary).
  */
 async function getMX(domain) {
-    try {
+    return withRetry(async () => {
         const records = await dns.resolveMx(domain);
         if (!records || records.length === 0) return null;
         // Sort by priority (lowest = primary)
         records.sort((a, b) => a.priority - b.priority);
         return records[0].exchange.toLowerCase().replace(/\.$/, '');
-    } catch (e) {
-        return null;
-    }
+    });
 }
 
 /**
  * Resolve A record (hostname → IP).
  */
 async function getA(hostname) {
-    try {
+    return withRetry(async () => {
         const addrs = await dns.resolve4(hostname);
         return addrs && addrs.length > 0 ? addrs[0] : null;
-    } catch (e) {
-        return null;
-    }
+    });
 }
 
 /**
  * Reverse PTR lookup (IP → hostname).
  */
 async function getPTR(ip) {
-    try {
+    return withRetry(async () => {
         const names = await dns.reverse(ip);
         return names && names.length > 0 ? names[0].toLowerCase() : null;
-    } catch (e) {
-        return null;
-    }
+    });
 }
 
 /**

package/src/sender.js

@@ -492,6 +492,8 @@ async function send(options) {
                     try { senderIntel.recordSuccessfulSend(campaignId, sender, email, result); } catch (e) { }
                 } else {
                     campaign.failedSends++;
+                    const errMsg = result.error || result.message || 'unknown error';
+                    console.log(`${RED}✗${RESET} ${WHITE}${email}${RESET} — ${RED}${errMsg}${RESET}`);
                     try { senderIntel.recordFailedSend(campaignId, sender, email, result); } catch (e) { }
                 }
                 campaign.processedEmails++;
@@ -1152,13 +1154,11 @@ function buildBasicRustJob(config, recipient, messageHtml, configManager) {
             // Scenario 2: Use config from_email
             fromEmail = conf.from_email;
             envelopeSender = conf.from_email;
-            console.log(`[SENDER] Using config from_email: ${fromEmail}`);
         } else {
             // Scenario 3: Use SMTP user email
             const smtpConfig = Array.isArray(config.smtp) ? config.smtp[0] : config.smtp;
             fromEmail = smtpConfig.user;
             envelopeSender = smtpConfig.user;
-            console.log(`[SENDER] Using SMTP user email: ${fromEmail}`);
         }
     }