@raevon/n8n-nodes-whatsapp 1.0.0

package/dist/credentials/WhatsAppApi.credentials.d.ts

@@ -0,0 +1,7 @@
+import { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class WhatsAppApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/WhatsAppApi.credentials.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppApi = void 0;
+class WhatsAppApi {
+    constructor() {
+        this.name = 'whatsappApi';
+        this.displayName = 'WhatsApp API';
+        this.documentationUrl = 'https://github.com/WhiskeySockets/Baileys';
+        this.properties = [
+            {
+                displayName: 'Session Path',
+                name: 'sessionPath',
+                type: 'string',
+                default: '~/.n8n/whatsapp-auth',
+                required: true,
+                description: 'Directory path where WhatsApp session files are stored. After first QR scan, session persists here.',
+            },
+            {
+                displayName: 'QR Server Port',
+                name: 'qrPort',
+                type: 'number',
+                default: 3456,
+                description: 'Local HTTP server port for serving QR code during first-time setup. Only used when no session exists.',
+            },
+            {
+                displayName: 'Message Delay Min (ms)',
+                name: 'messageDelayMinMs',
+                type: 'number',
+                default: 5000,
+                description: 'Minimum delay between messages in milliseconds. Part of anti-ban protection.',
+            },
+            {
+                displayName: 'Message Delay Max (ms)',
+                name: 'messageDelayMaxMs',
+                type: 'number',
+                default: 9000,
+                description: 'Maximum delay between messages in milliseconds. Part of anti-ban protection.',
+            },
+            {
+                displayName: 'Burst Size',
+                name: 'burstSize',
+                type: 'number',
+                default: 20,
+                description: 'Number of messages before an extra cooldown pause. Set to 0 to disable.',
+            },
+            {
+                displayName: 'Burst Pause Min (ms)',
+                name: 'burstPauseMinMs',
+                type: 'number',
+                default: 30000,
+                description: 'Minimum burst cooldown pause in milliseconds.',
+            },
+            {
+                displayName: 'Burst Pause Max (ms)',
+                name: 'burstPauseMaxMs',
+                type: 'number',
+                default: 60000,
+                description: 'Maximum burst cooldown pause in milliseconds.',
+            },
+            {
+                displayName: 'Typing Simulation',
+                name: 'typingSimulation',
+                type: 'boolean',
+                default: true,
+                description: 'Show "typing..." indicator before sending each message to appear human-like.',
+            },
+            {
+                displayName: 'Daily Send Limit',
+                name: 'dailySendLimit',
+                type: 'number',
+                default: 500,
+                description: 'Maximum messages per day (UTC). Set to 0 for unlimited (not recommended).',
+            },
+            {
+                displayName: 'Check Recipient Exists',
+                name: 'checkRecipientExists',
+                type: 'boolean',
+                default: true,
+                description: 'Verify the recipient phone number is registered on WhatsApp before sending.',
+            },
+        ];
+    }
+}
+exports.WhatsAppApi = WhatsAppApi;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { WhatsAppSend } from './nodes/WhatsApp/WhatsAppSend.node';
+export { WhatsAppTrigger } from './nodes/WhatsApp/WhatsAppTrigger.node';
+export { WhatsAppApi } from './credentials/WhatsAppApi.credentials';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppApi = exports.WhatsAppTrigger = exports.WhatsAppSend = void 0;
+var WhatsAppSend_node_1 = require("./nodes/WhatsApp/WhatsAppSend.node");
+Object.defineProperty(exports, "WhatsAppSend", { enumerable: true, get: function () { return WhatsAppSend_node_1.WhatsAppSend; } });
+var WhatsAppTrigger_node_1 = require("./nodes/WhatsApp/WhatsAppTrigger.node");
+Object.defineProperty(exports, "WhatsAppTrigger", { enumerable: true, get: function () { return WhatsAppTrigger_node_1.WhatsAppTrigger; } });
+var WhatsAppApi_credentials_1 = require("./credentials/WhatsAppApi.credentials");
+Object.defineProperty(exports, "WhatsAppApi", { enumerable: true, get: function () { return WhatsAppApi_credentials_1.WhatsAppApi; } });

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

@@ -0,0 +1,59 @@
+import { type WASocket } from '@whiskeysockets/baileys';
+export interface WhatsAppCredentials {
+    sessionPath: string;
+    qrPort: number;
+    messageDelayMinMs: number;
+    messageDelayMaxMs: number;
+    burstSize: number;
+    burstPauseMinMs: number;
+    burstPauseMaxMs: number;
+    typingSimulation: boolean;
+    dailySendLimit: number;
+    checkRecipientExists: boolean;
+}
+interface AntiBanConfig {
+    messageDelayMinMs: number;
+    messageDelayMaxMs: number;
+    burstSize: number;
+    burstPauseMinMs: number;
+    burstPauseMaxMs: number;
+    typingSimulation: boolean;
+    dailySendLimit: number;
+    checkRecipientExists: boolean;
+}
+export declare function getWhatsAppCredentials(credentials: Record<string, any>): Promise<WhatsAppCredentials>;
+export declare function ensureConnected(cfg: WhatsAppCredentials): Promise<WASocket>;
+export declare function simulateTyping(jid: string, content: {
+    text?: string;
+    caption?: string;
+}, cfg: AntiBanConfig): Promise<void>;
+export declare function sendMessageWithAntiBan(to: string, content: {
+    text?: string;
+    image?: Buffer;
+    document?: Buffer;
+    audio?: Buffer;
+    location?: {
+        degreesLatitude: number;
+        degreesLongitude: number;
+        name?: string;
+        address?: string;
+    };
+    mimetype?: string;
+    fileName?: string;
+    caption?: string;
+    ptt?: boolean;
+}, cfg: WhatsAppCredentials): Promise<{
+    messageId: string;
+    status: string;
+    recipient: string;
+}>;
+export declare function getConnectionStatus(): {
+    status: string;
+    connected: boolean;
+    qrAvailable: boolean;
+    queueSize: number;
+    sentToday: number;
+    dailyLimit: number;
+};
+export declare function parseIncomingMessage(msg: any): Record<string, any> | null;
+export {};

package/dist/nodes/WhatsApp/WhatsAppApiHelper.js

@@ -0,0 +1,423 @@
+"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 });
+exports.getWhatsAppCredentials = getWhatsAppCredentials;
+exports.ensureConnected = ensureConnected;
+exports.simulateTyping = simulateTyping;
+exports.sendMessageWithAntiBan = sendMessageWithAntiBan;
+exports.getConnectionStatus = getConnectionStatus;
+exports.parseIncomingMessage = parseIncomingMessage;
+const n8n_workflow_1 = require("n8n-workflow");
+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 sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const randBetween = (min, max) => max > min ? min + Math.floor(Math.random() * (max - min + 1)) : min;
+// --- Singleton socket manager ---
+let socketInstance = null;
+let socketStatus = 'stopped';
+let socketConfig = null;
+let sessionPath = null;
+let queue = null;
+let nextSendAt = 0;
+let sentInBurst = 0;
+let sentTodayCount = 0;
+let sentTodayDate = '';
+let reconnectAttempts = 0;
+let reconnectTimer = null;
+let qrResolve = null;
+let qrHttpServer = null;
+let latestQr = null;
+function todayStartIso() {
+    return new Date().toISOString().slice(0, 10) + 'T00:00:00.000Z';
+}
+function sendGapMs(cfg) {
+    return randBetween(cfg.messageDelayMinMs, cfg.messageDelayMaxMs);
+}
+function burstPauseMs(cfg) {
+    const size = cfg.burstSize;
+    if (!size || ++sentInBurst < size)
+        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`;
+}
+function startQrServer(port) {
+    return new Promise((resolve) => {
+        if (qrHttpServer) {
+            resolve();
+            return;
+        }
+        qrHttpServer = node_http_1.default.createServer((req, res) => {
+            const url = new node_url_1.URL(req.url || '/', `http://localhost:${port}`);
+            if (url.pathname === '/qr' && latestQr) {
+                const qrUrl = `https://quickchart.io/qr?text=${encodeURIComponent(latestQr)}&size=300`;
+                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;color:white;font-family:sans-serif}img{border-radius:12px}p{margin-top:20px;text-align:center}</style></head><body><div><img src="${qrUrl}" width="300"/><p>Scan with WhatsApp → Settings → Linked Devices → Link a Device</p><p style="color:#888;font-size:12px">This page auto-refreshes. Session saves after scan.</p></div></body></html>`);
+            }
+            else {
+                res.writeHead(404);
+                res.end('Not found');
+            }
+        });
+        qrHttpServer.listen(port, () => resolve());
+    });
+}
+function stopQrServer() {
+    if (qrHttpServer) {
+        qrHttpServer.close();
+        qrHttpServer = null;
+    }
+}
+async function scheduleReconnect(cfg) {
+    if (reconnectTimer)
+        return;
+    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, sessionPath).catch(() => { });
+    }, delay);
+}
+async function initSocket(cfg, authPath) {
+    if (socketInstance && socketStatus === 'connected')
+        return socketInstance;
+    const resolvedPath = authPath.startsWith('~')
+        ? node_path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', authPath.slice(1))
+        : 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, { level: 'silent' }),
+        },
+        markOnlineOnConnect: false,
+        syncFullHistory: false,
+        shouldSyncHistoryMessage: () => false,
+        generateHighQualityLinkPreview: false,
+        logger: { level: 'silent' },
+    });
+    socketInstance = sock;
+    socketStatus = 'connecting';
+    reconnectAttempts = 0;
+    sock.ev.on('creds.update', () => {
+        saveCreds().catch(() => { });
+    });
+    sock.ev.on('connection.update', (update) => {
+        var _a, _b;
+        const { connection, lastDisconnect, qr } = update;
+        if (qr) {
+            latestQr = qr;
+            socketStatus = 'qr_ready';
+            const qrUrl = `https://quickchart.io/qr?text=${encodeURIComponent(qr)}&size=300`;
+            if (qrResolve) {
+                qrResolve({ qr, qrUrl });
+                qrResolve = null;
+            }
+        }
+        if (connection === 'open') {
+            socketStatus = 'connected';
+            reconnectAttempts = 0;
+            latestQr = null;
+            stopQrServer();
+            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 === baileys_1.DisconnectReason.loggedOut) {
+                socketStatus = 'logged_out';
+                socketInstance = null;
+                stopQrServer();
+            }
+            else {
+                socketInstance = null;
+                scheduleReconnect(cfg);
+            }
+        }
+    });
+    return sock;
+}
+// --- Public API ---
+async function getWhatsAppCredentials(credentials) {
+    var _a, _b;
+    return {
+        sessionPath: credentials.sessionPath || '~/.n8n/whatsapp-auth',
+        qrPort: credentials.qrPort || 3456,
+        messageDelayMinMs: credentials.messageDelayMinMs || 5000,
+        messageDelayMaxMs: credentials.messageDelayMaxMs || 9000,
+        burstSize: (_a = credentials.burstSize) !== null && _a !== void 0 ? _a : 20,
+        burstPauseMinMs: credentials.burstPauseMinMs || 30000,
+        burstPauseMaxMs: credentials.burstPauseMaxMs || 60000,
+        typingSimulation: credentials.typingSimulation !== false,
+        dailySendLimit: (_b = credentials.dailySendLimit) !== null && _b !== void 0 ? _b : 500,
+        checkRecipientExists: credentials.checkRecipientExists !== false,
+    };
+}
+async function ensureConnected(cfg) {
+    if (socketStatus === 'connected' && socketInstance)
+        return socketInstance;
+    const antiBanCfg = {
+        messageDelayMinMs: cfg.messageDelayMinMs,
+        messageDelayMaxMs: cfg.messageDelayMaxMs,
+        burstSize: cfg.burstSize,
+        burstPauseMinMs: cfg.burstPauseMinMs,
+        burstPauseMaxMs: cfg.burstPauseMaxMs,
+        typingSimulation: cfg.typingSimulation,
+        dailySendLimit: cfg.dailySendLimit,
+        checkRecipientExists: cfg.checkRecipientExists,
+    };
+    socketConfig = antiBanCfg;
+    sessionPath = cfg.sessionPath;
+    queue = new p_queue_1.default({ concurrency: 1 });
+    // Start QR server for first-time setup
+    const resolvedPath = cfg.sessionPath.startsWith('~')
+        ? node_path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', cfg.sessionPath.slice(1))
+        : cfg.sessionPath;
+    const hasSession = node_fs_1.default.existsSync(resolvedPath) && node_fs_1.default.readdirSync(resolvedPath).length > 0;
+    if (!hasSession) {
+        await startQrServer(cfg.qrPort);
+    }
+    const sock = await initSocket(antiBanCfg, cfg.sessionPath);
+    // If no session, wait for QR scan
+    if (!hasSession) {
+        const qrData = await new Promise((resolve) => {
+            qrResolve = resolve;
+            // Timeout after 5 minutes
+            setTimeout(() => {
+                if (qrResolve) {
+                    qrResolve(null);
+                    qrResolve = null;
+                }
+            }, 300000);
+        });
+        if (!qrData) {
+            throw new n8n_workflow_1.NodeApiError({}, {
+                message: 'QR code expired. Please try again.',
+            });
+        }
+        // Wait for connection to open after scan
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new Error('Connection timeout after QR scan')), 60000);
+            const checkInterval = setInterval(() => {
+                if (socketStatus === 'connected') {
+                    clearTimeout(timeout);
+                    clearInterval(checkInterval);
+                    resolve();
+                }
+                if (socketStatus === 'logged_out' || socketStatus === 'error') {
+                    clearTimeout(timeout);
+                    clearInterval(checkInterval);
+                    reject(new Error('Connection failed after QR scan'));
+                }
+            }, 1000);
+        });
+    }
+    return sock;
+}
+async function simulateTyping(jid, content, cfg) {
+    if (!cfg.typingSimulation || !socketInstance)
+        return;
+    try {
+        await socketInstance.sendPresenceUpdate('composing', jid);
+        const len = (content.text || content.caption || '').length;
+        await sleep(Math.min(randBetween(900, 1800) + len * 25, 4000));
+        await socketInstance.sendPresenceUpdate('paused', jid);
+    }
+    catch {
+        // presence is best-effort
+    }
+}
+async function sendMessageWithAntiBan(to, content, cfg) {
+    const sock = await ensureConnected(cfg);
+    // Daily limit check
+    if (cfg.dailySendLimit > 0) {
+        const today = todayStartIso();
+        if (sentTodayDate !== today) {
+            sentTodayDate = today;
+            sentTodayCount = 0;
+        }
+        if (sentTodayCount >= cfg.dailySendLimit) {
+            throw new n8n_workflow_1.NodeApiError({}, {
+                message: `Daily send limit (${cfg.dailySendLimit}) reached. Resets at midnight UTC.`,
+            });
+        }
+    }
+    const jid = normalizeRecipient(to);
+    // Recipient validation
+    if (cfg.checkRecipientExists && !jid.endsWith('@g.us')) {
+        const results = await sock.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 n8n_workflow_1.NodeApiError({}, {
+                message: `Recipient ${to} is not registered on WhatsApp.`,
+            });
+        }
+    }
+    // Queue the send through anti-ban
+    const antiBanCfg = {
+        messageDelayMinMs: cfg.messageDelayMinMs,
+        messageDelayMaxMs: cfg.messageDelayMaxMs,
+        burstSize: cfg.burstSize,
+        burstPauseMinMs: cfg.burstPauseMinMs,
+        burstPauseMaxMs: cfg.burstPauseMaxMs,
+        typingSimulation: cfg.typingSimulation,
+        dailySendLimit: cfg.dailySendLimit,
+        checkRecipientExists: cfg.checkRecipientExists,
+    };
+    const result = await queue.add(async () => {
+        var _a;
+        const wait = nextSendAt - Date.now();
+        if (wait > 0)
+            await sleep(wait);
+        // Typing simulation
+        await simulateTyping(jid, content, antiBanCfg);
+        // Build message content
+        const msgContent = {};
+        if (content.text)
+            msgContent.text = content.text;
+        if (content.image)
+            msgContent.image = content.image;
+        if (content.document)
+            msgContent.document = content.document;
+        if (content.audio)
+            msgContent.audio = content.audio;
+        if (content.location)
+            msgContent.location = content.location;
+        if (content.mimetype)
+            msgContent.mimetype = content.mimetype;
+        if (content.fileName)
+            msgContent.fileName = content.fileName;
+        if (content.caption)
+            msgContent.caption = content.caption;
+        if (content.ptt !== undefined)
+            msgContent.ptt = content.ptt;
+        const response = await sock.sendMessage(jid, msgContent);
+        // Update anti-ban timing
+        nextSendAt = Date.now() + sendGapMs(antiBanCfg) + burstPauseMs(antiBanCfg);
+        // Update daily count
+        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('WhatsApp did not return a message ID');
+        }
+        return {
+            messageId: response.key.id,
+            status: 'sent',
+            recipient: jid,
+        };
+    });
+    return result;
+}
+function getConnectionStatus() {
+    var _a;
+    return {
+        status: socketStatus,
+        connected: socketStatus === 'connected',
+        qrAvailable: socketStatus === 'qr_ready',
+        queueSize: queue ? queue.size + queue.pending : 0,
+        sentToday: sentTodayCount,
+        dailyLimit: (_a = socketConfig === null || socketConfig === void 0 ? void 0 : socketConfig.dailySendLimit) !== null && _a !== void 0 ? _a : 0,
+    };
+}
+function parseIncomingMessage(msg) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    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 timestampSeconds = msg.messageTimestamp != null
+        ? Number(msg.messageTimestamp)
+        : Date.now() / 1000;
+    return {
+        messageId: msg.key.id,
+        chatJid: msg.key.remoteJid,
+        sender: msg.key.participant || (msg.key.remoteJid !== msg.key.participant ? msg.key.remoteJid : null),
+        content: content || `[${messageType}]`,
+        timestamp: new Date(timestampSeconds * 1000).toISOString(),
+        isFromMe: (_g = msg.key.fromMe) !== null && _g !== void 0 ? _g : false,
+        messageType,
+    };
+}

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

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class WhatsAppSend implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

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

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppSend = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const WhatsAppApiHelper_1 = require("./WhatsAppApiHelper");
+class WhatsAppSend {
+    constructor() {
+        this.description = {
+            displayName: 'WhatsApp Send',
+            name: 'whatsAppSend',
+            icon: 'file:icons/whatsapp.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            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,
+                    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' },
+                    ],
+                    default: 'sendText',
+                },
+                {
+                    displayName: 'Recipient',
+                    name: 'recipient',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'Phone number (e.g., +1234567890) or WhatsApp JID (e.g., 1234567890@s.whatsapp.net)',
+                },
+                {
+                    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 for the image or document',
+                },
+                {
+                    displayName: 'File Name',
+                    name: 'fileName',
+                    type: 'string',
+                    default: 'file',
+                    required: true,
+                    displayOptions: { show: { operation: ['sendDocument'] } },
+                    description: 'Name of the file being sent',
+                },
+                {
+                    displayName: 'MIME Type',
+                    name: 'mimeType',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { operation: ['sendImage', 'sendDocument', 'sendAudio'] } },
+                    description: 'MIME type (auto-detected if empty)',
+                },
+                {
+                    displayName: 'Voice Note',
+                    name: 'ptt',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: { show: { operation: ['sendAudio'] } },
+                    description: 'Send as voice note (push-to-talk) instead of audio file',
+                },
+                {
+                    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: 'Location Name',
+                    name: 'locationName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { operation: ['sendLocation'] } },
+                    description: 'Optional name for the location',
+                },
+                {
+                    displayName: 'Location Address',
+                    name: 'locationAddress',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { operation: ['sendLocation'] } },
+                    description: 'Optional address for the location',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('whatsappApi');
+        const cfg = await (0, WhatsAppApiHelper_1.getWhatsAppCredentials)(credentials);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const operation = this.getNodeParameter('operation', i);
+                const recipient = this.getNodeParameter('recipient', i);
+                let content = {};
+                switch (operation) {
+                    case 'sendText':
+                        content = { text: this.getNodeParameter('text', i) };
+                        break;
+                    case 'sendImage': {
+                        const binaryProperty = this.getNodeParameter('binaryProperty', i);
+                        const buffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
+                        content = {
+                            image: buffer,
+                            caption: this.getNodeParameter('caption', i) || undefined,
+                            mimeType: this.getNodeParameter('mimeType', i) || undefined,
+                        };
+                        break;
+                    }
+                    case 'sendDocument': {
+                        const binaryProperty = this.getNodeParameter('binaryProperty', i);
+                        const buffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
+                        content = {
+                            document: buffer,
+                            fileName: this.getNodeParameter('fileName', i),
+                            caption: this.getNodeParameter('caption', i) || undefined,
+                            mimeType: this.getNodeParameter('mimeType', i) || undefined,
+                        };
+                        break;
+                    }
+                    case 'sendAudio': {
+                        const binaryProperty = this.getNodeParameter('binaryProperty', i);
+                        const buffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
+                        content = {
+                            audio: buffer,
+                            ptt: this.getNodeParameter('ptt', i),
+                            mimeType: this.getNodeParameter('mimeType', i) || undefined,
+                        };
+                        break;
+                    }
+                    case 'sendLocation':
+                        content = {
+                            location: {
+                                degreesLatitude: this.getNodeParameter('latitude', i),
+                                degreesLongitude: this.getNodeParameter('longitude', i),
+                                name: this.getNodeParameter('locationName', i) || undefined,
+                                address: this.getNodeParameter('locationAddress', i) || undefined,
+                            },
+                        };
+                        break;
+                }
+                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()) {
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                            success: false,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
+            }
+        }
+        return [returnData];
+    }
+}
+exports.WhatsAppSend = WhatsAppSend;

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

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

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppTrigger = void 0;
+const WhatsAppApiHelper_1 = require("./WhatsAppApiHelper");
+const messageBuffer = [];
+let socketInitialized = false;
+class WhatsAppTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'WhatsApp Trigger',
+            name: 'whatsAppTrigger',
+            icon: 'file:icons/whatsapp.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["event"]}}',
+            description: 'Triggers on incoming WhatsApp messages',
+            defaults: { name: 'WhatsApp Trigger' },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [{ name: 'whatsappApi', required: true }],
+            polling: true,
+            properties: [
+                {
+                    displayName: 'Event',
+                    name: 'event',
+                    type: 'options',
+                    options: [
+                        { name: 'Message Received', value: 'messageReceived', description: 'Trigger when any message is received' },
+                    ],
+                    default: 'messageReceived',
+                },
+                {
+                    displayName: 'Chat JID Filter',
+                    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.',
+                },
+                {
+                    displayName: 'Only Text Messages',
+                    name: 'onlyText',
+                    type: 'boolean',
+                    default: false,
+                    description: 'If true, only trigger for text messages (ignores images, documents, etc.)',
+                },
+            ],
+        };
+    }
+    async poll() {
+        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);
+        // Initialize socket listener once
+        if (!socketInitialized) {
+            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;
+                    messageBuffer.push(parsed);
+                }
+            });
+            socketInitialized = true;
+        }
+        // Return buffered messages
+        if (messageBuffer.length === 0)
+            return null;
+        const messages = messageBuffer.splice(0, messageBuffer.length);
+        return [messages.map((msg) => ({
+                json: msg,
+                pairedItem: { item: 0 },
+            }))];
+    }
+}
+exports.WhatsAppTrigger = WhatsAppTrigger;

package/dist/nodes/WhatsApp/icons/whatsapp.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="#25D366"><path d="M17.472 14.382c-.297-.149-1.758-.867-2.03-.967-.273-.099-.471-.148-.67.15-.197.297-.767.966-.94 1.164-.173.199-.347.223-.644.075-.297-.15-1.255-.463-2.39-1.475-.883-.788-1.48-1.761-1.653-2.059-.173-.297-.018-.458.13-.606.134-.133.298-.347.446-.52.149-.174.198-.298.298-.497.099-.198.05-.371-.025-.52-.075-.149-.669-1.612-.916-2.207-.242-.579-.487-.5-.669-.51-.173-.008-.371-.01-.57-.01-.198 0-.52.074-.792.372-.272.297-1.04 1.016-1.04 2.479 0 1.462 1.065 2.875 1.213 3.074.149.198 2.096 3.2 5.077 4.487.709.306 1.262.489 1.694.625.712.227 1.36.195 1.871.118.571-.085 1.758-.719 2.006-1.413.248-.694.248-1.289.173-1.413-.074-.124-.272-.198-.57-.347m-5.421 7.403h-.004a9.87 9.87 0 01-5.031-1.378l-.361-.214-3.741.982.998-3.648-.235-.374a9.86 9.86 0 01-1.51-5.26c.001-5.45 4.436-9.884 9.888-9.884 2.64 0 5.122 1.03 6.988 2.898a9.825 9.825 0 012.893 6.994c-.003 5.45-4.437 9.884-9.885 9.884m8.413-18.297A11.815 11.815 0 0012.05 0C5.495 0 .16 5.335.157 11.892c0 2.096.547 4.142 1.588 5.945L.057 24l6.305-1.654a11.882 11.882 0 005.683 1.448h.005c6.554 0 11.89-5.335 11.893-11.893a11.821 11.821 0 00-3.48-8.413z"/></svg>

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@raevon/n8n-nodes-whatsapp",
+  "version": "1.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",
+    "whatsapp",
+    "messaging",
+    "automation"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "n8n-nodes-whatsapp"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && mkdir -p dist/nodes/WhatsApp/icons && cp nodes/WhatsApp/icons/whatsapp.svg dist/nodes/WhatsApp/icons/whatsapp.svg",
+    "dev": "tsc --watch",
+    "lint": "eslint credentials nodes --ext .ts",
+    "lintfix": "eslint credentials nodes --ext .ts --fix",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/WhatsAppApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/WhatsApp/WhatsAppSend.node.js",
+      "dist/nodes/WhatsApp/WhatsAppTrigger.node.js"
+    ]
+  },
+  "dependencies": {
+    "@whiskeysockets/baileys": "^7.0.0-rc13",
+    "p-queue": "^8.0.1",
+    "pino": "^9.6.0",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.39",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "eslint": "^8.57.1",
+    "n8n-workflow": "^2.16.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "n8n-workflow": ">=1.0.0"
+  }
+}