@yousolution/node-red-contrib-you-tunnel-websocket 1.1.2 → 1.2.0

package/nodes/wsTunnel.js

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  **/
-const { startWebSocketServer, stopWebSocketServer } = require('@remotelinker/reverse-ws-tunnel/server');
-const { logger, setLogContext, setLogLevel } = require('@remotelinker/reverse-ws-tunnel/utils');
+const { startWebSocketServer, stopWebSocketServer, sendCommand } = require('@remotelinker/reverse-ws-tunnel/server');
+const { logger, setLogContext, setLogLevel, getMetrics } = require('@remotelinker/reverse-ws-tunnel/utils');
 
 const instances = {};
 
@@ -49,10 +49,12 @@ module.exports = function (RED) {
 
     node.status({ fill: 'red', shape: 'ring', text: 'disconnected' });
     const port = node.tunnelConfig.options.port;
-    const host = node.tunnelConfig.options.host ? '' : undefined;
-    const path = node.tunnelConfig.options.path ? '' : undefined;
+    const host = node.tunnelConfig.options.host || undefined;
+    const path = node.tunnelConfig.options.path || undefined;
     const tunnelIdHeaderName = node.tunnelConfig.options.tunnelIdHeaderName;
     instances[id] = instances[id] || {};
+    const pendingConnections = new Map();
+    const confirmedConnections = new Map();
     // Cleanup any existing server on this port before starting
     // This handles cases where previous deployment didn't cleanup properly
     stopWebSocketServer(port)
@@ -101,7 +103,45 @@ module.exports = function (RED) {
         });
         logger.info(`WebSocket connection from ${clientAddress}:${clientPort}`);
         logger.info(`Total connected clients: ${totalClients}`);
+
+        const connectedAt = Date.now();
+        pendingConnections.set(ws, { remoteAddress: clientAddress, connectedAt });
+
+        const onFirstMessage = () => {
+          ws.removeListener('message', onFirstMessage);
+          setImmediate(() => {
+            const tunnels =
+              instances[id]?.state?.[port]?.websocketTunnels || {};
+            for (const [tunnelId, tunnel] of Object.entries(tunnels)) {
+              if (tunnel.ws === ws) {
+                const pending = pendingConnections.get(ws);
+                if (pending) {
+                  pendingConnections.delete(ws);
+                  confirmedConnections.set(ws, {
+                    tunnelId,
+                    remoteAddress: pending.remoteAddress,
+                    connectedAt: pending.connectedAt,
+                  });
+                  node.send({
+                    event: 'connect',
+                    tunnelId,
+                    remoteAddress: pending.remoteAddress,
+                    connectedAt: pending.connectedAt,
+                    serverPort: port,
+                  });
+                }
+                return;
+              }
+            }
+          });
+        };
+        ws.on('message', onFirstMessage);
+
         ws.on('close', () => {
+          const confirmed = confirmedConnections.get(ws);
+          confirmedConnections.delete(ws);
+          pendingConnections.delete(ws);
+
           const remainingClients = server.clients.size;
           node.status({
             fill: 'green',
@@ -110,11 +150,31 @@ module.exports = function (RED) {
           });
           logger.info(`Client disconnected: ${clientAddress}:${clientPort}`);
           logger.info(`Remaining clients: ${remainingClients}`);
+
+          if (confirmed) {
+            node.send({
+              event: 'disconnect',
+              tunnelId: confirmed.tunnelId,
+              remoteAddress: confirmed.remoteAddress,
+              serverPort: port,
+            });
+          }
         });
       });
     }
+
+    node.on('input', function (msg) {
+      const snapshot = getMetrics().snapshot();
+      msg.payload = snapshot;
+      msg.event = 'metrics';
+      msg.serverPort = port;
+      node.send(msg);
+    });
+
     this.on('close', function (removed, done) {
-      logger.info(`[DEBUG] Close called for node ${id}, removed=${removed}`);
+      logger.debug(`Close called for node ${id}, removed=${removed}`);
+      pendingConnections.clear();
+      confirmedConnections.clear();
 
       if (instances[id] && instances[id].state && instances[id].state[port]) {
         stopWebSocketServer(port)
@@ -124,7 +184,7 @@ module.exports = function (RED) {
             done();
           })
           .catch((err) => {
-            console.error(`Error stopping server on port ${port}:`, err);
+            logger.error(`Error stopping server on port ${port}:`, err);
             delete instances[id];
             done();
           });
@@ -135,4 +195,37 @@ module.exports = function (RED) {
     });
   }
   RED.nodes.registerType('wstunnel server', WSTunnelServer);
+
+  function WSTunnelCommand(n) {
+    RED.nodes.createNode(this, n);
+    const node = this;
+    node.tunnelConfig = RED.nodes.getNode(n.wstunnel);
+
+    node.on('input', function (msg) {
+      const port = node.tunnelConfig.options.port;
+      const tunnelId = msg.tunnelId || (msg.payload && msg.payload.tunnelId);
+      const command = msg.command || (msg.payload && msg.payload.command);
+      const args = msg.args || (msg.payload && msg.payload.args) || {};
+
+      if (!tunnelId || !command) {
+        node.error('Missing tunnelId or command');
+        msg.payload = false;
+        msg.sent = false;
+        msg.error = 'Missing tunnelId or command';
+        node.send([null, msg]);
+        return;
+      }
+
+      const sent = sendCommand(port, tunnelId, command, args);
+      msg.payload = sent;
+      msg.sent = sent;
+      msg.tunnelId = tunnelId;
+      msg.command = command;
+      if (!sent) {
+        msg.error = 'Tunnel not found or not connected';
+      }
+      node.send([sent ? msg : null, sent ? null : msg]);
+    });
+  }
+  RED.nodes.registerType('wstunnel command', WSTunnelCommand);
 };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@yousolution/node-red-contrib-you-tunnel-websocket",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Module to create websockeet tunnel for NODE-RED",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "scripts": {
     "update": "PACKAGE_NAME=$(npm pack) && mv $PACKAGE_NAME ./data && cd data && rm -rf node_modules && npm i $PACKAGE_NAME  && docker-compose restart",
-    "test": "mocha 'test/**/*.spec.js'",
+    "test": "jest --verbose",
     "coverage": "nyc npm run test"
   },
   "keywords": [
@@ -23,15 +23,7 @@
     }
   },
   "dependencies": {
-    "@remotelinker/reverse-ws-tunnel": "^1.0.11",
-    "cookie": "^1.0.2",
-    "cross-conf-env": "^1.3.0",
-    "dotenv": "^17.2.1",
-    "express": "^4.21.2",
-    "http-parser-js": "^0.5.10",
-    "http-proxy": "^1.18.1",
-    "uuid": "^11.1.0",
-    "ws": "^8.18.0"
+    "@remotelinker/reverse-ws-tunnel": "^1.2.0"
   },
   "repository": {
     "type": "git",

package/test/ki-001-host-path-passthrough.test.js

@@ -0,0 +1,187 @@
+/**
+ * KI-001 — Inverted host/path Default Logic (Regression Test)
+ *
+ * This test proves that configured host and path values are discarded
+ * by the current ternary logic in WSTunnelServer.
+ *
+ * Expected behavior after fix:
+ *   - host: '0.0.0.0' is passed through to startWebSocketServer
+ *   - path: '/api/tunnel' is passed through to startWebSocketServer
+ *
+ * Current (defective) behavior:
+ *   - host: '0.0.0.0' becomes ''
+ *   - path: '/api/tunnel' becomes ''
+ */
+
+const path = require('path');
+
+const WS_TUNNEL_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+// Mock stopWebSocketServer — resolves synchronously to avoid timing issues
+const mockStopWebSocketServer = jest.fn(() => Promise.resolve());
+
+// Mock startWebSocketServer — captures the options passed to it
+const mockStartWebSocketServer = jest.fn((opts) =>
+  Promise.resolve({
+    [opts.port]: {
+      webSocketServer: {
+        on: jest.fn(),
+        clients: new Set(),
+      },
+    },
+  })
+);
+
+// Mock logger
+const mockLogger = {
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  debug: jest.fn(),
+  trace: jest.fn(),
+};
+
+// Mock setLogContext and setLogLevel
+const mockSetLogContext = jest.fn();
+const mockSetLogLevel = jest.fn();
+
+// Creates a mock RED object with configurable getNode return value
+function createMockRED(configOverrides = {}) {
+  const registeredTypes = {};
+  const defaultConfig = {
+    name: 'test-tunnel',
+    host: 'localhost',
+    port: 1880,
+    path: '',
+    tunnelIdHeaderName: 'x-tunnel-id',
+    logLevel: 'info',
+  };
+  return {
+    nodes: {
+      createNode: jest.fn((node, config) => {
+        node.status = jest.fn();
+        node.on = jest.fn((event, handler) => {
+          node._handlers = node._handlers || {};
+          node._handlers[event] = handler;
+        });
+      }),
+      registerType: jest.fn((type, constructor) => {
+        registeredTypes[type] = constructor;
+      }),
+      getNode: jest.fn(() => ({
+        options: { ...defaultConfig, ...configOverrides },
+      })),
+    },
+    _registeredTypes: registeredTypes,
+  };
+}
+
+// Flush the promise chain: stopWebSocketServer().then(startWebSocketServer(...))
+async function flushPromises() {
+  // Advance past setImmediate and all microtasks
+  await new Promise((resolve) => {
+    setImmediate(resolve);
+  });
+  // One more tick to handle the chained .then()
+  await new Promise((resolve) => {
+    setImmediate(resolve);
+  });
+}
+
+describe('KI-001 — host/path value passthrough (regression)', () => {
+  beforeAll(() => {
+    const serverModule = require('@remotelinker/reverse-ws-tunnel/server');
+    serverModule.stopWebSocketServer = mockStopWebSocketServer;
+    serverModule.startWebSocketServer = mockStartWebSocketServer;
+
+    const utilsModule = require('@remotelinker/reverse-ws-tunnel/utils');
+    utilsModule.logger = mockLogger;
+    utilsModule.setLogContext = mockSetLogContext;
+    utilsModule.setLogLevel = mockSetLogLevel;
+  });
+
+  beforeEach(() => {
+    mockStopWebSocketServer.mockClear();
+    mockStartWebSocketServer.mockClear();
+    mockLogger.info.mockClear();
+    mockSetLogContext.mockClear();
+    mockSetLogLevel.mockClear();
+  });
+
+  test('configured host "0.0.0.0" is passed through to startWebSocketServer', async () => {
+    const RED = createMockRED({ host: '0.0.0.0' });
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    const node = {};
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    await flushPromises();
+
+    expect(mockStartWebSocketServer).toHaveBeenCalledTimes(1);
+    const passedOptions = mockStartWebSocketServer.mock.calls[0][0];
+
+    // ASSERTION: host must be '0.0.0.0', not ''
+    // This FAILS with current code because the ternary converts truthy → ''
+    expect(passedOptions.host).toBe('0.0.0.0');
+  });
+
+  test('configured path "/api/tunnel" is passed through to startWebSocketServer', async () => {
+    const RED = createMockRED({ path: '/api/tunnel' });
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    const node = {};
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    await flushPromises();
+
+    expect(mockStartWebSocketServer).toHaveBeenCalledTimes(1);
+    const passedOptions = mockStartWebSocketServer.mock.calls[0][0];
+
+    // ASSERTION: path must be '/api/tunnel', not ''
+    // This FAILS with current code because the ternary converts truthy → ''
+    expect(passedOptions.path).toBe('/api/tunnel');
+  });
+
+  test('empty path becomes undefined (semantically equivalent to unset)', async () => {
+    const RED = createMockRED({ path: '' });
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    const node = {};
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    await flushPromises();
+
+    expect(mockStartWebSocketServer).toHaveBeenCalledTimes(1);
+    const passedOptions = mockStartWebSocketServer.mock.calls[0][0];
+
+    // ASSERTION: empty path should become undefined (ws library default = accept all)
+    // The ws library treats undefined/null the same as falsy for path filtering
+    expect(passedOptions.path).toBeUndefined();
+  });
+
+  test('both host and path are passed through simultaneously', async () => {
+    const RED = createMockRED({ host: '0.0.0.0', path: '/api/tunnel' });
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    const node = {};
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    await flushPromises();
+
+    expect(mockStartWebSocketServer).toHaveBeenCalledTimes(1);
+    const passedOptions = mockStartWebSocketServer.mock.calls[0][0];
+
+    // ASSERTION: both values must be preserved
+    // This FAILS with current code — both become ''
+    expect(passedOptions.host).toBe('0.0.0.0');
+    expect(passedOptions.path).toBe('/api/tunnel');
+  });
+});

package/test/ki-002-tunnel-id-header-default.test.js

@@ -0,0 +1,60 @@
+/**
+ * KI-002 — tunnelIdHeaderName Default Mismatch (Regression Test)
+ *
+ * This test proves that the HTML editor default for tunnelIdHeaderName
+ * ('') does not match the constructor default ('x-tunnel-id').
+ *
+ * Expected behavior after fix:
+ *   - HTML default is 'x-tunnel-id', matching the constructor and documentation.
+ *
+ * Current (defective) behavior:
+ *   - HTML default is '', which is inconsistent.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const HTML_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.html');
+const JS_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+describe('KI-002 — tunnelIdHeaderName default consistency (regression)', () => {
+  let htmlContent;
+  let jsContent;
+
+  beforeAll(() => {
+    htmlContent = fs.readFileSync(HTML_PATH, 'utf8');
+    jsContent = fs.readFileSync(JS_PATH, 'utf8');
+  });
+
+  test('HTML wstunnel registration default for tunnelIdHeaderName is "x-tunnel-id"', () => {
+    const match = htmlContent.match(
+      /tunnelIdHeaderName:\s*\{\s*value:\s*['"]([^'"]*)['"]\s*\}/
+    );
+    expect(match).not.toBeNull();
+
+    // ASSERTION: HTML default must be 'x-tunnel-id'
+    // This FAILS with current code because HTML default is ''
+    expect(match[1]).toBe('x-tunnel-id');
+  });
+
+  test('constructor default for tunnelIdHeaderName is "x-tunnel-id"', () => {
+    const match = jsContent.match(
+      /tunnelIdHeaderName:\s*n\.tunnelIdHeaderName\s*\|\|\s*['"]([^'"]*)['"]/
+    );
+    expect(match).not.toBeNull();
+    expect(match[1]).toBe('x-tunnel-id');
+  });
+
+  test('HTML and constructor defaults for tunnelIdHeaderName are identical', () => {
+    const htmlMatch = htmlContent.match(
+      /tunnelIdHeaderName:\s*\{\s*value:\s*['"]([^'"]*)['"]\s*\}/
+    );
+    const jsMatch = jsContent.match(
+      /tunnelIdHeaderName:\s*n\.tunnelIdHeaderName\s*\|\|\s*['"]([^'"]*)['"]/
+    );
+
+    expect(htmlMatch).not.toBeNull();
+    expect(jsMatch).not.toBeNull();
+    expect(htmlMatch[1]).toBe(jsMatch[1]);
+  });
+});

package/test/ki-003-debug-log-level.test.js

@@ -0,0 +1,180 @@
+/**
+ * KI-003 — Leftover Debug Log Statement (Regression Test)
+ *
+ * This test proves that the close handler logs a [DEBUG] message at info level
+ * instead of using logger.debug() without the [DEBUG] prefix.
+ *
+ * Expected behavior after fix:
+ *   - Close handler logs at debug level (not info)
+ *   - Message does not contain [DEBUG] prefix
+ *
+ * Current (defective) behavior:
+ *   - Close handler logs at info level with [DEBUG] prefix
+ */
+
+const path = require('path');
+
+const WS_TUNNEL_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+// Mock stopWebSocketServer
+const mockStopWebSocketServer = jest.fn(() => Promise.resolve());
+
+// Mock startWebSocketServer
+const mockStartWebSocketServer = jest.fn((opts) =>
+  Promise.resolve({
+    [opts.port]: {
+      webSocketServer: {
+        on: jest.fn(),
+        clients: new Set(),
+      },
+    },
+  })
+);
+
+// Mock logger
+const mockLogger = {
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  debug: jest.fn(),
+  trace: jest.fn(),
+};
+
+// Mock setLogContext and setLogLevel
+const mockSetLogContext = jest.fn();
+const mockSetLogLevel = jest.fn();
+
+// Mock RED object
+function createMockRED() {
+  const registeredTypes = {};
+  return {
+    nodes: {
+      createNode: jest.fn((node, config) => {
+        node.status = jest.fn();
+        node.on = jest.fn((event, handler) => {
+          node._handlers = node._handlers || {};
+          node._handlers[event] = handler;
+        });
+      }),
+      registerType: jest.fn((type, constructor) => {
+        registeredTypes[type] = constructor;
+      }),
+      getNode: jest.fn(() => ({
+        options: {
+          name: 'test-tunnel',
+          host: 'localhost',
+          port: 1880,
+          path: '',
+          tunnelIdHeaderName: 'x-tunnel-id',
+          logLevel: 'info',
+        },
+      })),
+    },
+    _registeredTypes: registeredTypes,
+  };
+}
+
+function createNode(RED) {
+  const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+  const node = {};
+  WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+  return node;
+}
+
+describe('KI-003 — close handler debug log level (regression)', () => {
+  beforeAll(() => {
+    const serverModule = require('@remotelinker/reverse-ws-tunnel/server');
+    serverModule.stopWebSocketServer = mockStopWebSocketServer;
+    serverModule.startWebSocketServer = mockStartWebSocketServer;
+
+    const utilsModule = require('@remotelinker/reverse-ws-tunnel/utils');
+    utilsModule.logger = mockLogger;
+    utilsModule.setLogContext = mockSetLogContext;
+    utilsModule.setLogLevel = mockSetLogLevel;
+  });
+
+  beforeEach(() => {
+    mockStopWebSocketServer.mockClear();
+    mockStartWebSocketServer.mockClear();
+    mockLogger.info.mockClear();
+    mockLogger.debug.mockClear();
+    mockLogger.warn.mockClear();
+    mockLogger.error.mockClear();
+    mockSetLogContext.mockClear();
+    mockSetLogLevel.mockClear();
+  });
+
+  test('close handler does NOT log [DEBUG] at info level', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    // Both mocks are pre-resolved; microtask flush is sufficient
+    await Promise.resolve();
+
+    const node = createNode(RED);
+    const done = jest.fn();
+
+    mockLogger.info.mockClear();
+
+    node._handlers.close.call(node, false, done);
+
+    // Close handler logs synchronously; microtask flush ensures done() path is reached
+    await Promise.resolve();
+
+    // ASSERTION: info must NOT be called with [DEBUG] prefix
+    // This FAILS with current code because line 117 uses logger.info('[DEBUG]...')
+    const infoCalls = mockLogger.info.mock.calls.map((c) => c[0]);
+    expect(infoCalls.some((msg) => msg.includes('[DEBUG]'))).toBe(false);
+  });
+
+  test('close handler logs close message at debug level', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    // Both mocks are pre-resolved; microtask flush is sufficient
+    await Promise.resolve();
+
+    const node = createNode(RED);
+    const done = jest.fn();
+
+    mockLogger.debug.mockClear();
+
+    node._handlers.close.call(node, false, done);
+
+    // Close handler logs synchronously; microtask flush ensures done() path is reached
+    await Promise.resolve();
+
+    // ASSERTION: debug must be called with close message
+    // This FAILS with current code because the message is at info level, not debug
+    const debugCalls = mockLogger.debug.mock.calls.map((c) => c[0]);
+    expect(debugCalls.some((msg) => msg.includes('Close called for node'))).toBe(true);
+  });
+
+  test('close message does not contain [DEBUG] prefix', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    // Both mocks are pre-resolved; microtask flush is sufficient
+    await Promise.resolve();
+
+    const node = createNode(RED);
+    const done = jest.fn();
+
+    mockLogger.debug.mockClear();
+
+    node._handlers.close.call(node, false, done);
+
+    // Close handler logs synchronously; microtask flush ensures done() path is reached
+    await Promise.resolve();
+
+    // ASSERTION: debug message must not contain [DEBUG] prefix
+    const debugCalls = mockLogger.debug.mock.calls.map((c) => c[0]);
+    const closeMsg = debugCalls.find((msg) => msg.includes('Close called for node'));
+    if (closeMsg) {
+      expect(closeMsg).not.toContain('[DEBUG]');
+    }
+  });
+});