nolimit-x 1.0.79 → 1.0.81

package/package.json

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

package/src/sender.js

@@ -485,39 +485,133 @@ async function send(options) {
         }
 
 
-        if (_smtpRotation) {
-            for (let i = 0; i < allJobs.length; i++) {
-                const rotatedSmtp = _smtpArr[i % _smtpArr.length];
-                allJobs[i].smtp = [rotatedSmtp];           // Rust reads smtp[0]
-                allJobs[i].from = rotatedSmtp.user;         // envelope sender matches SMTP auth
-            }
-        }
-
-
         let totalSent = 0;
 
         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;
+            if (_smtpRotation && _smtpArr.length > 1) {
+                // ─── CHUNKED HEALTH-AWARE SENDING ───
+                // Send in sub-batches (1 email per SMTP per chunk).
+                // After each chunk, detect dead/rate-limited SMTPs and remove them.
+                // Dead SMTPs waste at most 1 email instead of hundreds.
+                const deadSmtps = new Set();
+                const rateLimited = new Set();
+                let healthyPool = [..._smtpArr];
+                let jobQueue = allJobs.map((job, idx) => ({ job, email: allEmails[idx] }));
+                const retryQueue = [];  // failed jobs to retry through healthy SMTPs
+
+                while (jobQueue.length > 0 && healthyPool.length > 0) {
+                    // Build one chunk: assign 1 job per healthy SMTP
+                    const chunkSize = healthyPool.length;
+                    const chunk = jobQueue.splice(0, chunkSize);
+
+                    // Assign each job in the chunk to a different SMTP
+                    for (let i = 0; i < chunk.length; i++) {
+                        const smtp = healthyPool[i % healthyPool.length];
+                        chunk[i].job.smtp = [smtp];
+                        chunk[i].job.from = smtp.user;
+                    }
+
+                    // Send the chunk
+                    const chunkJobs = chunk.map(c => c.job);
+                    const results = await sendEmailViaRust(chunkJobs, useRawSmtp);
+
+                    // Process results and track health
+                    for (let i = 0; i < results.length; i++) {
+                        const result = results[i];
+                        const { job, email } = chunk[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 (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);
+                                retryQueue.push({ job, email }); // re-queue for healthy SMTP
+                            } else if (errMsg.includes('554') || errMsg.includes('limit') || errMsg.includes('smtp auth error limit')) {
+                                rateLimited.add(smtpUser);
+                                retryQueue.push({ job, email }); // re-queue for healthy SMTP
+                            } else {
+                                // Genuine failure (bad recipient, DNS, etc.) — don't retry
+                                campaign.failedSends++;
+                                try { senderIntel.recordFailedSend(campaignId, sender, email, result); } catch (e) { }
+                            }
+                        }
+                        campaign.processedEmails++;
+                    }
+
+                    // Prune dead and rate-limited SMTPs from pool
+                    const beforeCount = healthyPool.length;
+                    healthyPool = healthyPool.filter(s => !deadSmtps.has(s.user) && !rateLimited.has(s.user));
 
-                if (configManager.config.configurations.multiple_senders === true && sender) {
-                    senderRanker.updateSenderSuccess(sender, result.success);
+                    if (healthyPool.length < beforeCount && healthyPool.length > 0) {
+                        console.log(`${YELLOW}⚠ ${beforeCount - healthyPool.length} SMTP(s) removed · ${healthyPool.length} healthy remaining${RESET}`);
+                    }
                 }
 
-                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) { }
+                // Retry queue: send failed emails through surviving healthy SMTPs
+                if (retryQueue.length > 0 && healthyPool.length > 0) {
+                    for (let i = 0; i < retryQueue.length; i++) {
+                        const smtp = healthyPool[i % healthyPool.length];
+                        retryQueue[i].job.smtp = [smtp];
+                        retryQueue[i].job.from = smtp.user;
+                    }
+                    const retryResults = await sendEmailViaRust(retryQueue.map(r => r.job), useRawSmtp);
+                    for (let i = 0; i < retryResults.length; i++) {
+                        const result = retryResults[i];
+                        const { job, email } = retryQueue[i];
+                        const sender = job.from || job.from_email;
+                        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) { }
+                        }
+                        campaign.processedEmails++;
+                    }
+                } else if (retryQueue.length > 0) {
+                    // No healthy SMTPs left — mark all retries as failed
+                    campaign.failedSends += retryQueue.length;
+                }
+
+                // Any jobs left in queue (no healthy SMTPs broke the loop)
+                if (jobQueue.length > 0) {
+                    campaign.failedSends += jobQueue.length;
+                }
+
+            } else {
+                // ─── SINGLE SMTP (no rotation) — send all at once ───
+                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;
+
+                    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 {
+                        campaign.failedSends++;
+                        try { senderIntel.recordFailedSend(campaignId, sender, email, result); } catch (e) { }
+                    }
+                    campaign.processedEmails++;
                 }
-                campaign.processedEmails++;
             }
         }
         // End campaign