@raevon/n8n-nodes-whatsapp 2.0.5 → 2.0.7

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

@@ -11,5 +11,6 @@ export interface WhatsAppCredentials {
 }
 export declare function getServerUrl(cfg: WhatsAppCredentials): string;
 export declare function ensureServerRunning(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>;

package/dist/nodes/WhatsApp/WhatsAppApiHelper.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getServerUrl = getServerUrl;
 exports.ensureServerRunning = ensureServerRunning;
+exports.stopServer = stopServer;
 exports.disconnect = disconnect;
 exports.getWhatsAppCredentials = getWhatsAppCredentials;
 const node_child_process_1 = require("node:child_process");
@@ -345,27 +346,67 @@ async function startServer(cfg) {
 }
 async function ensureServerRunning(cfg) {
     const port = getPort(cfg);
-    // Check if server is already running on this port
+    // Port is free — start server
     if (await isPortOpen(port)) {
-        // Port is in use - check if it's our server by hitting /health
-        try {
-            const res = await fetch(`http://127.0.0.1:${port}/health`);
-            if (res.ok) {
-                // Server is alive and responding
-                return;
+        await startServer(cfg);
+        return;
+    }
+    // Port is in use — server already running, just verify it responds
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(3000) });
+        if (res.ok)
+            return; // Server alive, use it
+    }
+    catch { }
+    // Port in use but not responding — try to kill via /proc
+    try {
+        const out = (0, node_child_process_1.execSync)(`cat /proc/net/tcp | awk '{if(NR>1){split($2,a,\":\");if(strtonum("0x"a[2])==${port})print $10}}'`, { encoding: 'utf-8' }).trim();
+        if (out) {
+            // Find PID from inode
+            const inode = out;
+            const pidOut = (0, node_child_process_1.execSync)(`for p in /proc/[0-9]*/fd/*; do if readlink "$p" 2>/dev/null | grep -q "socket:\\[${inode}]"; then echo "$p" | cut -d/ -f3; break; fi; done`, { encoding: 'utf-8' }).trim();
+            if (pidOut)
+                (0, node_child_process_1.execSync)(`kill -9 ${pidOut}`);
+            await new Promise(r => setTimeout(r, 1500));
+        }
+    }
+    catch { }
+    // Try again
+    if (await isPortOpen(port)) {
+        await startServer(cfg);
+        return;
+    }
+    throw new Error(`Port ${port} occupied by unknown process. Restart n8n container to clear.`);
+}
+async function stopServer(cfg) {
+    const port = getPort(cfg);
+    const state = servers.get(port);
+    if (state) {
+        if (state.socket) {
+            try {
+                state.socket.end(new Error('Server stop'));
             }
+            catch { }
         }
-        catch { }
-        // Port is in use but not responding - kill the stale process
-        try {
-            const pid = (0, node_child_process_1.execSync)(`lsof -ti:${port}`, { encoding: 'utf-8' }).trim();
-            if (pid)
-                (0, node_child_process_1.execSync)(`kill -9 ${pid}`);
-            await new Promise(r => setTimeout(r, 1000)); // Wait for port to release
+        if (state.server) {
+            try {
+                state.server.close();
+            }
+            catch { }
+        }
+        servers.delete(port);
+    }
+    // Also try to kill any process on the port
+    try {
+        const out = (0, node_child_process_1.execSync)(`cat /proc/net/tcp | awk '{if(NR>1){split($2,a,\":\");if(strtonum("0x"a[2])==${port})print $10}}'`, { encoding: 'utf-8' }).trim();
+        if (out) {
+            const inode = out;
+            const pidOut = (0, node_child_process_1.execSync)(`for p in /proc/[0-9]*/fd/*; do if readlink "$p" 2>/dev/null | grep -q "socket:\\[${inode}]"; then echo "$p" | cut -d/ -f3; break; fi; done`, { encoding: 'utf-8' }).trim();
+            if (pidOut)
+                (0, node_child_process_1.execSync)(`kill -9 ${pidOut}`);
         }
-        catch { }
     }
-    await startServer(cfg);
+    catch { }
 }
 async function disconnect() { }
 async function getWhatsAppCredentials(credentials) {

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

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WhatsAppConnect = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const WhatsAppApiHelper_1 = require("./WhatsAppApiHelper");
-const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 function expandHome(p) {
     if (!p.startsWith('~'))
         return p;
@@ -22,7 +22,7 @@ class WhatsAppConnect {
             group: ['transform'],
             version: 1,
             subtitle: '={{$parameter["operation"]}}',
-            description: 'Connect to WhatsApp — starts background server, scan QR on first run',
+            description: 'Connect to WhatsApp — manage server, scan QR, sign out',
             defaults: { name: 'WhatsApp Connect' },
             inputs: ['main'],
             outputs: ['main'],
@@ -34,8 +34,10 @@ class WhatsAppConnect {
                     type: 'options',
                     noDataExpression: true,
                     options: [
-                        { name: 'Connect', value: 'connect', description: 'Start WhatsApp server and connect', action: 'Connect to WhatsApp' },
+                        { 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' },
                     ],
                     default: 'connect',
@@ -51,42 +53,49 @@ class WhatsAppConnect {
         const operation = this.getNodeParameter('operation', 0);
         for (let i = 0; i < items.length; i++) {
             try {
-                if (operation === 'connect') {
-                    // Start the WhatsApp server
+                if (operation === 'startServer') {
+                    await (0, WhatsAppApiHelper_1.ensureServerRunning)(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') {
+                    await (0, WhatsAppApiHelper_1.stopServer)(cfg);
+                    returnData.push({
+                        json: { success: true, message: 'Server stopped', sessionPath: cfg.sessionPath },
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (operation === 'connect') {
                     try {
                         await (0, WhatsAppApiHelper_1.ensureServerRunning)(cfg);
                     }
-                    catch (serverErr) {
+                    catch (err) {
                         returnData.push({
-                            json: { connected: false, error: `Server start failed: ${serverErr.message}`, sessionPath: cfg.sessionPath },
+                            json: { connected: false, error: err.message, sessionPath: cfg.sessionPath },
                             pairedItem: { item: i },
                         });
                         continue;
                     }
-                    // Connect to the server
                     try {
                         const response = await fetch(`${(0, WhatsAppApiHelper_1.getServerUrl)(cfg)}/connect`, { method: 'POST' });
                         const result = await response.json();
-                        returnData.push({
-                            json: { ...result, sessionPath: cfg.sessionPath },
-                            pairedItem: { item: i },
-                        });
+                        returnData.push({ json: { ...result, sessionPath: cfg.sessionPath }, pairedItem: { item: i } });
                     }
-                    catch (fetchErr) {
+                    catch (err) {
                         returnData.push({
-                            json: { connected: false, error: `Fetch failed: ${fetchErr.message}. Server URL: ${(0, WhatsAppApiHelper_1.getServerUrl)(cfg)}`, sessionPath: cfg.sessionPath },
+                            json: { connected: false, error: `Server unreachable: ${err.message}`, 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 },
-                        });
+                        returnData.push({ json: { ...result, sessionPath: cfg.sessionPath }, pairedItem: { item: i } });
                     }
                     catch {
                         returnData.push({
@@ -96,17 +105,10 @@ class WhatsAppConnect {
                     }
                 }
                 else if (operation === 'signOut') {
-                    try {
-                        await fetch(`${(0, WhatsAppApiHelper_1.getServerUrl)(cfg)}/signout`, { method: 'POST' });
-                    }
-                    catch { }
-                    // Delete session files
+                    await (0, WhatsAppApiHelper_1.stopServer)(cfg);
                     const resolvedPath = expandHome(cfg.sessionPath);
                     if (node_fs_1.default.existsSync(resolvedPath)) {
-                        const files = node_fs_1.default.readdirSync(resolvedPath);
-                        for (const file of files) {
-                            node_fs_1.default.unlinkSync(node_path_1.default.join(resolvedPath, file));
-                        }
+                        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({

package/package.json

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