@remotelinker/reverse-ws-tunnel 1.0.8 → 1.0.10

package/README.md

@@ -30,6 +30,30 @@ Reverse WebSocket Tunnel is a library that enables you to expose local services
 
 ---
 
+## ✨ v1.0.10 - What's New
+
+### 🔧 Code Quality & Developer Experience
+- **Code Cleanup**: Removed unused constants and redundant variables
+- **Input Validation**: Added tunnelId validation for incoming messages
+- **Code Formatting**: Added Prettier configuration for consistent code style
+- **Test Suite**: Reorganized tests, removed obsolete files, added new test coverage
+
+---
+
+## ✨ v1.0.9 - Previous Release
+
+### 🐛 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/index.js

@@ -2,7 +2,17 @@ const { startHttpProxyServer } = require('./proxyServer');
 const { connectWebSocket } = require('./tunnelClient');
 const { setLogContext } = require('../utils/logger');
 
-function startClient({ targetUrl, allowInsicureCerts, wsUrl, tunnelId, tunnelEntryUrl, tunnelEntryPort, headers, environment, autoReconnect }) {
+function startClient({
+  targetUrl,
+  allowInsicureCerts,
+  wsUrl,
+  tunnelId,
+  tunnelEntryUrl,
+  tunnelEntryPort,
+  headers,
+  environment,
+  autoReconnect,
+}) {
   setLogContext('CLIENT');
   environment = environment || 'production';
   const proxy = startHttpProxyServer(targetUrl, allowInsicureCerts);

package/client/index.mjs

@@ -1,2 +1,2 @@
 import cjsModule from './index.js';
-export const { startClient } = cjsModule;
+export const { startClient } = cjsModule;

package/client/proxyServer.js

@@ -24,23 +24,34 @@ function startHttpProxyServer(targetUrl, allowInsecureCerts = false) {
       return res.end('Missing TARGET_URL');
     }
 
-    proxy.web(req, res, { target: targetUrl, changeOrigin: true, secure: !allowInsecureCerts }, (err) => {
-      logger.error('Proxy web error:', err);
-      if (!res.headersSent) {
-        res.writeHead(502);
-        res.end('Bad gateway');
-      } else {
-        res.end();
+    proxy.web(
+      req,
+      res,
+      { target: targetUrl, changeOrigin: true, secure: !allowInsecureCerts },
+      err => {
+        logger.error('Proxy web error:', err);
+        if (!res.headersSent) {
+          res.writeHead(502);
+          res.end('Bad gateway');
+        } else {
+          res.end();
+        }
       }
-    });
+    );
   });
 
   server.on('upgrade', (req, socket, head) => {
     logger.trace(`Incoming WebSocket upgrade: ${req.url}`);
-    proxy.ws(req, socket, head, { target: targetUrl, changeOrigin: false, secure: !allowInsecureCerts }, (err) => {
-      logger.error('Proxy WS upgrade error:', err);
-      socket.end();
-    });
+    proxy.ws(
+      req,
+      socket,
+      head,
+      { target: targetUrl, changeOrigin: false, secure: !allowInsecureCerts },
+      err => {
+        logger.error('Proxy WS upgrade error:', err);
+        socket.end();
+      }
+    );
   });
 
   proxy.on('error', (err, req, res) => {

package/client/tunnelClient.js

@@ -6,7 +6,6 @@ const { buildMessageBuffer } = require('./utils');
 const { logger } = require('../utils/logger');
 const packageJson = require('../package.json');
 
-const RECONNECT_INTERVAL = 5000;
 const MESSAGE_TYPE_CONFIG = 0x01;
 const MESSAGE_TYPE_DATA = 0x02;
 const MESSAGE_TYPE_APP_PING = 0x03;
@@ -19,11 +18,21 @@ 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) {
-  const { wsUrl, tunnelId, targetUrl, targetPort, tunnelEntryUrl, tunnelEntryPort, headers, environment, autoReconnect = true } = config;
+  const {
+    wsUrl,
+    tunnelId,
+    targetUrl,
+    targetPort,
+    tunnelEntryUrl,
+    tunnelEntryPort,
+    headers,
+    environment,
+    autoReconnect = true,
+  } = config;
 
   const eventEmitter = new EventEmitter();
   let ws;
@@ -32,8 +41,6 @@ function connectWebSocket(config) {
   let healthMonitor;
   let isClosed = false;
   let reconnectAttempt = 0;
-  let pingSeq = 0;
-  let lastPongTs = Date.now();
 
   if (!tunnelId) {
     throw new Error(`Missing mandatory tunnelId`);
@@ -43,25 +50,59 @@ function connectWebSocket(config) {
     if (isClosed) return;
 
     try {
-      const headersParsed = headers || '{}';
+      // Parse headers - handle both string and object formats
+      let headersParsed = {};
+      if (headers) {
+        if (typeof headers === 'string') {
+          try {
+            headersParsed = JSON.parse(headers);
+          } catch (e) {
+            logger.warn(`Failed to parse headers string: ${headers}`);
+          }
+        } else if (typeof headers === 'object') {
+          headersParsed = headers;
+        }
+      }
       logger.debug(`Parsed headers: ${JSON.stringify(headersParsed)}`);
       logger.debug(`Try to connect to: ${wsUrl}`);
       ws = new WebSocket(wsUrl, { headers: headersParsed });
       logger.debug(`Connection: ${wsUrl}`);
     } catch (error) {
-      logger.error('Malformed headers:', error);
+      logger.error('Failed to create WebSocket connection:', error);
       return;
     }
 
+    // PingState condiviso tra heartbeat e message handler
+    // Reset completo dello stato per ogni connessione
+    const pingState = {
+      pingSeq: 0,
+      lastPongTs: Date.now(),
+    };
+    const pingStateCallbacks = {
+      pingSeq: () => pingState.pingSeq,
+      incPingSeq: () => pingState.pingSeq++,
+      lastPongTs: () => pingState.lastPongTs,
+      setLastPongTs: ts => (pingState.lastPongTs = ts),
+    };
+
     ws.on('open', () => {
       logger.info(`Connected to WebSocket server ${wsUrl}`);
-      logger.warn(`WS tunnel config sent: TARGET_PORT=${targetPort}, ENTRY_PORT=${tunnelEntryPort}`);
+      logger.warn(
+        `WS tunnel config sent: TARGET_PORT=${targetPort}, ENTRY_PORT=${tunnelEntryPort}`
+      );
+
+      // Reset reconnect attempt on successful connection
+      reconnectAttempt = 0;
+
       eventEmitter.emit('connected');
       ({ pingInterval } = heartBeat(ws));
 
       // Avviare heartbeat applicativo
-      appPingInterval = startAppHeartbeat(ws, tunnelId, { pingSeq: () => pingSeq, incPingSeq: () => pingSeq++ });
-      healthMonitor = startHealthMonitor(ws, tunnelId, { lastPongTs: () => lastPongTs, setLastPongTs: (ts) => lastPongTs = ts });
+      appPingInterval = startAppHeartbeat(ws, tunnelId, pingStateCallbacks);
+      healthMonitor = startHealthMonitor(ws, tunnelId, {
+        lastPongTs: () => pingState.lastPongTs,
+        setLastPongTs: ts => (pingState.lastPongTs = ts),
+      });
 
       const uuid = uuidv4();
       const payload = {
@@ -73,57 +114,86 @@ function connectWebSocket(config) {
         agentVersion: packageJson.version,
       };
 
-      const message = buildMessageBuffer(tunnelId, uuid, MESSAGE_TYPE_CONFIG, JSON.stringify(payload));
+      const message = buildMessageBuffer(
+        tunnelId,
+        uuid,
+        MESSAGE_TYPE_CONFIG,
+        JSON.stringify(payload)
+      );
       logger.debug(`Sending tunnel config [uuid=${uuid}]`);
       ws.send(message);
     });
 
     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);
 
-        const messageTunnelId = message.slice(0, 36).toString();
+        const messageTunnelId = message.slice(0, 36).toString().trim();
         const uuid = message.slice(36, 72).toString();
         const type = message.readUInt8(72);
         const payload = message.slice(73);
 
-        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();
-          }
+        // Validate tunnelId matches expected tunnel
+        if (messageTunnelId !== tunnelId) {
+          logger.warn(
+            `Received message for wrong tunnel: ${messageTunnelId} (expected: ${tunnelId})`
+          );
           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}`);
+        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();
+            }
+            return;
           }
-        } catch (err) {
-          logger.error(`Invalid app pong format: ${err.message}`);
+
+          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;
+        } 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 >= pingStateCallbacks.pingSeq() - 10) {
+              // Aggiorna lastPongTs usando il callback
+              pingStateCallbacks.setLastPongTs(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}`);
+          }
+          return;
         }
-        return;
-      }
       }
     });
 
@@ -141,8 +211,12 @@ function connectWebSocket(config) {
         delete clients[uuid];
       }
 
+      // Reset message buffer on close for proper reconnection
+      messageBuffer = Buffer.alloc(0);
+
       if (!isClosed && autoReconnect) {
-        const delay = RECONNECT_BACKOFF[reconnectAttempt] || RECONNECT_BACKOFF[RECONNECT_BACKOFF.length - 1];
+        const delay =
+          RECONNECT_BACKOFF[reconnectAttempt] || RECONNECT_BACKOFF[RECONNECT_BACKOFF.length - 1];
         logger.info(`Reconnecting in ${delay / 1000}s (attempt ${reconnectAttempt + 1})`);
         setTimeout(() => {
           reconnectAttempt = Math.min(reconnectAttempt + 1, RECONNECT_BACKOFF.length);
@@ -151,7 +225,7 @@ function connectWebSocket(config) {
       }
     });
 
-    ws.on('error', (err) => {
+    ws.on('error', err => {
       logger.error('WebSocket error:', err);
     });
   };
@@ -193,7 +267,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;
@@ -206,13 +280,13 @@ function createTcpClient(targetUrl, targetPort, ws, tunnelId, uuid) {
     logger.info(`TCP connection established for uuid=${uuid}`);
   });
 
-  client.on('data', (data) => {
+  client.on('data', data => {
     logger.trace(`TCP data received for uuid=${uuid}, length=${data.length}`);
     const message = buildMessageBuffer(tunnelId, uuid, MESSAGE_TYPE_DATA, data);
     ws.send(message);
   });
 
-  client.on('error', (err) => {
+  client.on('error', err => {
     logger.error(`TCP error for uuid=${uuid}:`, err);
     client.destroy();
     delete clients[uuid];
@@ -237,7 +311,7 @@ function startAppHeartbeat(ws, tunnelId, pingState) {
       const pingData = JSON.stringify({
         type: 'ping',
         seq: currentPingSeq,
-        ts: Date.now()
+        ts: Date.now(),
       });
 
       const message = buildMessageBuffer(tunnelId, uuidv4(), MESSAGE_TYPE_APP_PING, pingData);
@@ -262,7 +336,8 @@ function startHealthMonitor(ws, tunnelId, pongState) {
   }, 5000); // Check every 5 seconds
 }
 
-function resetClients() { // for testing
+function resetClients() {
+  // for testing
   for (const key in clients) {
     delete clients[key];
   }

package/client/utils.js

@@ -12,7 +12,8 @@ function buildMessageBuffer(tunnelId, uuid, type, payload) {
   const typeBuffer = Buffer.from([type]);
   const payloadBuffer = Buffer.isBuffer(payload) ? payload : Buffer.from(payload, 'utf8');
 
-  const totalLength = tunnelBuffer.length + uuidBuffer.length + typeBuffer.length + payloadBuffer.length;
+  const totalLength =
+    tunnelBuffer.length + uuidBuffer.length + typeBuffer.length + payloadBuffer.length;
   const lengthBuffer = Buffer.alloc(4);
   lengthBuffer.writeUInt32BE(totalLength);
 

package/index.cjs

@@ -5,5 +5,5 @@ const utils = require('./utils');
 module.exports = {
   ...server,
   ...client,
-  ...utils
-};
+  ...utils,
+};

package/index.mjs

@@ -1,3 +1,3 @@
 export * from './server/index.mjs';
 export * from './client/index.mjs';
-export * from './utils/index.mjs';
+export * from './utils/index.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotelinker/reverse-ws-tunnel",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "A Node.js library for creating secure reverse tunnels over WebSocket connections",
   "main": "index.cjs",
   "types": "types/index.d.ts",
@@ -41,7 +41,9 @@
     "example:server:esm": "node examples/server/server-example.mjs",
     "example:client": "node examples/client/client-example.js",
     "example:client:esm": "node examples/client/client-example.mjs",
-    "example:webserver": "node examples/webserver/webserver-example.js"
+    "example:webserver": "node examples/webserver/webserver-example.js",
+    "format": "prettier --write \"**/*.js\" \"**/*.mjs\" \"**/*.cjs\"",
+    "format:check": "prettier --check \"**/*.js\" \"**/*.mjs\" \"**/*.cjs\""
   },
   "exports": {
     ".": {
@@ -78,6 +80,7 @@
   },
   "devDependencies": {
     "jest": "^29.7.0",
+    "prettier": "^3.8.1",
     "typescript": "^5.9.3"
   }
 }

package/server/index.mjs

@@ -1,2 +1,2 @@
 import cjsModule from './index.js';
-export const { startWebSocketServer, setLogContext } = cjsModule;
+export const { startWebSocketServer, setLogContext } = cjsModule;

package/server/messageHandler.js

@@ -1,5 +1,10 @@
 const state = require('./state');
-const { MESSAGE_TYPE_CONFIG, MESSAGE_TYPE_DATA, MESSAGE_TYPE_APP_PING, MESSAGE_TYPE_APP_PONG } = require('./constants');
+const {
+  MESSAGE_TYPE_CONFIG,
+  MESSAGE_TYPE_DATA,
+  MESSAGE_TYPE_APP_PING,
+  MESSAGE_TYPE_APP_PONG,
+} = require('./constants');
 const { startTCPServer } = require('./tcpServer');
 const { logger } = require('../utils/logger');
 const { buildMessageBuffer } = require('../client/utils');
@@ -49,7 +54,9 @@ function handleParsedMessage(ws, tunnelId, uuid, type, payload, tunnelIdHeaderNa
 
       const portKey = String(TUNNEL_ENTRY_PORT);
       if (!state[port][portKey]) {
-        logger.info(`Starting new TCP server on port ${TUNNEL_ENTRY_PORT} for tunnelId=${tunnelId}`);
+        logger.info(
+          `Starting new TCP server on port ${TUNNEL_ENTRY_PORT} for tunnelId=${tunnelId}`
+        );
         state[port][portKey] = {};
         state[port][portKey] = {
           tcpServer: startTCPServer(TUNNEL_ENTRY_PORT, tunnelIdHeaderName, port),
@@ -60,7 +67,9 @@ function handleParsedMessage(ws, tunnelId, uuid, type, payload, tunnelIdHeaderNa
 
       logger.info(`Tunnel [${tunnelId}] established successfully`);
     } catch (error) {
-      logger.error(`Failed to process MESSAGE_TYPE_CONFIG for tunnelId=${tunnelId}: ${error.message}`);
+      logger.error(
+        `Failed to process MESSAGE_TYPE_CONFIG for tunnelId=${tunnelId}: ${error.message}`
+      );
     }
 
     return;
@@ -72,7 +81,7 @@ function handleParsedMessage(ws, tunnelId, uuid, type, payload, tunnelIdHeaderNa
       const pingData = JSON.parse(payload.toString());
       const pongData = JSON.stringify({
         type: 'pong',
-        seq: pingData.seq
+        seq: pingData.seq,
       });
 
       const pongMessage = buildMessageBuffer(tunnelId, uuid, MESSAGE_TYPE_APP_PONG, pongData);

package/server/tcpServer.js

@@ -5,12 +5,13 @@ 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);
   const tcpPortKey = String(port);
 
-  const server = net.createServer((socket) => {
+  const server = net.createServer(socket => {
     const uuid = uuidv4();
     const uuidBuffer = Buffer.from(uuid);
     let currentTunnelId = null;
@@ -21,7 +22,7 @@ function startTCPServer(port, tunnelIdHeaderName, websocketPort) {
     function createParser() {
       const parser = new HTTPParser(HTTPParser.REQUEST);
 
-      parser[HTTPParser.kOnHeadersComplete] = (info) => {
+      parser[HTTPParser.kOnHeadersComplete] = info => {
         const headers = info.headers.reduce((acc, val, i, arr) => {
           if (i % 2 === 0) acc[val.toLowerCase()] = arr[i + 1];
           return acc;
@@ -59,8 +60,11 @@ 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)]));
+        logger.trace(
+          `Sending initial headers (${rawHeaders.length} bytes) to tunnel [${currentTunnelId}]`
+        );
+        const message = buildMessageBuffer(currentTunnelId, uuid, MESSAGE_TYPE_DATA, rawHeaders);
+        tunnel.ws.send(message);
 
         if (isWebSocket) parser.close();
       };
@@ -70,7 +74,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);
         }
       };
 
@@ -86,12 +91,15 @@ function startTCPServer(port, tunnelIdHeaderName, websocketPort) {
 
     let currentParser = createParser();
 
-    socket.on('data', (chunk) => {
+    socket.on('data', chunk => {
       const tunnel = state[wsPortKey]?.websocketTunnels?.[currentTunnelId];
       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]));
+          logger.trace(
+            `Forwarding WebSocket TCP data (${chunk.length} bytes) for tunnel [${currentTunnelId}]`
+          );
+          const message = buildMessageBuffer(currentTunnelId, uuid, MESSAGE_TYPE_DATA, chunk);
+          tunnel.ws.send(message);
         }
       } else {
         try {
@@ -107,16 +115,20 @@ 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);
       }
     });
 
     socket.on('close', () => {
-      const deleted = delete state[wsPortKey]?.websocketTunnels?.[currentTunnelId]?.tcpConnections?.[uuid];
-      logger.debug(`TCP socket closed [${uuid}] for tunnel [${currentTunnelId}], connection ${deleted ? 'removed' : 'not found'}`);
+      const deleted =
+        delete state[wsPortKey]?.websocketTunnels?.[currentTunnelId]?.tcpConnections?.[uuid];
+      logger.debug(
+        `TCP socket closed [${uuid}] for tunnel [${currentTunnelId}], connection ${deleted ? 'removed' : 'not found'}`
+      );
     });
 
-    socket.on('error', (err) => {
+    socket.on('error', err => {
       logger.error(`Socket error on tunnel [${currentTunnelId}], uuid [${uuid}]:`, err);
       delete state[wsPortKey]?.websocketTunnels?.[currentTunnelId]?.tcpConnections?.[uuid];
     });
@@ -129,7 +141,7 @@ function startTCPServer(port, tunnelIdHeaderName, websocketPort) {
     logger.info(`TCP server listening on port ${port} for websocketPort ${websocketPort}`);
   });
 
-  server.on('error', (err) => {
+  server.on('error', err => {
     logger.error(`TCP server error on port ${port}:`, err);
   });
 }

package/server/websocketServer.js

@@ -22,7 +22,9 @@ function startWebSocketServer({ port, host, path, tunnelIdHeaderName }) {
   state[portKey].webSocketServer = new WebSocket.Server({ port, host, path });
 
   state[portKey].webSocketServer.on('listening', () => {
-    logger.info(`WebSocket server listening on port ${port}${host ? ` (host: ${host})` : ''}${path ? `, path: ${path}` : ''}`);
+    logger.info(
+      `WebSocket server listening on port ${port}${host ? ` (host: ${host})` : ''}${path ? `, path: ${path}` : ''}`
+    );
   });
 
   state[portKey].webSocketServer.on('connection', (ws, req) => {
@@ -41,7 +43,9 @@ function startWebSocketServer({ port, host, path, tunnelIdHeaderName }) {
 
     const interval = setInterval(() => {
       if (!ws.isAlive) {
-        logger.warn(`No pong received from client on tunnel [${tunnelId || 'unknown'}], terminating.`);
+        logger.warn(
+          `No pong received from client on tunnel [${tunnelId || 'unknown'}], terminating.`
+        );
         return ws.terminate();
       }
       ws.isAlive = false;
@@ -51,7 +55,7 @@ function startWebSocketServer({ port, host, path, tunnelIdHeaderName }) {
       }
     }, PING_INTERVAL);
 
-    ws.on('message', (chunk) => {
+    ws.on('message', chunk => {
       logger.trace(`Received message chunk: ${chunk.length} bytes`);
       buffer = Buffer.concat([buffer, chunk]);
 
@@ -67,15 +71,22 @@ function startWebSocketServer({ port, host, path, tunnelIdHeaderName }) {
         const type = message.readUInt8(72);
         const payload = message.slice(73);
 
-        logger.trace(`Parsed message - tunnelId: ${messageTunnelId}, uuid: ${uuid}, type: ${type}, payload length: ${payload.length}`);
+        logger.trace(
+          `Parsed message - tunnelId: ${messageTunnelId}, uuid: ${uuid}, type: ${type}, payload length: ${payload.length}`
+        );
 
         // Check for duplicate tunnelId on first message (when tunnelId is not yet set)
         if (!tunnelId && messageTunnelId) {
           const existingTunnel = state[portKey]?.websocketTunnels?.[messageTunnelId];
           if (existingTunnel && existingTunnel.ws && existingTunnel.ws !== ws) {
             // Check if the existing WebSocket is still open
-            if (existingTunnel.ws.readyState === WebSocket.OPEN || existingTunnel.ws.readyState === WebSocket.CONNECTING) {
-              logger.error(`Tunnel [${messageTunnelId}] already exists with an active connection. Rejecting new connection.`);
+            if (
+              existingTunnel.ws.readyState === WebSocket.OPEN ||
+              existingTunnel.ws.readyState === WebSocket.CONNECTING
+            ) {
+              logger.error(
+                `Tunnel [${messageTunnelId}] already exists with an active connection. Rejecting new connection.`
+              );
 
               // Assign tunnelId before closing so cleanup logs the correct value
               tunnelId = messageTunnelId;
@@ -84,7 +95,9 @@ function startWebSocketServer({ port, host, path, tunnelIdHeaderName }) {
               ws.close(1008, `Duplicate tunnelId: ${messageTunnelId}`);
               return;
             } else {
-              logger.info(`Existing tunnel [${messageTunnelId}] has a closed connection. Allowing new connection.`);
+              logger.info(
+                `Existing tunnel [${messageTunnelId}] has a closed connection. Allowing new connection.`
+              );
             }
           }
           tunnelId = messageTunnelId;
@@ -104,7 +117,9 @@ function startWebSocketServer({ port, host, path, tunnelIdHeaderName }) {
           delete state[portKey].websocketTunnels[tunnelId];
           logger.debug(`Removed tunnel [${tunnelId}] from state`);
         } else {
-          logger.debug(`Tunnel [${tunnelId}] not removed - this was a duplicate/rejected connection`);
+          logger.debug(
+            `Tunnel [${tunnelId}] not removed - this was a duplicate/rejected connection`
+          );
         }
       } else {
         logger.debug(`No tunnelId assigned yet, nothing to remove from state`);
@@ -126,13 +141,13 @@ function startWebSocketServer({ port, host, path, tunnelIdHeaderName }) {
       cleanup('close');
     });
 
-    ws.on('error', (err) => {
+    ws.on('error', err => {
       logger.error(`WebSocket error on tunnel [${tunnelId || 'unknown'}]:`, err);
       cleanup('error');
     });
   });
 
-  state[portKey].webSocketServer.on('error', (err) => {
+  state[portKey].webSocketServer.on('error', err => {
     logger.error('WebSocket server error:', err);
   });
 

package/utils/index.mjs

@@ -1,2 +1,2 @@
 import cjsModule from './index.js';
-export const { setLogLevel, getLogLevel, loadConfig } = cjsModule;
+export const { setLogLevel, getLogLevel, loadConfig } = cjsModule;

package/utils/loadConfig.js

@@ -7,7 +7,9 @@ const TOML = require('@iarna/toml');
 
 function loadConfig(customPath) {
   const callerDir = require.main?.path || process.cwd();
-  const configPath = customPath ? path.join(customPath, FILE_CONFIG_NAME) : path.join(callerDir, FILE_CONFIG_NAME);
+  const configPath = customPath
+    ? path.join(customPath, FILE_CONFIG_NAME)
+    : path.join(callerDir, FILE_CONFIG_NAME);
 
   console.log({ configPath });
 
@@ -25,7 +27,9 @@ function loadConfig(customPath) {
       logger.warn(`⚠️ Failed to parse config.toml at ${configPath}: ${err.message}`);
     }
   } else {
-    logger.info(`ℹ️ No config.toml found at: ${configPath}, falling back to environment variables.`);
+    logger.info(
+      `ℹ️ No config.toml found at: ${configPath}, falling back to environment variables.`
+    );
   }
 
   const envConfig = {
@@ -33,7 +37,9 @@ function loadConfig(customPath) {
     wsUrl: process.env.WS_URL,
     targetUrl: process.env.TARGET_URL,
     tunnelEntryUrl: process.env.TUNNEL_ENTRY_URL,
-    tunnelEntryPort: process.env.TUNNEL_ENTRY_PORT ? Number(process.env.TUNNEL_ENTRY_PORT) : undefined,
+    tunnelEntryPort: process.env.TUNNEL_ENTRY_PORT
+      ? Number(process.env.TUNNEL_ENTRY_PORT)
+      : undefined,
     headers: process.env.HEADERS,
     allowInsicureCerts: process.env.ALLOW_INSICURE_CERTS === 'true',
     logLevel: process.env.LOG_LEVEL || 'info',

package/utils/logger.js

@@ -34,12 +34,12 @@ const logger = winston.createLogger({
     new winston.transports.Console({
       format: winston.format.combine(
         winston.format.timestamp(),
-        winston.format.printf((info) => {
+        winston.format.printf(info => {
           const contextPrefix = logContext ? `${logContext} | ` : '';
           // Get the raw level (before colorization)
           const rawLevel = info[Symbol.for('level')] || info.level || 'info';
           // Apply color to level and message separately
-           const colorizer = winston.format.colorize({ colors: customLevels.colors });
+          const colorizer = winston.format.colorize({ colors: customLevels.colors });
           const coloredLevel = colorizer.colorize(rawLevel, rawLevel);
           const coloredMessage = colorizer.colorize(rawLevel, `${contextPrefix}${info.message}`);
           return `[${info.timestamp}] ${coloredLevel}: ${coloredMessage}`;