nolimit-x 1.0.78 → 1.0.80

package/package.json

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

package/src/processor.js

@@ -43,13 +43,22 @@ class ConfigManager {
             const smtpRotation = this.config.configurations?.system?.smtp_rotation || false;
 
             if (smtpRotation) {
-                // Load multiple SMTP providers from smtp.txt
-                this.smtpConfigs = this.loadSmtpProviders();
+                // Load multiple SMTP providers from smtps.txt
+                const externalProviders = this.loadSmtpProviders();
+                // Merge config.json SMTP(s) + smtps.txt into one pool, deduplicated by host+user
+                const configSmtps = Array.isArray(this.config.smtp) ? this.config.smtp : [this.config.smtp];
+                const combined = [...configSmtps, ...externalProviders];
+                const seen = new Set();
+                this.smtpConfigs = combined.filter(s => {
+                    const key = `${s.host}:${s.port}:${s.user}`;
+                    if (seen.has(key)) return false;
+                    seen.add(key);
+                    return true;
+                });
                 if (this.smtpConfigs.length === 0) {
-                    console.warn('SMTP rotation enabled but no providers found in smtps.txt, falling back to config.json');
                     this.smtpConfig = this.config.smtp[0];
                 } else {
-                    this.smtpConfig = this.smtpConfigs[0]; // Default to first provider
+                    this.smtpConfig = this.smtpConfigs[0];
                 }
             } else {
                 // Use single SMTP from config.json

package/src/sender.js

@@ -498,26 +498,83 @@ async function send(options) {
 
         if (allJobs.length > 0) {
             console.log('');
-            const results = await sendEmailViaRust(allJobs, useRawSmtp);
 
-            for (let i = 0; i < results.length; i++) {
-                const result = results[i];
-                const email = allEmails[i];
-                const sender = allJobs[i].from || allJobs[i].from_email;
+            // Health-aware SMTP rotation: send → detect dead SMTPs → retry failed through healthy ones
+            const deadSmtps = new Set();     // permanently failed (535 auth)
+            const ratelimited = new Set();   // temporarily exhausted (554 rate limit)
+            let pendingJobs = allJobs;
+            let pendingEmails = allEmails;
+            let retryRound = 0;
+            const MAX_RETRIES = 2;
+
+            while (pendingJobs.length > 0) {
+                const results = await sendEmailViaRust(pendingJobs, useRawSmtp);
+                const retryJobs = [];
+                const retryEmails = [];
+
+                for (let i = 0; i < results.length; i++) {
+                    const result = results[i];
+                    const email = pendingEmails[i];
+                    const job = pendingJobs[i];
+                    const sender = job.from || job.from_email;
+                    const smtpUser = job.smtp?.[0]?.user || '';
+
+                    if (configManager.config.configurations.multiple_senders === true && sender) {
+                        senderRanker.updateSenderSuccess(sender, result.success);
+                    }
 
-                if (configManager.config.configurations.multiple_senders === true && sender) {
-                    senderRanker.updateSenderSuccess(sender, result.success);
+                    if (result.success) {
+                        campaign.successfulSends++;
+                        totalSent++;
+                        try { senderIntel.recordSuccessfulSend(campaignId, sender, email, result); } catch (e) { }
+                    } else {
+                        const errMsg = (result.error || result.message || '').toLowerCase();
+                        if (errMsg.includes('535') || errMsg.includes('authentication failed')) {
+                            deadSmtps.add(smtpUser);
+                            retryJobs.push(job);
+                            retryEmails.push(email);
+                        } else if (errMsg.includes('554') || errMsg.includes('limit')) {
+                            ratelimited.add(smtpUser);
+                            retryJobs.push(job);
+                            retryEmails.push(email);
+                        } else {
+                            // Genuine send failure — don't retry
+                            campaign.failedSends++;
+                            try { senderIntel.recordFailedSend(campaignId, sender, email, result); } catch (e) { }
+                        }
+                    }
+                    campaign.processedEmails++;
                 }
 
-                if (result.success) {
-                    campaign.successfulSends++;
-                    totalSent++;
-                    try { senderIntel.recordSuccessfulSend(campaignId, sender, email, result); } catch (e) { }
-                } else {
-                    campaign.failedSends++;
-                    try { senderIntel.recordFailedSend(campaignId, sender, email, result); } catch (e) { }
+                retryRound++;
+                if (retryRound > MAX_RETRIES || retryJobs.length === 0) {
+                    // Mark remaining retries as failed
+                    if (retryJobs.length > 0) {
+                        campaign.failedSends += retryJobs.length;
+                    }
+                    break;
+                }
+
+                // Healthy SMTPs = pool minus dead and ratelimited
+                const healthySmtps = _smtpRotation
+                    ? _smtpArr.filter(s => !deadSmtps.has(s.user) && !ratelimited.has(s.user))
+                    : [];
+
+                if (healthySmtps.length === 0) {
+                    // No healthy SMTPs left — mark all as failed
+                    campaign.failedSends += retryJobs.length;
+                    break;
                 }
-                campaign.processedEmails++;
+
+                // Reassign failed jobs to healthy SMTPs
+                for (let i = 0; i < retryJobs.length; i++) {
+                    const smtp = healthySmtps[i % healthySmtps.length];
+                    retryJobs[i].smtp = [smtp];
+                    retryJobs[i].from = smtp.user;
+                }
+
+                pendingJobs = retryJobs;
+                pendingEmails = retryEmails;
             }
         }
         // End campaign