@raevon/n8n-nodes-whatsapp 2.0.14 → 3.0.0

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

@@ -1,3 +1,4 @@
+import { type WASocket } from '@whiskeysockets/baileys';
 export interface WhatsAppCredentials {
     sessionPath: string;
     messageDelayMinMs: number;
@@ -9,9 +10,20 @@ export interface WhatsAppCredentials {
     dailySendLimit: number;
     checkRecipientExists: boolean;
 }
-export declare function getServerUrl(cfg: WhatsAppCredentials): string;
-export declare function ensureServerRunning(cfg: WhatsAppCredentials): Promise<void>;
-export declare function startServerIfNeeded(cfg: WhatsAppCredentials): Promise<void>;
-export declare function stopServer(cfg: WhatsAppCredentials): Promise<void>;
-export declare function disconnect(): Promise<void>;
 export declare function getWhatsAppCredentials(credentials: Record<string, any>): Promise<WhatsAppCredentials>;
+export declare function ensureConnected(cfg: WhatsAppCredentials): Promise<WASocket>;
+export declare function getConnectionStatus(): {
+    status: "stopped" | "connecting" | "qr_ready" | "connected" | "logged_out" | "error" | "disconnected";
+    connected: boolean;
+    qrAvailable: boolean;
+    sentToday: number;
+    dailyLimit: number;
+    lastError: string | null;
+};
+export declare function connectOrGetQr(cfg: WhatsAppCredentials): Promise<{
+    connected: boolean;
+    qrUrl?: string;
+    message: string;
+}>;
+export declare function parseIncomingMessage(msg: any): Record<string, any> | null;
+export declare function sendMessageWithAntiBan(to: string, content: any, cfg: WhatsAppCredentials): Promise<any>;

package/dist/nodes/WhatsApp/WhatsAppApiHelper.js

@@ -36,368 +36,130 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getServerUrl = getServerUrl;
-exports.ensureServerRunning = ensureServerRunning;
-exports.startServerIfNeeded = startServerIfNeeded;
-exports.stopServer = stopServer;
-exports.disconnect = disconnect;
 exports.getWhatsAppCredentials = getWhatsAppCredentials;
+exports.ensureConnected = ensureConnected;
+exports.getConnectionStatus = getConnectionStatus;
+exports.connectOrGetQr = connectOrGetQr;
+exports.parseIncomingMessage = parseIncomingMessage;
+exports.sendMessageWithAntiBan = sendMessageWithAntiBan;
+const n8n_workflow_1 = require("n8n-workflow");
+const baileys_1 = __importStar(require("@whiskeysockets/baileys"));
 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;
+const qrcode_1 = __importDefault(require("qrcode"));
+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 getPort(cfg) {
-    const hash = cfg.sessionPath.split('').reduce((a, b) => ((a << 5) - a + b.charCodeAt(0)) | 0, 0);
-    return 3456 + (Math.abs(hash) % 1000);
+const noop = () => { };
+const silentLogger = { level: 'silent', info: noop, warn: noop, error: noop, debug: noop, fatal: noop, trace: noop, child: () => silentLogger };
+// --- Singleton state ---
+let socket = null;
+let status = 'stopped';
+let queue = null;
+let nextSendAt = 0;
+let sentInBurst = 0;
+let sentTodayCount = 0;
+let sentTodayDate = '';
+let reconnectAttempts = 0;
+let reconnectTimer = null;
+let qrResolve = null;
+let generation = 0;
+let lastDisconnectError = null;
+function todayStartIso() {
+    return new Date().toISOString().slice(0, 10) + 'T00:00:00.000Z';
 }
-function getServerUrl(cfg) {
-    return `http://127.0.0.1:${getPort(cfg)}`;
+function sendGapMs(cfg) {
+    return randBetween(cfg.messageDelayMinMs, cfg.messageDelayMaxMs);
 }
-async function isPortOpen(port) {
-    return new Promise((resolve) => {
-        const server = node_net_1.default.createServer();
-        server.once('error', () => resolve(false));
-        server.once('listening', () => { server.close(); resolve(true); });
-        server.listen(port, '127.0.0.1');
-    });
+function burstPauseMs(cfg) {
+    if (!cfg.burstSize || ++sentInBurst < cfg.burstSize)
+        return 0;
+    sentInBurst = 0;
+    return randBetween(cfg.burstPauseMinMs, cfg.burstPauseMaxMs);
+}
+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`;
 }
-// --- In-memory server state (singleton per process) ---
-const servers = new Map();
-async function startServer(cfg) {
-    const port = getPort(cfg);
-    // Already running?
-    if (servers.has(port))
+async function scheduleReconnect(cfg) {
+    if (reconnectTimer)
         return;
-    // Load Baileys dynamically
-    if (!baileysModule) {
-        baileysModule = await Promise.resolve().then(() => __importStar(require('@whiskeysockets/baileys')));
-    }
-    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: '',
-    };
-    async function connect() {
-        if (state.socket && state.status === 'connected')
+    const base = Math.min(1000 * (2 ** reconnectAttempts), 60000);
+    const delay = Math.round(base * (0.8 + Math.random() * 0.4));
+    reconnectAttempts += 1;
+    reconnectTimer = setTimeout(() => { reconnectTimer = null; initSocket(cfg, sessionPathGlobal).catch(() => { }); }, delay);
+}
+let sessionPathGlobal = null;
+async function initSocket(cfg, authPath) {
+    if (socket && status === 'connected')
+        return socket;
+    const gen = ++generation;
+    const resolvedPath = expandHome(authPath);
+    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)();
+    const sock = (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 = sock;
+    status = 'connecting';
+    reconnectAttempts = 0;
+    sock.ev.on('creds.update', () => {
+        if (gen !== generation)
             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 });
-        }
-    }
-    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`;
-    }
-    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 (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 { }
-            }
-            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 };
+        saveCreds().catch(() => { });
+    });
+    sock.ev.on('connection.update', async (update) => {
+        var _a, _b;
+        if (gen !== generation)
+            return;
+        const { connection, lastDisconnect, qr: newQr } = update;
+        if (newQr) {
+            qrResolve && qrResolve({ qr: newQr, qrUrl: '' });
+            qrResolve = null;
         }
-        if (winner.error)
-            throw winner.error;
-        return winner.result;
-    }
-    // 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();
+        if (connection === 'open') {
+            status = 'connected';
+            reconnectAttempts = 0;
             return;
         }
-        try {
-            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' }));
+        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;
+            lastDisconnectError = `Code: ${code}`;
+            if (code === baileys_1.DisconnectReason.loggedOut) {
+                status = 'logged_out';
+                socket = null;
+                ++generation;
             }
             else {
-                res.writeHead(404);
-                res.end('Not found');
+                status = 'disconnected';
+                socket = null;
+                scheduleReconnect(cfg);
             }
         }
-        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}`);
-}
-async function ensureServerRunning(cfg) {
-    const port = getPort(cfg);
-    // Just check if server is running — don't start it
-    try {
-        const res = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(3000) });
-        if (res.ok)
-            return; // Server alive
+    if (!queue) {
+        const PQ = (await Promise.resolve().then(() => __importStar(require('p-queue')))).default;
+        queue = new PQ({ concurrency: 1 });
     }
-    catch { }
-    throw new Error(`WhatsApp server not running on port ${port}. Run "Start Server" or "Connect" first.`);
+    return sock;
 }
-async function startServerIfNeeded(cfg) {
-    const port = getPort(cfg);
-    // Check if already running
-    try {
-        const res = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(3000) });
-        if (res.ok)
-            return; // Already running
-    }
-    catch { }
-    // Port free — start server
-    if (await isPortOpen(port)) {
-        await startServer(cfg);
-        return;
-    }
-    // Port occupied by something else
-    throw new Error(`Port ${port} occupied. Restart n8n container, then try again.`);
-}
-async function stopServer(cfg) {
-    const port = getPort(cfg);
-    // Try graceful shutdown via the server's own /signout endpoint
-    try {
-        await fetch(`http://127.0.0.1:${port}/signout`, { method: 'POST', signal: AbortSignal.timeout(3000) });
-    }
-    catch { }
-    // Clean up in-memory state
-    const state = servers.get(port);
-    if (state) {
-        if (state.socket) {
-            try {
-                state.socket.end(new Error('Server stop'));
-            }
-            catch { }
-        }
-        if (state.server) {
-            try {
-                state.server.close();
-            }
-            catch { }
-        }
-        servers.delete(port);
-    }
-}
-async function disconnect() { }
 async function getWhatsAppCredentials(credentials) {
     var _a, _b;
     return {
@@ -412,3 +174,164 @@ async function getWhatsAppCredentials(credentials) {
         checkRecipientExists: credentials.checkRecipientExists !== false,
     };
 }
+async function ensureConnected(cfg) {
+    sessionPathGlobal = cfg.sessionPath;
+    const resolvedPath = expandHome(cfg.sessionPath);
+    const hasSession = node_fs_1.default.existsSync(resolvedPath) && node_fs_1.default.readdirSync(resolvedPath).length > 0;
+    if (!hasSession) {
+        // No session — connect and wait for QR
+        const sock = await initSocket(cfg, cfg.sessionPath);
+        const qrData = await new Promise((resolve) => {
+            qrResolve = resolve;
+            setTimeout(() => { if (qrResolve) {
+                qrResolve(null);
+                qrResolve = null;
+            } }, 90000);
+        });
+        if (!qrData)
+            throw new n8n_workflow_1.NodeApiError({}, { message: 'QR expired. Run Connect again.' });
+        // Wait for connection
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new Error('Connection timeout')), 30000);
+            const check = setInterval(() => {
+                if (status === 'connected') {
+                    clearTimeout(timeout);
+                    clearInterval(check);
+                    resolve();
+                }
+                if (status === 'logged_out' || status === 'error') {
+                    clearTimeout(timeout);
+                    clearInterval(check);
+                    reject(new Error('Connection failed'));
+                }
+            }, 1000);
+        });
+        return sock;
+    }
+    // Session exists — connect
+    const sock = await initSocket(cfg, cfg.sessionPath);
+    await new Promise((resolve) => {
+        const check = setInterval(() => {
+            if (status === 'connected' || status === 'error' || status === 'logged_out') {
+                clearInterval(check);
+                resolve();
+            }
+        }, 500);
+        setTimeout(() => { clearInterval(check); resolve(); }, 20000);
+    });
+    if (status !== 'connected')
+        throw new n8n_workflow_1.NodeApiError({}, { message: `Connection failed (status: ${status})` });
+    return sock;
+}
+function getConnectionStatus() {
+    return { status, connected: status === 'connected', qrAvailable: status === 'qr_ready', sentToday: sentTodayCount, dailyLimit: 500, lastError: lastDisconnectError };
+}
+async function connectOrGetQr(cfg) {
+    sessionPathGlobal = cfg.sessionPath;
+    const resolvedPath = expandHome(cfg.sessionPath);
+    const hasSession = node_fs_1.default.existsSync(resolvedPath) && node_fs_1.default.readdirSync(resolvedPath).length > 0;
+    if (hasSession) {
+        await initSocket(cfg, cfg.sessionPath);
+        await new Promise((resolve) => {
+            const check = setInterval(() => { if (status === 'connected' || status === 'error' || status === 'logged_out') {
+                clearInterval(check);
+                resolve();
+            } }, 500);
+            setTimeout(() => { clearInterval(check); resolve(); }, 15000);
+        });
+        if (status === 'connected')
+            return { connected: true, message: 'Connected successfully' };
+        return { connected: false, message: `Status: ${status}` };
+    }
+    const sock = await initSocket(cfg, cfg.sessionPath);
+    const qrData = await new Promise((resolve) => {
+        qrResolve = resolve;
+        setTimeout(() => { if (qrResolve) {
+            qrResolve(null);
+            qrResolve = null;
+        } }, 30000);
+    });
+    if (!qrData)
+        return { connected: false, message: 'QR not generated. Try again.' };
+    const qrDataUrl = await qrcode_1.default.toDataURL(qrData.qr, { width: 300, margin: 2 });
+    return { connected: false, qrUrl: qrDataUrl, message: `Open this URL to scan QR:\n${qrDataUrl}\n\nAfter scanning, run Connect again.` };
+}
+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}`;
+    const ts = 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(ts * 1000).toISOString(), isFromMe: (_h = msg.key.fromMe) !== null && _h !== void 0 ? _h : false, messageType };
+}
+async function sendMessageWithAntiBan(to, content, cfg) {
+    var _a;
+    const sock = await ensureConnected(cfg);
+    if (cfg.dailySendLimit > 0) {
+        const today = todayStartIso();
+        if (sentTodayDate !== today) {
+            sentTodayDate = today;
+            sentTodayCount = 0;
+        }
+        if (sentTodayCount >= cfg.dailySendLimit)
+            throw new Error(`Daily limit reached`);
+    }
+    const jid = normalizeRecipient(to);
+    if (cfg.checkRecipientExists && !jid.endsWith('@g.us')) {
+        const results = await sock.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 not on WhatsApp`);
+    }
+    const task = queue.add(async () => {
+        var _a;
+        const wait = nextSendAt - Date.now();
+        if (wait > 0)
+            await sleep(wait);
+        if (cfg.typingSimulation) {
+            try {
+                await sock.sendPresenceUpdate('composing', jid);
+                await sleep(Math.min(randBetween(900, 1800) + (content.text || '').length * 25, 4000));
+                await sock.sendPresenceUpdate('paused', jid);
+            }
+            catch { }
+        }
+        const response = await sock.sendMessage(jid, content);
+        nextSendAt = Date.now() + sendGapMs(cfg) + burstPauseMs(cfg);
+        if (cfg.dailySendLimit > 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');
+        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 };
+    }
+    if (winner.error)
+        throw winner.error;
+    return winner.result;
+}

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

@@ -1,18 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WhatsAppConnect = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const WhatsAppApiHelper_1 = require("./WhatsAppApiHelper");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-function expandHome(p) {
-    if (!p.startsWith('~'))
-        return p;
-    return node_path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', p.slice(1));
-}
 class WhatsAppConnect {
     constructor() {
         this.description = {
@@ -22,23 +12,17 @@ class WhatsAppConnect {
             group: ['transform'],
             version: 1,
             subtitle: '={{$parameter["operation"]}}',
-            description: 'Connect to WhatsApp — manage server, scan QR, sign out',
+            description: 'Connect to WhatsApp — scan QR on first run',
             defaults: { name: 'WhatsApp Connect' },
             inputs: ['main'],
             outputs: ['main'],
             credentials: [{ name: 'whatsappApi', required: true }],
             properties: [
                 {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    noDataExpression: true,
+                    displayName: 'Operation', name: 'operation', type: 'options', noDataExpression: true,
                     options: [
-                        { name: 'Connect', value: 'connect', description: 'Start server and connect to WhatsApp', action: 'Connect to WhatsApp' },
-                        { name: 'Get Status', value: 'status', description: 'Get server and connection status', action: 'Get status' },
-                        { name: 'Start Server', value: 'startServer', description: 'Start the WhatsApp background server', action: 'Start server' },
-                        { name: 'Stop Server', value: 'stopServer', description: 'Stop the WhatsApp background server', action: 'Stop server' },
-                        { name: 'Sign Out', value: 'signOut', description: 'Stop server and delete session', action: 'Sign out' },
+                        { name: 'Connect', value: 'connect', description: 'Connect to WhatsApp', action: 'Connect' },
+                        { name: 'Get Status', value: 'status', description: 'Get connection status', action: 'Get status' },
                     ],
                     default: 'connect',
                 },
@@ -53,78 +37,13 @@ class WhatsAppConnect {
         const operation = this.getNodeParameter('operation', 0);
         for (let i = 0; i < items.length; i++) {
             try {
-                if (operation === 'startServer') {
-                    await (0, WhatsAppApiHelper_1.startServerIfNeeded)(cfg);
-                    returnData.push({
-                        json: { success: true, message: 'Server started', port: (0, WhatsAppApiHelper_1.getServerUrl)(cfg), sessionPath: cfg.sessionPath },
-                        pairedItem: { item: i },
-                    });
-                }
-                else if (operation === 'stopServer') {
-                    // Try graceful shutdown via /signout
-                    try {
-                        await fetch(`${(0, WhatsAppApiHelper_1.getServerUrl)(cfg)}/signout`, { method: 'POST', signal: AbortSignal.timeout(3000) });
-                        returnData.push({
-                            json: { success: true, message: 'Server stopped', sessionPath: cfg.sessionPath },
-                            pairedItem: { item: i },
-                        });
-                    }
-                    catch {
-                        returnData.push({
-                            json: { success: false, message: 'Server may be in another worker. Restart n8n container to fully stop.', sessionPath: cfg.sessionPath },
-                            pairedItem: { item: i },
-                        });
-                    }
-                }
-                else if (operation === 'connect') {
-                    try {
-                        await (0, WhatsAppApiHelper_1.startServerIfNeeded)(cfg);
-                    }
-                    catch (err) {
-                        returnData.push({
-                            json: { connected: false, error: err.message, sessionPath: cfg.sessionPath },
-                            pairedItem: { item: i },
-                        });
-                        continue;
-                    }
-                    try {
-                        const serverUrl = (0, WhatsAppApiHelper_1.getServerUrl)(cfg);
-                        const response = await fetch(`${serverUrl}/connect`, { method: 'POST', signal: AbortSignal.timeout(60000) });
-                        const result = await response.json();
-                        returnData.push({ json: { ...result, sessionPath: cfg.sessionPath }, pairedItem: { item: i } });
-                    }
-                    catch (err) {
-                        returnData.push({
-                            json: { connected: false, error: `Connect failed: ${err.message}`, sessionPath: cfg.sessionPath },
-                            pairedItem: { item: i },
-                        });
-                    }
+                if (operation === 'connect') {
+                    const result = await (0, WhatsAppApiHelper_1.connectOrGetQr)(cfg);
+                    returnData.push({ json: { ...result, sessionPath: cfg.sessionPath }, pairedItem: { item: i } });
                 }
                 else if (operation === 'status') {
-                    try {
-                        await (0, WhatsAppApiHelper_1.ensureServerRunning)(cfg);
-                        const response = await fetch(`${(0, WhatsAppApiHelper_1.getServerUrl)(cfg)}/status`);
-                        const result = await response.json();
-                        returnData.push({ json: { ...result, sessionPath: cfg.sessionPath }, pairedItem: { item: i } });
-                    }
-                    catch {
-                        returnData.push({
-                            json: { status: 'server_not_running', connected: false, sessionPath: cfg.sessionPath },
-                            pairedItem: { item: i },
-                        });
-                    }
-                }
-                else if (operation === 'signOut') {
-                    await (0, WhatsAppApiHelper_1.stopServer)(cfg);
-                    const resolvedPath = expandHome(cfg.sessionPath);
-                    if (node_fs_1.default.existsSync(resolvedPath)) {
-                        node_fs_1.default.readdirSync(resolvedPath).forEach(f => node_fs_1.default.unlinkSync(node_path_1.default.join(resolvedPath, f)));
-                        node_fs_1.default.rmdirSync(resolvedPath);
-                    }
-                    returnData.push({
-                        json: { success: true, message: 'Signed out. Session deleted.', sessionPath: cfg.sessionPath },
-                        pairedItem: { item: i },
-                    });
+                    const status = (0, WhatsAppApiHelper_1.getConnectionStatus)();
+                    returnData.push({ json: { ...status, sessionPath: cfg.sessionPath }, pairedItem: { item: i } });
                 }
             }
             catch (error) {

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

@@ -12,95 +12,31 @@ class WhatsAppSend {
             group: ['transform'],
             version: 1,
             subtitle: '={{$parameter["operation"]}}',
-            description: 'Send WhatsApp messages via background server',
+            description: 'Send WhatsApp messages with anti-ban protection',
             defaults: { name: 'WhatsApp Send' },
             inputs: ['main'],
             outputs: ['main'],
             credentials: [{ name: 'whatsappApi', required: true }],
             properties: [
                 {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    noDataExpression: true,
+                    displayName: 'Operation', name: 'operation', type: 'options', noDataExpression: true,
                     options: [
-                        { name: 'Send Text', value: 'sendText', description: 'Send a text message', action: 'Send text message' },
-                        { name: 'Send Image', value: 'sendImage', description: 'Send an image with optional caption', action: 'Send image message' },
-                        { name: 'Send Document', value: 'sendDocument', description: 'Send a document/file', action: 'Send document' },
-                        { name: 'Send Audio', value: 'sendAudio', description: 'Send an audio message or voice note', action: 'Send audio message' },
-                        { name: 'Send Location', value: 'sendLocation', description: 'Send a location pin', action: 'Send location' },
+                        { name: 'Send Text', value: 'sendText', description: 'Send a text message', action: 'Send text' },
+                        { name: 'Send Image', value: 'sendImage', description: 'Send an image', action: 'Send image' },
+                        { name: 'Send Document', value: 'sendDocument', description: 'Send a document', action: 'Send document' },
+                        { name: 'Send Audio', value: 'sendAudio', description: 'Send audio', action: 'Send audio' },
+                        { name: 'Send Location', value: 'sendLocation', description: 'Send location', action: 'Send location' },
                     ],
                     default: 'sendText',
                 },
-                {
-                    displayName: 'Recipient',
-                    name: 'recipient',
-                    type: 'string',
-                    default: '',
-                    required: true,
-                    description: 'Phone number (e.g., +1234567890) or WhatsApp JID',
-                },
-                {
-                    displayName: 'Text',
-                    name: 'text',
-                    type: 'string',
-                    default: '',
-                    required: true,
-                    displayOptions: { show: { operation: ['sendText'] } },
-                    description: 'Message text to send',
-                },
-                {
-                    displayName: 'Binary Property',
-                    name: 'binaryProperty',
-                    type: 'string',
-                    default: 'data',
-                    required: true,
-                    displayOptions: { show: { operation: ['sendImage', 'sendDocument', 'sendAudio'] } },
-                    description: 'Name of the binary property containing the file data',
-                },
-                {
-                    displayName: 'Caption',
-                    name: 'caption',
-                    type: 'string',
-                    default: '',
-                    displayOptions: { show: { operation: ['sendImage', 'sendDocument'] } },
-                    description: 'Optional caption',
-                },
-                {
-                    displayName: 'File Name',
-                    name: 'fileName',
-                    type: 'string',
-                    default: 'file',
-                    required: true,
-                    displayOptions: { show: { operation: ['sendDocument'] } },
-                    description: 'Name of the file being sent',
-                },
-                {
-                    displayName: 'Voice Note',
-                    name: 'ptt',
-                    type: 'boolean',
-                    default: false,
-                    displayOptions: { show: { operation: ['sendAudio'] } },
-                    description: 'Send as voice note',
-                },
-                {
-                    displayName: 'Latitude',
-                    name: 'latitude',
-                    type: 'number',
-                    default: 0,
-                    required: true,
-                    displayOptions: { show: { operation: ['sendLocation'] } },
-                    description: 'Location latitude',
-                },
-                {
-                    displayName: 'Longitude',
-                    name: 'longitude',
-                    type: 'number',
-                    default: 0,
-                    required: true,
-                    displayOptions: { show: { operation: ['sendLocation'] } },
-                    description: 'Location longitude',
-                },
+                { displayName: 'Recipient', name: 'recipient', type: 'string', default: '', required: true, description: 'Phone number or JID' },
+                { displayName: 'Text', name: 'text', type: 'string', default: '', required: true, displayOptions: { show: { operation: ['sendText'] } }, description: 'Message text' },
+                { displayName: 'Binary Property', name: 'binaryProperty', type: 'string', default: 'data', required: true, displayOptions: { show: { operation: ['sendImage', 'sendDocument', 'sendAudio'] } }, description: 'Binary property name' },
+                { displayName: 'Caption', name: 'caption', type: 'string', default: '', displayOptions: { show: { operation: ['sendImage', 'sendDocument'] } }, description: 'Caption' },
+                { displayName: 'File Name', name: 'fileName', type: 'string', default: 'file', required: true, displayOptions: { show: { operation: ['sendDocument'] } }, description: 'File name' },
+                { displayName: 'Voice Note', name: 'ptt', type: 'boolean', default: false, displayOptions: { show: { operation: ['sendAudio'] } }, description: 'Voice note' },
+                { displayName: 'Latitude', name: 'latitude', type: 'number', default: 0, required: true, displayOptions: { show: { operation: ['sendLocation'] } }, description: 'Latitude' },
+                { displayName: 'Longitude', name: 'longitude', type: 'number', default: 0, required: true, displayOptions: { show: { operation: ['sendLocation'] } }, description: 'Longitude' },
             ],
         };
     }
@@ -109,60 +45,39 @@ class WhatsAppSend {
         const returnData = [];
         const credentials = await this.getCredentials('whatsappApi');
         const cfg = await (0, WhatsAppApiHelper_1.getWhatsAppCredentials)(credentials);
-        // Ensure server is running
-        await (0, WhatsAppApiHelper_1.ensureServerRunning)(cfg);
-        const serverUrl = (0, WhatsAppApiHelper_1.getServerUrl)(cfg);
         for (let i = 0; i < items.length; i++) {
             try {
                 const operation = this.getNodeParameter('operation', i);
                 const recipient = this.getNodeParameter('recipient', i);
-                let body = { to: recipient };
+                let content = {};
                 switch (operation) {
                     case 'sendText':
-                        body.text = this.getNodeParameter('text', i);
+                        content = { text: this.getNodeParameter('text', i) };
                         break;
                     case 'sendImage': {
-                        const binaryProperty = this.getNodeParameter('binaryProperty', i);
-                        const buffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
-                        body.image = buffer.toString('base64');
-                        body.caption = this.getNodeParameter('caption', i) || undefined;
+                        const bp = this.getNodeParameter('binaryProperty', i);
+                        const buf = await this.helpers.getBinaryDataBuffer(i, bp);
+                        content = { image: buf, caption: this.getNodeParameter('caption', i) || undefined };
                         break;
                     }
                     case 'sendDocument': {
-                        const binaryProperty = this.getNodeParameter('binaryProperty', i);
-                        const buffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
-                        body.document = buffer.toString('base64');
-                        body.fileName = this.getNodeParameter('fileName', i);
-                        body.caption = this.getNodeParameter('caption', i) || undefined;
+                        const bp = this.getNodeParameter('binaryProperty', i);
+                        const buf = await this.helpers.getBinaryDataBuffer(i, bp);
+                        content = { document: buf, fileName: this.getNodeParameter('fileName', i), caption: this.getNodeParameter('caption', i) || undefined };
                         break;
                     }
                     case 'sendAudio': {
-                        const binaryProperty = this.getNodeParameter('binaryProperty', i);
-                        const buffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
-                        body.audio = buffer.toString('base64');
-                        body.ptt = this.getNodeParameter('ptt', i);
+                        const bp = this.getNodeParameter('binaryProperty', i);
+                        const buf = await this.helpers.getBinaryDataBuffer(i, bp);
+                        content = { audio: buf, ptt: this.getNodeParameter('ptt', i) };
                         break;
                     }
                     case 'sendLocation':
-                        body.location = {
-                            degreesLatitude: this.getNodeParameter('latitude', i),
-                            degreesLongitude: this.getNodeParameter('longitude', i),
-                        };
+                        content = { location: { degreesLatitude: this.getNodeParameter('latitude', i), degreesLongitude: this.getNodeParameter('longitude', i) } };
                         break;
                 }
-                const response = await fetch(`${serverUrl}/send`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body),
-                });
-                const result = await response.json();
-                if (!response.ok) {
-                    throw new Error(result.error || 'Send failed');
-                }
-                returnData.push({
-                    json: { ...result, operation, success: true },
-                    pairedItem: { item: i },
-                });
+                const result = await (0, WhatsAppApiHelper_1.sendMessageWithAntiBan)(recipient, content, cfg);
+                returnData.push({ json: { ...result, operation, success: true }, pairedItem: { item: i } });
             }
             catch (error) {
                 if (this.continueOnFail()) {

package/dist/nodes/WhatsApp/WhatsAppTrigger.node.d.ts

@@ -1,5 +1,5 @@
-import { INodeType, INodeTypeDescription, INodeExecutionData, IPollFunctions } from 'n8n-workflow';
+import { INodeType, INodeTypeDescription, ITriggerFunctions, ITriggerResponse } from 'n8n-workflow';
 export declare class WhatsAppTrigger implements INodeType {
     description: INodeTypeDescription;
-    poll(this: IPollFunctions): Promise<INodeExecutionData[][] | null>;
+    trigger(this: ITriggerFunctions): Promise<ITriggerResponse>;
 }

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

@@ -11,12 +11,11 @@ class WhatsAppTrigger {
             group: ['trigger'],
             version: 1,
             subtitle: '={{$parameter["event"]}}',
-            description: 'Triggers on incoming WhatsApp messages via background server',
+            description: 'Triggers on incoming WhatsApp messages — connection stays alive while workflow is active',
             defaults: { name: 'WhatsApp Trigger' },
             inputs: [],
             outputs: ['main'],
             credentials: [{ name: 'whatsappApi', required: true }],
-            polling: true,
             properties: [
                 {
                     displayName: 'Event',
@@ -44,37 +43,71 @@ class WhatsAppTrigger {
             ],
         };
     }
-    async poll() {
+    async trigger() {
         const credentials = await this.getCredentials('whatsappApi');
         const cfg = await (0, WhatsAppApiHelper_1.getWhatsAppCredentials)(credentials);
         const chatFilter = this.getNodeParameter('chatJidFilter', '');
         const onlyText = this.getNodeParameter('onlyText', false);
-        // 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);
+        // Connect to WhatsApp — this keeps the socket alive
+        const sock = await (0, WhatsAppApiHelper_1.ensureConnected)(cfg);
+        // Listen for incoming messages
+        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;
+                // Emit message to workflow
+                this.emit([[{ json: parsed }]]);
             }
-            if (onlyText) {
-                messages = messages.filter((msg) => msg.messageType === 'conversation' || msg.messageType === 'extendedTextMessage');
+        });
+        // Handle connection errors
+        sock.ev.on('connection.update', (update) => {
+            if (update.connection === 'close') {
+                this.emitError(new Error('WhatsApp connection closed'));
             }
-            if (messages.length === 0)
-                return null;
-            return [messages.map((msg) => ({
-                    json: msg,
-                    pairedItem: { item: 0 },
-                }))];
-        }
-        catch {
-            return null;
-        }
+        });
+        // Cleanup when workflow deactivates
+        let closeFunctionCalled = false;
+        const closeFunction = async () => {
+            closeFunctionCalled = true;
+            try {
+                sock.end(new Error('Workflow deactivated'));
+            }
+            catch { }
+        };
+        // Manual trigger for testing
+        const manualTriggerFunction = async () => {
+            return new Promise((resolve) => {
+                const handler = (upsert) => {
+                    for (const msg of upsert.messages) {
+                        if (msg.key.fromMe)
+                            continue;
+                        const parsed = (0, WhatsAppApiHelper_1.parseIncomingMessage)(msg);
+                        if (parsed) {
+                            sock.ev.off('messages.upsert', handler);
+                            this.emit([[{ json: parsed }]]);
+                            resolve();
+                            return;
+                        }
+                    }
+                };
+                sock.ev.on('messages.upsert', handler);
+                setTimeout(() => { sock.ev.off('messages.upsert', handler); resolve(); }, 30000);
+            });
+        };
+        return {
+            closeFunction,
+            manualTriggerFunction,
+        };
     }
 }
 exports.WhatsAppTrigger = WhatsAppTrigger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raevon/n8n-nodes-whatsapp",
-  "version": "2.0.14",
+  "version": "3.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",