@remotelinker/reverse-ws-tunnel 1.0.8 → 1.0.9

package/README.md

@@ -30,6 +30,20 @@ Reverse WebSocket Tunnel is a library that enables you to expose local services
 
 ---
 
+## ✨ v1.0.9 - What's New
+
+### 🐛 Bug Fixes
+- **Message Format Standardization**: Fixed inconsistent message formats between server components
+- **Ping/Pong Reliability**: Resolved issues with application-level heartbeat failing during data transfer
+- **Connection Stability**: Improved connection handling and reduced timeout issues
+
+### 🔧 Technical Improvements
+- **Unified Message Protocol**: All server messages now use consistent `buildMessageBuffer` format
+- **Simplified Client Architecture**: Removed hybrid parsing logic for better maintainability
+- **Enhanced Buffer Management**: Improved message buffering and parsing reliability
+
+---
+
 ## 📦 Installation
 
 ```bash

package/client/tunnelClient.js

@@ -19,7 +19,7 @@ const HEALTH_TIMEOUT = 45 * 1000; // 45 secondi sliding window
 const RECONNECT_BACKOFF = [1000, 2000, 5000, 10000, 30000]; // Backoff progressivo
 
 /**
- * Starts the WebSocket tunnel client.
+ * Starts WebSocket tunnel client.
  * @param {Object} config - Configuration for tunnel.
  */
 function connectWebSocket(config) {
@@ -80,13 +80,16 @@ function connectWebSocket(config) {
 
     let messageBuffer = Buffer.alloc(0);
     
-    ws.on('message', (chunk) => {
-      logger.trace(`Received message chunk: ${chunk.length} bytes`);
-      messageBuffer = Buffer.concat([messageBuffer, chunk]);
+    ws.on('message', (data) => {
+      logger.trace(`Received message chunk: ${data.length} bytes`);
+      messageBuffer = Buffer.concat([messageBuffer, data]);
 
       while (messageBuffer.length >= 4) {
         const length = messageBuffer.readUInt32BE(0);
-        if (messageBuffer.length < 4 + length) break;
+        if (messageBuffer.length < 4 + length) {
+          logger.trace(`Waiting for more data: need ${4 + length} bytes, have ${messageBuffer.length}`);
+          break;
+        }
 
         const message = messageBuffer.slice(4, 4 + length);
         messageBuffer = messageBuffer.slice(4 + length);
@@ -98,32 +101,40 @@ function connectWebSocket(config) {
 
         logger.trace(`Received WS message for uuid=${uuid}, type=${type}, length=${payload.length}`);
 
-      if (type === MESSAGE_TYPE_DATA) {
-        if (payload.toString() === 'CLOSE') {
-          logger.debug(`Received CLOSE for uuid=${uuid}`);
-          if (clients[uuid]) {
-            clients[uuid].end();
+        if (type === MESSAGE_TYPE_DATA) {
+          if (payload.toString() === 'CLOSE') {
+            logger.debug(`Received CLOSE for uuid=${uuid}`);
+            if (clients[uuid]) {
+              clients[uuid].end();
+            }
+            return;
+          }
+
+          const client = clients[uuid] || createTcpClient(targetUrl, targetPort, ws, tunnelId, uuid);
+
+          if (!client.write(payload)) {
+            logger.debug(`Backpressure on TCP socket for uuid=${uuid}`);
+            client.once('drain', () => {
+              logger.info(`TCP socket drained for uuid=${uuid}`);
+            });
           }
           return;
-        }
 
-        const client = clients[uuid] || createTcpClient(targetUrl, targetPort, ws, tunnelId, uuid);
-
-      } else if (type === MESSAGE_TYPE_APP_PONG) {
-        try {
-          const pongData = JSON.parse(payload.toString());
-          // Accetta solo pong con seq >= pingSeq - 10 (finestra di 10 ping)
-          if (pongData.seq >= (pingSeq - 10)) {
-            lastPongTs = Date.now();
-            logger.trace(`App pong received: seq=${pongData.seq}`);
-          } else {
-            logger.debug(`Ignoring old pong: seq=${pongData.seq}`);
+        } else if (type === MESSAGE_TYPE_APP_PONG) {
+          try {
+            const pongData = JSON.parse(payload.toString());
+            // Accetta solo pong con seq >= pingSeq - 10 (finestra di 10 ping)
+            if (pongData.seq >= (pingSeq - 10)) {
+              lastPongTs = Date.now();
+              logger.trace(`App pong received: seq=${pongData.seq}`);
+            } else {
+              logger.debug(`Ignoring old pong: seq=${pongData.seq}`);
+            }
+          } catch (err) {
+            logger.error(`Invalid app pong format: ${err.message}`);
           }
-        } catch (err) {
-          logger.error(`Invalid app pong format: ${err.message}`);
+          return;
         }
-        return;
-      }
       }
     });
 
@@ -193,7 +204,7 @@ function heartBeat(ws) {
 }
 
 /**
- * Creates a TCP connection to the target service.
+ * Creates a TCP connection to target service.
  */
 function createTcpClient(targetUrl, targetPort, ws, tunnelId, uuid) {
   const hostname = new URL(targetUrl).hostname;
@@ -271,4 +282,4 @@ function resetClients() { // for testing
 module.exports = {
   connectWebSocket,
   resetClients, // for testing
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotelinker/reverse-ws-tunnel",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "A Node.js library for creating secure reverse tunnels over WebSocket connections",
   "main": "index.cjs",
   "types": "types/index.d.ts",

package/server/tcpServer.js

@@ -5,6 +5,7 @@ const { HTTPParser, methods } = require('http-parser-js');
 const state = require('./state');
 const { MESSAGE_TYPE_DATA } = require('./constants');
 const { logger } = require('../utils/logger');
+const { buildMessageBuffer } = require('../client/utils');
 
 function startTCPServer(port, tunnelIdHeaderName, websocketPort) {
   const wsPortKey = String(websocketPort);
@@ -60,7 +61,8 @@ function startTCPServer(port, tunnelIdHeaderName, websocketPort) {
         isWebSocket = headers['upgrade']?.toLowerCase() === 'websocket';
 
         logger.trace(`Sending initial headers (${rawHeaders.length} bytes) to tunnel [${currentTunnelId}]`);
-        tunnel.ws.send(Buffer.concat([uuidBuffer, Buffer.from([MESSAGE_TYPE_DATA]), Buffer.from(rawHeaders)]));
+        const message = buildMessageBuffer(currentTunnelId, uuid, MESSAGE_TYPE_DATA, rawHeaders);
+        tunnel.ws.send(message);
 
         if (isWebSocket) parser.close();
       };
@@ -70,7 +72,8 @@ function startTCPServer(port, tunnelIdHeaderName, websocketPort) {
         if (tunnel?.ws && !isWebSocket) {
           const body = chunk.slice(offset, offset + length);
           logger.trace(`Forwarding body (${body.length} bytes) to tunnel [${currentTunnelId}]`);
-          tunnel.ws.send(Buffer.concat([uuidBuffer, Buffer.from([MESSAGE_TYPE_DATA]), body]));
+          const message = buildMessageBuffer(currentTunnelId, uuid, MESSAGE_TYPE_DATA, body);
+          tunnel.ws.send(message);
         }
       };
 
@@ -91,7 +94,8 @@ function startTCPServer(port, tunnelIdHeaderName, websocketPort) {
       if (isWebSocket) {
         if (tunnel?.ws) {
           logger.trace(`Forwarding WebSocket TCP data (${chunk.length} bytes) for tunnel [${currentTunnelId}]`);
-          tunnel.ws.send(Buffer.concat([uuidBuffer, Buffer.from([MESSAGE_TYPE_DATA]), chunk]));
+          const message = buildMessageBuffer(currentTunnelId, uuid, MESSAGE_TYPE_DATA, chunk);
+          tunnel.ws.send(message);
         }
       } else {
         try {
@@ -107,7 +111,8 @@ function startTCPServer(port, tunnelIdHeaderName, websocketPort) {
       const tunnel = state[wsPortKey]?.websocketTunnels?.[currentTunnelId];
       if (tunnel?.ws) {
         logger.debug(`TCP socket end for tunnel [${currentTunnelId}] (uuid: ${uuid})`);
-        tunnel.ws.send(Buffer.concat([uuidBuffer, Buffer.from([MESSAGE_TYPE_DATA]), Buffer.from('CLOSE')]));
+        const message = buildMessageBuffer(currentTunnelId, uuid, MESSAGE_TYPE_DATA, 'CLOSE');
+        tunnel.ws.send(message);
       }
     });