@raevon/n8n-nodes-whatsapp 1.0.13 → 2.0.0

package/dist/nodes/WhatsApp/WhatsAppServer.js

@@ -0,0 +1,390 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const baileys_1 = __importStar(require("@whiskeysockets/baileys"));
+const p_queue_1 = __importDefault(require("p-queue"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_url_1 = require("node:url");
+const qrcode_1 = __importDefault(require("qrcode"));
+// --- Configuration ---
+const SESSION_PATH = process.env.WHATSAPP_SESSION_PATH || '~/.n8n/whatsapp-auth';
+const PORT = parseInt(process.env.WHATSAPP_PORT || '3456');
+const MESSAGE_DELAY_MIN = parseInt(process.env.MESSAGE_DELAY_MIN || '5000');
+const MESSAGE_DELAY_MAX = parseInt(process.env.MESSAGE_DELAY_MAX || '9000');
+const BURST_SIZE = parseInt(process.env.BURST_SIZE || '20');
+const BURST_PAUSE_MIN = parseInt(process.env.BURST_PAUSE_MIN || '30000');
+const BURST_PAUSE_MAX = parseInt(process.env.BURST_PAUSE_MAX || '60000');
+const TYPING_SIMULATION = process.env.TYPING_SIMULATION !== 'false';
+const DAILY_SEND_LIMIT = parseInt(process.env.DAILY_SEND_LIMIT || '500');
+const CHECK_RECIPIENT = process.env.CHECK_RECIPIENT !== 'false';
+// --- State ---
+let socket = null;
+let status = 'stopped';
+let qr = null;
+let queue = null;
+let nextSendAt = 0;
+let sentInBurst = 0;
+let sentTodayCount = 0;
+let sentTodayDate = '';
+let lastError = null;
+const messageBuffer = [];
+// --- Helpers ---
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const randBetween = (min, max) => max > min ? min + Math.floor(Math.random() * (max - min + 1)) : min;
+function expandHome(p) {
+    if (!p.startsWith('~'))
+        return p;
+    return node_path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', p.slice(1));
+}
+function todayStartIso() {
+    return new Date().toISOString().slice(0, 10) + 'T00:00:00.000Z';
+}
+function sendGapMs() {
+    return randBetween(MESSAGE_DELAY_MIN, MESSAGE_DELAY_MAX);
+}
+function burstPauseMs() {
+    if (!BURST_SIZE || ++sentInBurst < BURST_SIZE)
+        return 0;
+    sentInBurst = 0;
+    return randBetween(BURST_PAUSE_MIN, BURST_PAUSE_MAX);
+}
+function normalizeRecipient(to) {
+    if (to.endsWith('@s.whatsapp.net') || to.endsWith('@g.us'))
+        return to;
+    const digits = to.replace(/\D/g, '');
+    if (!/^[1-9][0-9]{7,14}$/.test(digits)) {
+        throw new Error(`Invalid phone number: ${to}`);
+    }
+    return `${digits}@s.whatsapp.net`;
+}
+// --- Silent Logger ---
+const noop = () => { };
+const silentLogger = {
+    level: 'silent',
+    info: noop, warn: noop, error: noop, debug: noop, fatal: noop, trace: noop,
+    child: () => silentLogger,
+};
+// --- Socket Management ---
+async function connect() {
+    if (socket && status === 'connected')
+        return;
+    const resolvedPath = expandHome(SESSION_PATH);
+    if (!node_fs_1.default.existsSync(resolvedPath)) {
+        node_fs_1.default.mkdirSync(resolvedPath, { recursive: true });
+    }
+    const { state, saveCreds } = await (0, baileys_1.useMultiFileAuthState)(resolvedPath);
+    const { version } = await (0, baileys_1.fetchLatestBaileysVersion)();
+    status = 'connecting';
+    qr = null;
+    socket = (0, baileys_1.default)({
+        version,
+        browser: baileys_1.Browsers.ubuntu('n8n WhatsApp Node'),
+        auth: {
+            creds: state.creds,
+            keys: (0, baileys_1.makeCacheableSignalKeyStore)(state.keys, silentLogger),
+        },
+        markOnlineOnConnect: false,
+        syncFullHistory: false,
+        shouldSyncHistoryMessage: () => false,
+        generateHighQualityLinkPreview: false,
+        logger: silentLogger,
+    });
+    socket.ev.on('creds.update', () => {
+        saveCreds().catch(() => { });
+    });
+    socket.ev.on('connection.update', async (update) => {
+        var _a, _b;
+        const { connection, lastDisconnect, qr: newQr } = update;
+        if (newQr) {
+            qr = newQr;
+            status = 'connecting';
+        }
+        if (connection === 'open') {
+            status = 'connected';
+            qr = null;
+            lastError = null;
+            console.log('[WhatsApp Server] Connected');
+            return;
+        }
+        if (connection === 'close') {
+            const code = (_b = (_a = lastDisconnect === null || lastDisconnect === void 0 ? void 0 : lastDisconnect.error) === null || _a === void 0 ? void 0 : _a.output) === null || _b === void 0 ? void 0 : _b.statusCode;
+            const reason = baileys_1.DisconnectReason[code] || 'Unknown';
+            lastError = `Code: ${code} (${reason})`;
+            console.log(`[WhatsApp Server] Disconnected: ${reason}`);
+            if (code === baileys_1.DisconnectReason.loggedOut) {
+                status = 'logged_out';
+                socket = null;
+            }
+            else {
+                status = 'error';
+                socket = null;
+                // Auto-reconnect after delay
+                setTimeout(() => connect().catch(() => { }), 5000);
+            }
+        }
+    });
+    // Listen for incoming messages
+    socket.ev.on('messages.upsert', (upsert) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        const { messages, type } = upsert;
+        if (type !== 'notify')
+            return;
+        for (const msg of messages) {
+            if (msg.key.fromMe)
+                continue;
+            let content = null;
+            const msgType = Object.keys(msg.message || {})[0] || 'unknown';
+            if ((_a = msg.message) === null || _a === void 0 ? void 0 : _a.conversation)
+                content = msg.message.conversation;
+            else if ((_c = (_b = msg.message) === null || _b === void 0 ? void 0 : _b.extendedTextMessage) === null || _c === void 0 ? void 0 : _c.text)
+                content = msg.message.extendedTextMessage.text;
+            else if ((_e = (_d = msg.message) === null || _d === void 0 ? void 0 : _d.imageMessage) === null || _e === void 0 ? void 0 : _e.caption)
+                content = msg.message.imageMessage.caption;
+            else if ((_g = (_f = msg.message) === null || _f === void 0 ? void 0 : _f.videoMessage) === null || _g === void 0 ? void 0 : _g.caption)
+                content = msg.message.videoMessage.caption;
+            else if ((_j = (_h = msg.message) === null || _h === void 0 ? void 0 : _h.documentMessage) === null || _j === void 0 ? void 0 : _j.fileName)
+                content = msg.message.documentMessage.fileName;
+            else if ((_k = msg.message) === null || _k === void 0 ? void 0 : _k.audioMessage)
+                content = '[Audio]';
+            else if ((_l = msg.message) === null || _l === void 0 ? void 0 : _l.stickerMessage)
+                content = '[Sticker]';
+            else if ((_m = msg.message) === null || _m === void 0 ? void 0 : _m.locationMessage)
+                content = `[Location] ${msg.message.locationMessage.address || ''}`;
+            else if ((_p = (_o = msg.message) === null || _o === void 0 ? void 0 : _o.contactMessage) === null || _p === void 0 ? void 0 : _p.displayName)
+                content = `[Contact] ${msg.message.contactMessage.displayName}`;
+            else
+                content = `[${msgType}]`;
+            const timestampSeconds = msg.messageTimestamp != null ? Number(msg.messageTimestamp) : Date.now() / 1000;
+            messageBuffer.push({
+                messageId: msg.key.id,
+                chatJid: msg.key.remoteJid,
+                sender: (_q = msg.key.participant) !== null && _q !== void 0 ? _q : msg.key.remoteJid,
+                content,
+                timestamp: new Date(timestampSeconds * 1000).toISOString(),
+                isFromMe: false,
+                messageType: msgType,
+            });
+        }
+    });
+    if (!queue) {
+        queue = new p_queue_1.default({ concurrency: 1 });
+    }
+}
+async function sendMessage(to, content) {
+    if (!socket || status !== 'connected') {
+        throw new Error('WhatsApp not connected');
+    }
+    // Daily limit
+    if (DAILY_SEND_LIMIT > 0) {
+        const today = todayStartIso();
+        if (sentTodayDate !== today) {
+            sentTodayDate = today;
+            sentTodayCount = 0;
+        }
+        if (sentTodayCount >= DAILY_SEND_LIMIT) {
+            throw new Error(`Daily limit (${DAILY_SEND_LIMIT}) reached`);
+        }
+    }
+    const jid = normalizeRecipient(to);
+    // Recipient check
+    if (CHECK_RECIPIENT && !jid.endsWith('@g.us')) {
+        const results = await socket.onWhatsApp(jid);
+        const result = results === null || results === void 0 ? void 0 : results[0];
+        if (!(result === null || result === void 0 ? void 0 : result.exists)) {
+            throw new Error(`Recipient ${to} not on WhatsApp`);
+        }
+    }
+    // Queue with anti-ban
+    const task = queue.add(async () => {
+        var _a;
+        const wait = nextSendAt - Date.now();
+        if (wait > 0)
+            await sleep(wait);
+        // Typing simulation
+        if (TYPING_SIMULATION) {
+            try {
+                await socket.sendPresenceUpdate('composing', jid);
+                const len = (content.text || content.caption || '').length;
+                await sleep(Math.min(randBetween(900, 1800) + len * 25, 4000));
+                await socket.sendPresenceUpdate('paused', jid);
+            }
+            catch { }
+        }
+        const response = await socket.sendMessage(jid, content);
+        nextSendAt = Date.now() + sendGapMs() + burstPauseMs();
+        if (DAILY_SEND_LIMIT > 0)
+            sentTodayCount++;
+        if (!((_a = response === null || response === void 0 ? void 0 : response.key) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('No message ID returned');
+        return { messageId: response.key.id, status: 'sent', recipient: jid };
+    });
+    // 15s timeout race
+    let timer;
+    const winner = await Promise.race([
+        task.then(result => ({ result }), error => ({ error })),
+        new Promise(resolve => { timer = setTimeout(() => resolve(null), 15000); }),
+    ]);
+    clearTimeout(timer);
+    if (!winner) {
+        task.then(() => { }, () => { });
+        return { messageId: 'queued', status: 'queued', recipient: jid };
+    }
+    const w = winner;
+    if (w.error)
+        throw w.error;
+    return w.result;
+}
+function getStatus() {
+    return {
+        status,
+        connected: status === 'connected',
+        qrAvailable: status === 'connecting' && qr !== null,
+        sentToday: sentTodayCount,
+        dailyLimit: DAILY_SEND_LIMIT,
+        lastError,
+    };
+}
+// --- HTTP Server ---
+const server = node_http_1.default.createServer(async (req, res) => {
+    const url = new node_url_1.URL(req.url || '/', `http://localhost:${PORT}`);
+    // CORS headers
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    try {
+        if (url.pathname === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, ...getStatus() }));
+        }
+        else if (url.pathname === '/status') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(getStatus()));
+        }
+        else if (url.pathname === '/connect') {
+            await connect();
+            // Wait for connection or QR (up to 30s)
+            const result = await new Promise((resolve) => {
+                const check = setInterval(() => {
+                    if (status === 'connected') {
+                        clearInterval(check);
+                        resolve({ connected: true, message: 'Connected' });
+                    }
+                    if (qr) {
+                        clearInterval(check);
+                        qrcode_1.default.toDataURL(qr, { width: 300, margin: 2 }).then(qrUrl => {
+                            resolve({ connected: false, qrUrl, message: 'Scan QR in browser' });
+                        });
+                    }
+                }, 500);
+                setTimeout(() => { clearInterval(check); resolve({ connected: false, status, message: 'Timeout' }); }, 30000);
+            });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(result));
+        }
+        else if (url.pathname === '/qr' && qr) {
+            const qrUrl = await qrcode_1.default.toDataURL(qr, { width: 400, margin: 2 });
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(`<!DOCTYPE html><html><head><title>WhatsApp QR</title><style>body{display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#111}img{border-radius:12px}</style></head><body><img src="${qrUrl}"/></body></html>`);
+        }
+        else if (url.pathname === '/send' && req.method === 'POST') {
+            let body = '';
+            req.on('data', chunk => body += chunk);
+            req.on('end', async () => {
+                try {
+                    const { to, ...content } = JSON.parse(body);
+                    if (!to)
+                        throw new Error('Missing "to" field');
+                    const result = await sendMessage(to, content);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(result));
+                }
+                catch (err) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+        }
+        else if (url.pathname === '/messages') {
+            // Return buffered messages and clear buffer
+            const messages = messageBuffer.splice(0, messageBuffer.length);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ messages, count: messages.length }));
+        }
+        else if (url.pathname === '/signout') {
+            if (socket) {
+                try {
+                    socket.end(new Error('Sign out'));
+                }
+                catch { }
+                socket = null;
+            }
+            status = 'stopped';
+            const resolvedPath = expandHome(SESSION_PATH);
+            if (node_fs_1.default.existsSync(resolvedPath)) {
+                const files = node_fs_1.default.readdirSync(resolvedPath);
+                for (const f of files)
+                    node_fs_1.default.unlinkSync(node_path_1.default.join(resolvedPath, f));
+                node_fs_1.default.rmdirSync(resolvedPath);
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, message: 'Signed out' }));
+        }
+        else {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Not found' }));
+        }
+    }
+    catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+    }
+});
+// --- Start ---
+server.listen(PORT, () => {
+    console.log(`[WhatsApp Server] Listening on port ${PORT}`);
+    console.log(`[WhatsApp Server] Session: ${SESSION_PATH}`);
+    // Auto-connect on startup
+    connect().catch(() => { });
+});

package/dist/nodes/WhatsApp/WhatsAppTrigger.node.js

@@ -2,10 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WhatsAppTrigger = void 0;
 const WhatsAppApiHelper_1 = require("./WhatsAppApiHelper");
-// Per-credential buffers — one buffer per session path
-// This ensures multiple trigger nodes with different credentials don't share messages
-const buffersBySession = new Map();
-const initializedBySession = new Set();
 class WhatsAppTrigger {
     constructor() {
         this.description = {
@@ -15,7 +11,7 @@ class WhatsAppTrigger {
             group: ['trigger'],
             version: 1,
             subtitle: '={{$parameter["event"]}}',
-            description: 'Triggers on incoming WhatsApp messages',
+            description: 'Triggers on incoming WhatsApp messages via background server',
             defaults: { name: 'WhatsApp Trigger' },
             inputs: [],
             outputs: ['main'],
@@ -36,14 +32,14 @@ class WhatsAppTrigger {
                     name: 'chatJidFilter',
                     type: 'string',
                     default: '',
-                    description: 'Optional: only trigger for messages from this chat JID (e.g., 1234567890@s.whatsapp.net). Leave empty for all chats.',
+                    description: 'Optional: only trigger for messages from this chat JID',
                 },
                 {
                     displayName: 'Only Text Messages',
                     name: 'onlyText',
                     type: 'boolean',
                     default: false,
-                    description: 'If true, only trigger for text messages (ignores images, documents, etc.)',
+                    description: 'If true, only trigger for text messages',
                 },
             ],
         };
@@ -53,42 +49,32 @@ class WhatsAppTrigger {
         const cfg = await (0, WhatsAppApiHelper_1.getWhatsAppCredentials)(credentials);
         const chatFilter = this.getNodeParameter('chatJidFilter', '');
         const onlyText = this.getNodeParameter('onlyText', false);
-        const sessionKey = cfg.sessionPath;
-        // Get or create buffer for this credential
-        if (!buffersBySession.has(sessionKey)) {
-            buffersBySession.set(sessionKey, []);
+        // Ensure server is running
+        await (0, WhatsAppApiHelper_1.ensureServerRunning)(cfg);
+        // Poll for messages
+        try {
+            const response = await fetch(`${(0, WhatsAppApiHelper_1.getServerUrl)(cfg)}/messages`);
+            const data = await response.json();
+            if (!data.messages || data.messages.length === 0)
+                return null;
+            // Apply filters
+            let messages = data.messages;
+            if (chatFilter) {
+                messages = messages.filter((msg) => msg.chatJid === chatFilter);
+            }
+            if (onlyText) {
+                messages = messages.filter((msg) => msg.messageType === 'conversation' || msg.messageType === 'extendedTextMessage');
+            }
+            if (messages.length === 0)
+                return null;
+            return [messages.map((msg) => ({
+                    json: msg,
+                    pairedItem: { item: 0 },
+                }))];
         }
-        const buffer = buffersBySession.get(sessionKey);
-        // Initialize socket listener once per credential
-        if (!initializedBySession.has(sessionKey)) {
-            const sock = await (0, WhatsAppApiHelper_1.ensureConnected)(cfg);
-            sock.ev.on('messages.upsert', (upsert) => {
-                const { messages, type } = upsert;
-                if (type !== 'notify')
-                    return;
-                for (const msg of messages) {
-                    if (msg.key.fromMe)
-                        continue;
-                    if (chatFilter && msg.key.remoteJid !== chatFilter)
-                        continue;
-                    const parsed = (0, WhatsAppApiHelper_1.parseIncomingMessage)(msg);
-                    if (!parsed)
-                        continue;
-                    if (onlyText && parsed.messageType !== 'conversation' && parsed.messageType !== 'extendedTextMessage')
-                        continue;
-                    buffer.push(parsed);
-                }
-            });
-            initializedBySession.add(sessionKey);
-        }
-        // Return buffered messages
-        if (buffer.length === 0)
+        catch {
             return null;
-        const messages = buffer.splice(0, buffer.length);
-        return [messages.map((msg) => ({
-                json: msg,
-                pairedItem: { item: 0 },
-            }))];
+        }
     }
 }
 exports.WhatsAppTrigger = WhatsAppTrigger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raevon/n8n-nodes-whatsapp",
-  "version": "1.0.13",
+  "version": "2.0.0",
   "description": "n8n community node for WhatsApp — send and receive messages with anti-ban protection via the Baileys library",
   "keywords": [
     "n8n-community-node-package",