nolimit-x 1.0.80 → 1.0.82

package/package.json

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

package/src/sender.js

@@ -485,96 +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('');
 
-            // 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;
+            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;
+                    }
 
-            while (pendingJobs.length > 0) {
-                const results = await sendEmailViaRust(pendingJobs, useRawSmtp);
-                const retryJobs = [];
-                const retryEmails = [];
+                    // Send the chunk
+                    const chunkJobs = chunk.map(c => c.job);
+                    const results = await sendEmailViaRust(chunkJobs, useRawSmtp);
 
-                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 || '';
+                    // 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 (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++;
                     }
 
-                    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);
+                    // 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 (healthyPool.length < beforeCount && healthyPool.length > 0) {
+                        console.log(`${YELLOW}⚠ ${beforeCount - healthyPool.length} SMTP(s) removed · ${healthyPool.length} healthy remaining${RESET}`);
+                    }
+                }
+
+                // 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 {
-                            // Genuine send failure — don't retry
                             campaign.failedSends++;
                             try { senderIntel.recordFailedSend(campaignId, sender, email, result); } catch (e) { }
                         }
+                        campaign.processedEmails++;
                     }
-                    campaign.processedEmails++;
+                } else if (retryQueue.length > 0) {
+                    // No healthy SMTPs left — mark all retries as failed
+                    campaign.failedSends += retryQueue.length;
                 }
 
-                retryRound++;
-                if (retryRound > MAX_RETRIES || retryJobs.length === 0) {
-                    // Mark remaining retries as failed
-                    if (retryJobs.length > 0) {
-                        campaign.failedSends += retryJobs.length;
-                    }
-                    break;
+                // Any jobs left in queue (no healthy SMTPs broke the loop)
+                if (jobQueue.length > 0) {
+                    campaign.failedSends += jobQueue.length;
                 }
 
-                // Healthy SMTPs = pool minus dead and ratelimited
-                const healthySmtps = _smtpRotation
-                    ? _smtpArr.filter(s => !deadSmtps.has(s.user) && !ratelimited.has(s.user))
-                    : [];
+            } 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 (healthySmtps.length === 0) {
-                    // No healthy SMTPs left — mark all as failed
-                    campaign.failedSends += retryJobs.length;
-                    break;
-                }
+                    if (configManager.config.configurations.multiple_senders === true && sender) {
+                        senderRanker.updateSenderSuccess(sender, result.success);
+                    }
 
-                // 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;
+                    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++;
                 }
-
-                pendingJobs = retryJobs;
-                pendingEmails = retryEmails;
             }
         }
         // End campaign