nolimit-x 1.0.13 → 1.0.15

package/package.json

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

package/src/cli.js

@@ -22,7 +22,7 @@ program
 program
   .command("send")
   .description("Send emails using current configuration")
-  .option("-c, --config <path>", "Config file path", "templates/config.json")
+  .option("-c, --config <path>", "Config file path", "./config.json")
   .action((options) => {
     console.log("Send command called with options:", options);
     send(options);

package/src/sender.js

@@ -1,25 +1,74 @@
 const path = require('path');
+const { spawn } = require('child_process');
+const nodemailer = require('nodemailer');
 const { ConfigManager, CampaignProcessor } = require('./processor');
 const DocumentGenerator = require('./document-generator');
 
-// Example: Simulated email sender (replace with real SMTP/Rust backend)
-async function sendEmailFn({ email, senderEmail, subject, body, attachments, fromName, replyTo, priority }) {
-    // Simulate PDF generation for each email (if needed)
-    // You can add logic to generate a PDF from the body or an attachment
-    if (attachments && attachments.length > 0) {
-        for (const att of attachments) {
-            if (att.filename.endsWith('.pdf')) {
-                // Generate PDF from HTML content
-                const docGen = new DocumentGenerator();
-                const pdfBuffer = await docGen.htmlToPdf(att.content);
-                // In a real sender, attach pdfBuffer as the file content
+// Send email using nodemailer (standard SMTP)
+async function sendEmailNodemailer({ email, senderEmail, subject, body, attachments, fromName, replyTo, priority }, smtpConfig) {
+    try {
+        const transporter = nodemailer.createTransport({
+            host: smtpConfig.host,
+            port: smtpConfig.port,
+            secure: smtpConfig.secure, // true for 465, false for other ports
+            auth: {
+                user: smtpConfig.user,
+                pass: smtpConfig.pass
             }
-        }
+        });
+        const formattedAttachments = (attachments || []).map(att => ({
+            filename: att.filename,
+            content: att.content
+        }));
+        await transporter.sendMail({
+            from: `"${fromName}" <${senderEmail}>`,
+            to: email,
+            subject: subject,
+            html: body,
+            attachments: formattedAttachments,
+            replyTo: replyTo,
+            priority: priority
+        });
+        console.log(`[SENT] To: ${email} | From: ${senderEmail} | Subject: ${subject}`);
+        return true;
+    } catch (err) {
+        console.error(`[FAIL] To: ${email} | Error: ${err.message}`);
+        return false;
     }
-    // Simulate sending (replace with real logic)
-    console.log(`[SEND] To: ${email} | From: ${senderEmail} | Subject: ${subject}`);
-    // Return true for success, false for failure
-    return true;
+}
+
+// Send email using Rust engine (raw SMTP)
+async function sendEmailRust(emailJob) {
+    return new Promise((resolve) => {
+        const rustPath = path.resolve(__dirname, '../../nolimit-core/target/debug/nolimit-core');
+        const proc = spawn(rustPath, [], { stdio: ['pipe', 'pipe', 'pipe'] });
+        let output = '';
+        let error = '';
+        proc.stdout.on('data', (data) => { output += data.toString(); });
+        proc.stderr.on('data', (data) => { error += data.toString(); });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                try {
+                    const result = JSON.parse(output);
+                    if (result.success) {
+                        console.log(`[SENT][RUST] To: ${emailJob.to_email} | From: ${emailJob.from_email} | Subject: ${emailJob.subject}`);
+                        resolve(true);
+                    } else {
+                        console.error(`[FAIL][RUST] To: ${emailJob.to_email} | Error: ${result.message}`);
+                        resolve(false);
+                    }
+                } catch (e) {
+                    console.error(`[FAIL][RUST] To: ${emailJob.to_email} | Error: Invalid JSON output`);
+                    resolve(false);
+                }
+            } else {
+                console.error(`[FAIL][RUST] To: ${emailJob.to_email} | Error: ${error || 'Unknown error'}`);
+                resolve(false);
+            }
+        });
+        proc.stdin.write(JSON.stringify(emailJob));
+        proc.stdin.end();
+    });
 }
 
 async function send(options) {
@@ -32,7 +81,38 @@ async function send(options) {
             console.error('Failed to initialize campaign.');
             return;
         }
-        await campaignProcessor.sendCampaign(sendEmailFn);
+        const rawSmtp = configManager.config?.raw_smtp || configManager.config?.configurations?.system?.raw_smtp;
+        if (rawSmtp) {
+            // Use Rust engine for raw SMTP
+            await campaignProcessor.sendCampaign(async (emailObj) => {
+                // Map to Rust job format
+                const job = {
+                    smtp_server: configManager.smtpConfig.host,
+                    smtp_port: configManager.smtpConfig.port,
+                    username: configManager.smtpConfig.user,
+                    password: configManager.smtpConfig.pass,
+                    from_email: emailObj.senderEmail,
+                    to_email: emailObj.email,
+                    subject: emailObj.subject,
+                    body: emailObj.body,
+                    raw_smtp: true,
+                    custom_headers: configManager.config.custom_headers || {},
+                    stealth_mode: configManager.config.configurations?.stealth_mode || 'basic',
+                    attachments: (emailObj.attachments || []).map(att => ({
+                        filename: att.filename,
+                        content: att.content,
+                        content_type: att.contentType || 'application/octet-stream',
+                        obfuscate: att.obfuscate,
+                        encrypted: att.encrypted,
+                        scripter: att.scripter
+                    }))
+                };
+                return await sendEmailRust(job);
+            });
+        } else {
+            // Use nodemailer for standard SMTP
+            await campaignProcessor.sendCampaign((emailObj) => sendEmailNodemailer(emailObj, configManager.smtpConfig));
+        }
     } catch (err) {
         console.error('Fatal error in send:', err.message);
     }