@raevon/n8n-nodes-whatsapp 1.0.1 → 1.0.3

package/dist/credentials/WhatsAppApi.credentials.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WhatsAppApi = void 0;
+// Note: WhatsApp uses WebSocket (not HTTP), so n8n's ICredentialTestRequest
+// can't test the connection. Session validation happens at socket connection
+// time in ensureConnected(). If the session is invalid, the first node
+// execution will trigger QR login automatically.
 class WhatsAppApi {
     constructor() {
         this.name = 'whatsappApi';
@@ -13,7 +17,7 @@ class WhatsAppApi {
                 type: 'string',
                 default: '~/.n8n/whatsapp-auth',
                 required: true,
-                description: 'Directory path where WhatsApp session files are stored. After first QR scan, session persists here.',
+                description: 'Directory path where WhatsApp session files are stored. After first QR scan, session persists here. Use the "WhatsApp Connect" node to scan QR on first setup.',
             },
             {
                 displayName: 'QR Server Port',

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WhatsAppApi = exports.WhatsAppTrigger = exports.WhatsAppSend = void 0;
+exports.WhatsAppApi = exports.WhatsAppConnect = 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 WhatsAppConnect_node_1 = require("./nodes/WhatsApp/WhatsAppConnect.node");
+Object.defineProperty(exports, "WhatsAppConnect", { enumerable: true, get: function () { return WhatsAppConnect_node_1.WhatsAppConnect; } });
 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.js

@@ -51,7 +51,17 @@ 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;
+// I8: Extracted ~ path expansion to avoid duplication
+function expandHome(p) {
+    if (!p.startsWith('~'))
+        return p;
+    return node_path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', p.slice(1));
+}
 // --- Singleton socket manager ---
+// NOTE: This singleton is shared across ALL n8n workflow executions using the same credential.
+// Anti-ban counters (sentTodayCount, sentInBurst, nextSendAt) are module-level — two workflows
+// burning through the same daily limit will share the counter. This is intentional for a
+// single-credential setup. Multi-credential support would require a Map<sessionPath, State>.
 let socketInstance = null;
 let socketStatus = 'stopped';
 let socketConfig = null;
@@ -65,6 +75,7 @@ let reconnectAttempts = 0;
 let reconnectTimer = null;
 let qrResolve = null;
 let qrHttpServer = null;
+let qrTimeout = null; // C3: Store timeout ref for cleanup
 let latestQr = null;
 let generation = 0; // #10: Generation counter — prevents stale handlers on reconnect
 function todayStartIso() {
@@ -116,6 +127,12 @@ function stopQrServer() {
         qrHttpServer = null;
     }
 }
+function clearQrTimeout() {
+    if (qrTimeout) {
+        clearTimeout(qrTimeout);
+        qrTimeout = null;
+    }
+}
 // #7: Reconnect backoff with jitter — exponential 1s→60s, ±20% randomization
 async function scheduleReconnect(cfg) {
     if (reconnectTimer)
@@ -132,9 +149,7 @@ async function initSocket(cfg, authPath) {
     if (socketInstance && socketStatus === 'connected')
         return socketInstance;
     const gen = ++generation; // #10: Snapshot generation for this connection attempt
-    const resolvedPath = authPath.startsWith('~')
-        ? node_path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', authPath.slice(1))
-        : authPath;
+    const resolvedPath = expandHome(authPath);
     if (!node_fs_1.default.existsSync(resolvedPath)) {
         node_fs_1.default.mkdirSync(resolvedPath, { recursive: true });
     }
@@ -161,7 +176,9 @@ async function initSocket(cfg, authPath) {
     sock.ev.on('creds.update', () => {
         if (gen !== generation)
             return; // #10: Ignore stale connection events
-        saveCreds().catch(() => { });
+        saveCreds().catch((err) => {
+            console.error('[WhatsApp] Failed to save credentials:', err.message);
+        });
     });
     sock.ev.on('connection.update', (update) => {
         var _a, _b;
@@ -171,8 +188,8 @@ async function initSocket(cfg, authPath) {
         if (qr) {
             latestQr = qr;
             socketStatus = 'qr_ready';
-            const qrUrl = `https://quickchart.io/qr?text=${encodeURIComponent(qr)}&size=300`;
             if (qrResolve) {
+                const qrUrl = `https://quickchart.io/qr?text=${encodeURIComponent(qr)}&size=300`;
                 qrResolve({ qr, qrUrl });
                 qrResolve = null;
             }
@@ -181,6 +198,7 @@ async function initSocket(cfg, authPath) {
             socketStatus = 'connected';
             reconnectAttempts = 0;
             latestQr = null;
+            clearQrTimeout(); // C3: Clear QR timeout on successful connection
             stopQrServer();
             return;
         }
@@ -233,11 +251,12 @@ async function ensureConnected(cfg) {
     };
     socketConfig = antiBanCfg;
     sessionPath = cfg.sessionPath;
-    queue = new p_queue_1.default({ concurrency: 1 });
+    // C1: Guard queue creation — only create once, preserve anti-ban state across calls
+    if (!queue) {
+        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 resolvedPath = expandHome(cfg.sessionPath);
     const hasSession = node_fs_1.default.existsSync(resolvedPath) && node_fs_1.default.readdirSync(resolvedPath).length > 0;
     if (!hasSession) {
         await startQrServer(cfg.qrPort);
@@ -247,12 +266,13 @@ async function ensureConnected(cfg) {
     if (!hasSession) {
         const qrData = await new Promise((resolve) => {
             qrResolve = resolve;
-            // Timeout after 5 minutes
-            setTimeout(() => {
+            // C3: Store timeout ref so it can be cleared on successful scan
+            qrTimeout = setTimeout(() => {
                 if (qrResolve) {
                     qrResolve(null);
                     qrResolve = null;
                 }
+                qrTimeout = null;
             }, 300000);
         });
         if (!qrData) {
@@ -402,7 +422,7 @@ function getConnectionStatus() {
     };
 }
 function parseIncomingMessage(msg) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     if (!msg.message || !msg.key || !msg.key.remoteJid)
         return null;
     let content = null;
@@ -443,10 +463,11 @@ function parseIncomingMessage(msg) {
     return {
         messageId: msg.key.id,
         chatJid: msg.key.remoteJid,
-        sender: msg.key.participant || (msg.key.remoteJid !== msg.key.participant ? msg.key.remoteJid : null),
+        // C4: Simplified sender logic — participant is sender in groups, remoteJid in DMs
+        sender: (_g = msg.key.participant) !== null && _g !== void 0 ? _g : msg.key.remoteJid,
         content: content || `[${messageType}]`,
         timestamp: new Date(timestampSeconds * 1000).toISOString(),
-        isFromMe: (_g = msg.key.fromMe) !== null && _g !== void 0 ? _g : false,
+        isFromMe: (_h = msg.key.fromMe) !== null && _h !== void 0 ? _h : false,
         messageType,
     };
 }

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

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

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppConnect = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const WhatsAppApiHelper_1 = require("./WhatsAppApiHelper");
+class WhatsAppConnect {
+    constructor() {
+        this.description = {
+            displayName: 'WhatsApp Connect',
+            name: 'whatsAppConnect',
+            icon: 'file:icons/whatsapp.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Connect to WhatsApp — scan QR code on first run, then reconnects automatically',
+            defaults: { name: 'WhatsApp Connect' },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [{ name: 'whatsappApi', required: true }],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Connect', value: 'connect', description: 'Connect to WhatsApp (scan QR on first run)', action: 'Connect to WhatsApp' },
+                        { name: 'Get Status', value: 'status', description: 'Get current connection status', action: 'Get connection status' },
+                    ],
+                    default: 'connect',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('whatsappApi');
+        const cfg = await (0, WhatsAppApiHelper_1.getWhatsAppCredentials)(credentials);
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (operation === 'connect') {
+                    // Connect to WhatsApp — this triggers QR flow on first run
+                    const sock = await (0, WhatsAppApiHelper_1.ensureConnected)(cfg);
+                    const status = (0, WhatsAppApiHelper_1.getConnectionStatus)();
+                    returnData.push({
+                        json: {
+                            success: true,
+                            status: status.status,
+                            connected: status.connected,
+                            message: status.connected
+                                ? 'WhatsApp connected successfully'
+                                : `QR code ready — open http://localhost:${cfg.qrPort}/qr in your browser to scan`,
+                            qrUrl: status.qrAvailable ? `http://localhost:${cfg.qrPort}/qr` : null,
+                            sessionPath: cfg.sessionPath,
+                        },
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (operation === 'status') {
+                    const status = (0, WhatsAppApiHelper_1.getConnectionStatus)();
+                    returnData.push({
+                        json: {
+                            ...status,
+                            sessionPath: cfg.sessionPath,
+                        },
+                        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.WhatsAppConnect = WhatsAppConnect;

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

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WhatsAppTrigger = void 0;
 const WhatsAppApiHelper_1 = require("./WhatsAppApiHelper");
-const messageBuffer = [];
-let socketInitialized = false;
+// Per-credential buffers — one buffer per session path
+// This ensures multiple trigger nodes with different credentials don't share messages
+const buffersBySession = new Map();
+const initializedBySession = new Set();
 class WhatsAppTrigger {
     constructor() {
         this.description = {
@@ -51,8 +53,14 @@ class WhatsAppTrigger {
         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 sessionKey = cfg.sessionPath;
+        // Get or create buffer for this credential
+        if (!buffersBySession.has(sessionKey)) {
+            buffersBySession.set(sessionKey, []);
+        }
+        const buffer = buffersBySession.get(sessionKey);
+        // Initialize socket listener once per credential
+        if (!initializedBySession.has(sessionKey)) {
             const sock = await (0, WhatsAppApiHelper_1.ensureConnected)(cfg);
             sock.ev.on('messages.upsert', (upsert) => {
                 const { messages, type } = upsert;
@@ -68,15 +76,15 @@ class WhatsAppTrigger {
                         continue;
                     if (onlyText && parsed.messageType !== 'conversation' && parsed.messageType !== 'extendedTextMessage')
                         continue;
-                    messageBuffer.push(parsed);
+                    buffer.push(parsed);
                 }
             });
-            socketInitialized = true;
+            initializedBySession.add(sessionKey);
         }
         // Return buffered messages
-        if (messageBuffer.length === 0)
+        if (buffer.length === 0)
             return null;
-        const messages = messageBuffer.splice(0, messageBuffer.length);
+        const messages = buffer.splice(0, buffer.length);
         return [messages.map((msg) => ({
                 json: msg,
                 pairedItem: { item: 0 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raevon/n8n-nodes-whatsapp",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "n8n community node for WhatsApp — send and receive messages with anti-ban protection via the Baileys library",
   "keywords": [
     "n8n-community-node-package",
@@ -30,14 +30,13 @@
     ],
     "nodes": [
       "dist/nodes/WhatsApp/WhatsAppSend.node.js",
-      "dist/nodes/WhatsApp/WhatsAppTrigger.node.js"
+      "dist/nodes/WhatsApp/WhatsAppTrigger.node.js",
+      "dist/nodes/WhatsApp/WhatsAppConnect.node.js"
     ]
   },
   "dependencies": {
     "@whiskeysockets/baileys": "^7.0.0-rc13",
-    "p-queue": "^8.0.1",
-    "pino": "^9.6.0",
-    "open": "^10.1.0"
+    "p-queue": "^8.0.1"
   },
   "devDependencies": {
     "@types/node": "^20.19.39",