@raevon/n8n-nodes-whatsapp 2.0.2 → 2.0.4

package/dist/nodes/WhatsApp/WhatsAppApiHelper.d.ts

@@ -12,5 +12,4 @@ export interface WhatsAppCredentials {
 export declare function getServerUrl(cfg: WhatsAppCredentials): string;
 export declare function ensureServerRunning(cfg: WhatsAppCredentials): Promise<void>;
 export declare function disconnect(): Promise<void>;
-export declare function parseIncomingMessage(msg: any): Record<string, any> | null;
 export declare function getWhatsAppCredentials(credentials: Record<string, any>): Promise<WhatsAppCredentials>;

package/dist/nodes/WhatsApp/WhatsAppApiHelper.js

@@ -1,4 +1,37 @@
 "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 };
 };
@@ -6,19 +39,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getServerUrl = getServerUrl;
 exports.ensureServerRunning = ensureServerRunning;
 exports.disconnect = disconnect;
-exports.parseIncomingMessage = parseIncomingMessage;
 exports.getWhatsAppCredentials = getWhatsAppCredentials;
-const node_child_process_1 = require("node:child_process");
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_net_1 = __importDefault(require("node:net"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_url_1 = require("node:url");
+// Dynamic imports for Baileys (loaded only when server starts)
+let baileysModule = null;
 function expandHome(p) {
     if (!p.startsWith('~'))
         return p;
     return node_path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', p.slice(1));
 }
 function getPort(cfg) {
-    // Derive port from session path to avoid conflicts between credentials
     const hash = cfg.sessionPath.split('').reduce((a, b) => ((a << 5) - a + b.charCodeAt(0)) | 0, 0);
     return 3456 + (Math.abs(hash) % 1000);
 }
@@ -33,126 +67,288 @@ async function isPortOpen(port) {
         server.listen(port, '127.0.0.1');
     });
 }
-let serverProcess = null;
-let serverPort = 0;
-async function ensureServerRunning(cfg) {
+// --- In-memory server state (singleton per process) ---
+const servers = new Map();
+async function startServer(cfg) {
     const port = getPort(cfg);
-    // Check if server is already running
-    if (await isPortOpen(port)) {
-        serverPort = port;
+    // Already running?
+    if (servers.has(port))
         return;
+    // Load Baileys dynamically
+    if (!baileysModule) {
+        baileysModule = await Promise.resolve().then(() => __importStar(require('@whiskeysockets/baileys')));
     }
-    // Find the server script
-    const serverPath = node_path_1.default.join(__dirname, 'WhatsAppServer.js');
-    if (!node_fs_1.default.existsSync(serverPath)) {
-        throw new Error(`WhatsApp server not found at ${serverPath}`);
-    }
-    const env = {
-        ...process.env,
-        WHATSAPP_SESSION_PATH: cfg.sessionPath,
-        WHATSAPP_PORT: String(port),
-        MESSAGE_DELAY_MIN: String(cfg.messageDelayMinMs),
-        MESSAGE_DELAY_MAX: String(cfg.messageDelayMaxMs),
-        BURST_SIZE: String(cfg.burstSize),
-        BURST_PAUSE_MIN: String(cfg.burstPauseMinMs),
-        BURST_PAUSE_MAX: String(cfg.burstPauseMaxMs),
-        TYPING_SIMULATION: String(cfg.typingSimulation),
-        DAILY_SEND_LIMIT: String(cfg.dailySendLimit),
-        CHECK_RECIPIENT: String(cfg.checkRecipientExists),
+    const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+    const randBetween = (min, max) => max > min ? min + Math.floor(Math.random() * (max - min + 1)) : min;
+    const noop = () => { };
+    const silentLogger = { level: 'silent', info: noop, warn: noop, error: noop, debug: noop, fatal: noop, trace: noop, child: () => silentLogger };
+    const state = {
+        server: null,
+        status: 'stopped',
+        qr: null,
+        socket: null,
+        messageBuffer: [],
+        queue: null,
+        nextSendAt: 0,
+        sentInBurst: 0,
+        sentTodayCount: 0,
+        sentTodayDate: '',
     };
-    // Use nohup + background for Docker compatibility
-    const cmd = `nohup node "${serverPath}" > /tmp/whatsapp-server-${port}.log 2>&1 &`;
-    try {
-        (0, node_child_process_1.execSync)(cmd, { env, stdio: 'pipe' });
+    async function connect() {
+        if (state.socket && state.status === 'connected')
+            return;
+        const resolvedPath = expandHome(cfg.sessionPath);
+        if (!node_fs_1.default.existsSync(resolvedPath))
+            node_fs_1.default.mkdirSync(resolvedPath, { recursive: true });
+        const { useMultiFileAuthState, fetchLatestBaileysVersion, makeWASocket, makeCacheableSignalKeyStore, Browsers, DisconnectReason } = baileysModule;
+        const { state: authState, saveCreds } = await useMultiFileAuthState(resolvedPath);
+        const { version } = await fetchLatestBaileysVersion();
+        state.status = 'connecting';
+        state.qr = null;
+        state.socket = makeWASocket({
+            version,
+            browser: Browsers.ubuntu('n8n WhatsApp Node'),
+            auth: { creds: authState.creds, keys: makeCacheableSignalKeyStore(authState.keys, silentLogger) },
+            markOnlineOnConnect: false,
+            syncFullHistory: false,
+            shouldSyncHistoryMessage: () => false,
+            generateHighQualityLinkPreview: false,
+            logger: silentLogger,
+        });
+        state.socket.ev.on('creds.update', () => saveCreds().catch(() => { }));
+        state.socket.ev.on('connection.update', (update) => {
+            var _a, _b;
+            const { connection, lastDisconnect, qr: newQr } = update;
+            if (newQr) {
+                state.qr = newQr;
+                state.status = 'qr_ready';
+            }
+            if (connection === 'open') {
+                state.status = 'connected';
+                state.qr = null;
+                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;
+                if (code === DisconnectReason.loggedOut) {
+                    state.status = 'logged_out';
+                    state.socket = null;
+                }
+                else {
+                    state.status = 'disconnected';
+                    state.socket = null;
+                    setTimeout(() => connect().catch(() => { }), 5000);
+                }
+            }
+        });
+        state.socket.ev.on('messages.upsert', (upsert) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            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
+                    content = `[${msgType}]`;
+                const ts = msg.messageTimestamp != null ? Number(msg.messageTimestamp) : Date.now() / 1000;
+                state.messageBuffer.push({ messageId: msg.key.id, chatJid: msg.key.remoteJid, sender: (_l = msg.key.participant) !== null && _l !== void 0 ? _l : msg.key.remoteJid, content, timestamp: new Date(ts * 1000).toISOString(), isFromMe: false, messageType: msgType });
+            }
+        });
+        if (!state.queue) {
+            const PQueue = (await Promise.resolve().then(() => __importStar(require('p-queue')))).default;
+            state.queue = new PQueue({ concurrency: 1 });
+        }
     }
-    catch (err) {
-        const stderr = err.stderr ? err.stderr.toString() : '';
-        const stdout = err.stdout ? err.stdout.toString() : '';
-        throw new Error(`Failed to start WhatsApp server: ${err.message} | stdout: ${stdout} | stderr: ${stderr}`);
+    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`;
     }
-    serverPort = port;
-    // Wait for server to start (up to 10s)
-    const started = await new Promise((resolve) => {
-        const start = Date.now();
-        const check = setInterval(async () => {
-            if (await isPortOpen(port)) {
-                clearInterval(check);
-                resolve(true);
+    async function sendMessage(to, content) {
+        var _a;
+        if (!state.socket || state.status !== 'connected')
+            throw new Error('WhatsApp not connected');
+        if (cfg.dailySendLimit > 0) {
+            const today = new Date().toISOString().slice(0, 10) + 'T00:00:00.000Z';
+            if (state.sentTodayDate !== today) {
+                state.sentTodayDate = today;
+                state.sentTodayCount = 0;
             }
-            if (Date.now() - start > 10000) {
-                clearInterval(check);
-                resolve(false);
+            if (state.sentTodayCount >= cfg.dailySendLimit)
+                throw new Error(`Daily limit (${cfg.dailySendLimit}) reached`);
+        }
+        const jid = normalizeRecipient(to);
+        if (cfg.checkRecipientExists && !jid.endsWith('@g.us')) {
+            const results = await state.socket.onWhatsApp(jid);
+            if (!((_a = results === null || results === void 0 ? void 0 : results[0]) === null || _a === void 0 ? void 0 : _a.exists))
+                throw new Error(`Recipient ${to} not on WhatsApp`);
+        }
+        const task = state.queue.add(async () => {
+            var _a;
+            const wait = state.nextSendAt - Date.now();
+            if (wait > 0)
+                await sleep(wait);
+            if (cfg.typingSimulation) {
+                try {
+                    await state.socket.sendPresenceUpdate('composing', jid);
+                    const len = (content.text || content.caption || '').length;
+                    await sleep(Math.min(randBetween(900, 1800) + len * 25, 4000));
+                    await state.socket.sendPresenceUpdate('paused', jid);
+                }
+                catch { }
             }
-        }, 500);
-    });
-    if (!started) {
-        // Read log for error details
-        let logContent = '';
-        try {
-            logContent = node_fs_1.default.readFileSync(`/tmp/whatsapp-server-${port}.log`, 'utf-8');
+            const response = await state.socket.sendMessage(jid, content);
+            const gap = randBetween(cfg.messageDelayMinMs, cfg.messageDelayMaxMs);
+            let burst = 0;
+            if (cfg.burstSize && ++state.sentInBurst >= cfg.burstSize) {
+                state.sentInBurst = 0;
+                burst = randBetween(cfg.burstPauseMinMs, cfg.burstPauseMaxMs);
+            }
+            state.nextSendAt = Date.now() + gap + burst;
+            if (cfg.dailySendLimit > 0)
+                state.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 };
+        });
+        let timer;
+        const winner = await Promise.race([
+            task.then((r) => ({ result: r }), (e) => ({ error: e })),
+            new Promise(r => { timer = setTimeout(() => r(null), 15000); }),
+        ]);
+        clearTimeout(timer);
+        if (!winner) {
+            task.then(() => { }, () => { });
+            return { messageId: 'queued', status: 'queued', recipient: jid };
         }
-        catch { }
-        throw new Error(`WhatsApp server failed to start. Log: ${logContent.slice(0, 500)}`);
+        if (winner.error)
+            throw winner.error;
+        return winner.result;
     }
-}
-async function disconnect() {
-    // Signal server to stop (it's a separate process)
-    if (serverPort) {
+    // HTTP server
+    const httpServer = node_http_1.default.createServer(async (req, res) => {
+        const url = new node_url_1.URL(req.url || '/', `http://localhost:${port}`);
+        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 {
-            await fetch(`http://127.0.0.1:${serverPort}/health`);
+            if (url.pathname === '/health') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, status: state.status, connected: state.status === 'connected' }));
+            }
+            else if (url.pathname === '/status') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ status: state.status, connected: state.status === 'connected', qrAvailable: state.status === 'qr_ready', sentToday: state.sentTodayCount, dailyLimit: cfg.dailySendLimit }));
+            }
+            else if (url.pathname === '/connect') {
+                await connect();
+                const result = await new Promise(r => {
+                    const check = setInterval(() => {
+                        if (state.status === 'connected') {
+                            clearInterval(check);
+                            r({ connected: true, message: 'Connected' });
+                        }
+                        if (state.qr) {
+                            clearInterval(check);
+                            Promise.resolve().then(() => __importStar(require('qrcode'))).then(QRCode => QRCode.toDataURL(state.qr, { width: 300, margin: 2 }).then(qrUrl => r({ connected: false, qrUrl, message: 'Scan QR' })));
+                        }
+                    }, 500);
+                    setTimeout(() => { clearInterval(check); r({ connected: false, status: state.status, message: 'Timeout' }); }, 30000);
+                });
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(result));
+            }
+            else if (url.pathname === '/qr' && state.qr) {
+                const QRCode = await Promise.resolve().then(() => __importStar(require('qrcode')));
+                const qrUrl = await QRCode.toDataURL(state.qr, { width: 400, margin: 2 });
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(`<!DOCTYPE html><html><body style="display:flex;justify-content:center;align-items:center;height:100vh;background:#111"><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"');
+                        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') {
+                const msgs = state.messageBuffer.splice(0, state.messageBuffer.length);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ messages: msgs, count: msgs.length }));
+            }
+            else if (url.pathname === '/signout') {
+                if (state.socket) {
+                    try {
+                        state.socket.end(new Error('Sign out'));
+                    }
+                    catch { }
+                    state.socket = null;
+                }
+                state.status = 'stopped';
+                const p = expandHome(cfg.sessionPath);
+                if (node_fs_1.default.existsSync(p)) {
+                    node_fs_1.default.readdirSync(p).forEach(f => node_fs_1.default.unlinkSync(node_path_1.default.join(p, f)));
+                    node_fs_1.default.rmdirSync(p);
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: true, message: 'Signed out' }));
+            }
+            else {
+                res.writeHead(404);
+                res.end('Not found');
+            }
         }
-        catch { }
-    }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message }));
+        }
+    });
+    await new Promise(r => httpServer.listen(port, () => r()));
+    state.server = httpServer;
+    servers.set(port, state);
+    console.log(`[WhatsApp] Server started on port ${port}`);
 }
-function parseIncomingMessage(msg) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    if (!msg.message || !msg.key || !msg.key.remoteJid)
-        return null;
-    let content = null;
-    const messageType = Object.keys(msg.message)[0];
-    if (msg.message.conversation) {
-        content = msg.message.conversation;
-    }
-    else if ((_a = msg.message.extendedTextMessage) === null || _a === void 0 ? void 0 : _a.text) {
-        content = msg.message.extendedTextMessage.text;
-    }
-    else if ((_b = msg.message.imageMessage) === null || _b === void 0 ? void 0 : _b.caption) {
-        content = msg.message.imageMessage.caption;
-    }
-    else if ((_c = msg.message.videoMessage) === null || _c === void 0 ? void 0 : _c.caption) {
-        content = msg.message.videoMessage.caption;
-    }
-    else if ((_d = msg.message.documentMessage) === null || _d === void 0 ? void 0 : _d.fileName) {
-        content = msg.message.documentMessage.fileName;
-    }
-    else if (msg.message.audioMessage) {
-        content = '[Audio]';
-    }
-    else if (msg.message.stickerMessage) {
-        content = '[Sticker]';
-    }
-    else if (msg.message.locationMessage) {
-        content = `[Location] ${msg.message.locationMessage.address || ''}`;
-    }
-    else if ((_e = msg.message.contactMessage) === null || _e === void 0 ? void 0 : _e.displayName) {
-        content = `[Contact] ${msg.message.contactMessage.displayName}`;
-    }
-    else if ((_f = msg.message.pollCreationMessage) === null || _f === void 0 ? void 0 : _f.name) {
-        content = `[Poll] ${msg.message.pollCreationMessage.name}`;
+async function ensureServerRunning(cfg) {
+    const port = getPort(cfg);
+    if (!servers.has(port)) {
+        await startServer(cfg);
     }
-    const timestampSeconds = msg.messageTimestamp != null
-        ? Number(msg.messageTimestamp)
-        : Date.now() / 1000;
-    return {
-        messageId: msg.key.id,
-        chatJid: msg.key.remoteJid,
-        sender: (_g = msg.key.participant) !== null && _g !== void 0 ? _g : msg.key.remoteJid,
-        content: content || `[${messageType}]`,
-        timestamp: new Date(timestampSeconds * 1000).toISOString(),
-        isFromMe: (_h = msg.key.fromMe) !== null && _h !== void 0 ? _h : false,
-        messageType,
-    };
 }
+async function disconnect() { }
 async function getWhatsAppCredentials(credentials) {
     var _a, _b;
     return {

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

@@ -52,18 +52,32 @@ class WhatsAppConnect {
         for (let i = 0; i < items.length; i++) {
             try {
                 if (operation === 'connect') {
-                    // Start the background WhatsApp server
-                    await (0, WhatsAppApiHelper_1.ensureServerRunning)(cfg);
+                    // Start the WhatsApp server
+                    try {
+                        await (0, WhatsAppApiHelper_1.ensureServerRunning)(cfg);
+                    }
+                    catch (serverErr) {
+                        returnData.push({
+                            json: { connected: false, error: `Server start failed: ${serverErr.message}`, sessionPath: cfg.sessionPath },
+                            pairedItem: { item: i },
+                        });
+                        continue;
+                    }
                     // Connect to the server
-                    const response = await fetch(`${(0, WhatsAppApiHelper_1.getServerUrl)(cfg)}/connect`, { method: 'POST' });
-                    const result = await response.json();
-                    returnData.push({
-                        json: {
-                            ...result,
-                            sessionPath: cfg.sessionPath,
-                        },
-                        pairedItem: { item: i },
-                    });
+                    try {
+                        const response = await fetch(`${(0, WhatsAppApiHelper_1.getServerUrl)(cfg)}/connect`, { method: 'POST' });
+                        const result = await response.json();
+                        returnData.push({
+                            json: { ...result, sessionPath: cfg.sessionPath },
+                            pairedItem: { item: i },
+                        });
+                    }
+                    catch (fetchErr) {
+                        returnData.push({
+                            json: { connected: false, error: `Fetch failed: ${fetchErr.message}. Server URL: ${(0, WhatsAppApiHelper_1.getServerUrl)(cfg)}`, sessionPath: cfg.sessionPath },
+                            pairedItem: { item: i },
+                        });
+                    }
                 }
                 else if (operation === 'status') {
                     try {

package/package.json

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