@remotelinker/reverse-ws-tunnel 1.0.4

package/server/messageHandler.js

@@ -0,0 +1,79 @@
+const state = require('./state');
+const { MESSAGE_TYPE_CONFIG, MESSAGE_TYPE_DATA } = require('./constants');
+const { startTCPServer } = require('./tcpServer');
+const { logger } = require('../utils/logger');
+
+/**
+ * Handles a parsed WebSocket message.
+ * @param {WebSocket} ws - The WebSocket connection.
+ * @param {string} tunnelId - Tunnel identifier.
+ * @param {string} uuid - Unique identifier for TCP connection.
+ * @param {number} type - Message type (config or data).
+ * @param {Buffer} payload - Data payload.
+ * @param {string} tunnelIdHeaderName - Header name to identify the tunnel.
+ * @param {number} port - Listening port for state grouping.
+ */
+function handleParsedMessage(ws, tunnelId, uuid, type, payload, tunnelIdHeaderName, port) {
+  logger.trace(`handleParsedMessage called. type=${type}, tunnelId=${tunnelId}, uuid=${uuid}`);
+
+  if (type === MESSAGE_TYPE_CONFIG) {
+    try {
+      const config = JSON.parse(payload);
+      logger.debug(`Received tunnel config for tunnelId=${tunnelId}: ${JSON.stringify(config)}`);
+
+      const { TUNNEL_ENTRY_PORT } = config;
+
+      if (!TUNNEL_ENTRY_PORT) {
+        logger.warn(`Tunnel config missing TUNNEL_ENTRY_PORT for tunnelId=${tunnelId}`);
+        throw new Error('Missing tunnel entry port!');
+      }
+
+      logger.debug(`Registering WebSocket tunnel [${tunnelId}] on port ${port}`);
+
+      if (!state[port]) {
+        state[port] = {
+          websocketTunnels: {},
+        };
+      }
+
+      if (!state[port].websocketTunnels) {
+        state[port].websocketTunnels = {};
+      }
+
+      state[port].websocketTunnels[tunnelId] = {
+        ws,
+        tcpConnections: {},
+        httpConnections: {},
+      };
+
+      const portKey = String(TUNNEL_ENTRY_PORT);
+      if (!state[port][portKey]) {
+        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),
+        };
+      } else {
+        logger.debug(`TCP server already exists on port ${TUNNEL_ENTRY_PORT}`);
+      }
+
+      logger.info(`Tunnel [${tunnelId}] established successfully`);
+    } catch (error) {
+      logger.error(`Failed to process MESSAGE_TYPE_CONFIG for tunnelId=${tunnelId}: ${error.message}`);
+    }
+
+    return;
+  }
+
+  // Handle MESSAGE_TYPE_DATA
+  const tunnel = state[port]?.websocketTunnels?.[tunnelId];
+
+  if (tunnel?.tcpConnections?.[uuid]?.socket) {
+    logger.trace(`Forwarding data to TCP socket for uuid=${uuid}, tunnelId=${tunnelId}`);
+    tunnel.tcpConnections[uuid].socket.write(payload);
+  } else {
+    logger.debug(`No TCP connection found for uuid=${uuid}, tunnelId=${tunnelId}`);
+  }
+}
+
+module.exports = { handleParsedMessage };

package/server/state.js

@@ -0,0 +1 @@
+module.exports = {};

package/server/tcpServer.js

@@ -0,0 +1,137 @@
+const net = require('net');
+const cookie = require('cookie');
+const { v4: uuidv4 } = require('uuid');
+const { HTTPParser, methods } = require('http-parser-js');
+const state = require('./state');
+const { MESSAGE_TYPE_DATA } = require('./constants');
+const { logger } = require('../utils/logger');
+
+function startTCPServer(port, tunnelIdHeaderName, websocketPort) {
+  const wsPortKey = String(websocketPort);
+  const tcpPortKey = String(port);
+
+  const server = net.createServer((socket) => {
+    const uuid = uuidv4();
+    const uuidBuffer = Buffer.from(uuid);
+    let currentTunnelId = null;
+    let isWebSocket = false;
+
+    logger.debug(`New TCP connection on port ${port} with uuid ${uuid}`);
+
+    function createParser() {
+      const parser = new HTTPParser(HTTPParser.REQUEST);
+
+      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;
+        }, {});
+
+        const methodName = methods[info.method] || 'UNKNOWN';
+
+        // Tunnel ID via header or cookie
+        if (headers[tunnelIdHeaderName]) {
+          currentTunnelId = headers[tunnelIdHeaderName];
+        } else if (headers['cookie']) {
+          currentTunnelId = cookie.parse(headers['cookie'])[tunnelIdHeaderName];
+        }
+
+        const tunnel = state[wsPortKey]?.websocketTunnels?.[currentTunnelId];
+
+        if (!tunnel?.ws) {
+          logger.warn(`Invalid or missing tunnel ID: ${currentTunnelId}, closing socket.`);
+          socket.destroy();
+          return;
+        }
+
+        if (!tunnel.tcpConnections[uuid]) {
+          tunnel.tcpConnections[uuid] = { socket };
+          logger.debug(`Registered TCP connection [${uuid}] to tunnel [${currentTunnelId}]`);
+        }
+
+        const rawHeaders =
+          `${methodName} ${info.url} HTTP/${info.versionMajor}.${info.versionMinor}\r\n` +
+          info.headers
+            .map((v, i) => (i % 2 === 0 ? `${v}: ${info.headers[i + 1]}` : null))
+            .filter(Boolean)
+            .join('\r\n') +
+          '\r\n\r\n';
+
+        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)]));
+
+        if (isWebSocket) parser.close();
+      };
+
+      parser[HTTPParser.kOnBody] = (chunk, offset, length) => {
+        const tunnel = state[wsPortKey]?.websocketTunnels?.[currentTunnelId];
+        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]));
+        }
+      };
+
+      parser[HTTPParser.kOnMessageComplete] = () => {
+        if (!isWebSocket) {
+          logger.trace(`HTTP message complete for tunnel [${currentTunnelId}]`);
+          currentParser = createParser();
+        }
+      };
+
+      return parser;
+    }
+
+    let currentParser = createParser();
+
+    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]));
+        }
+      } else {
+        try {
+          currentParser.execute(chunk);
+        } catch (err) {
+          logger.error(`HTTP parse error on tunnel [${currentTunnelId}]:`, err);
+          socket.destroy();
+        }
+      }
+    });
+
+    socket.on('end', () => {
+      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')]));
+      }
+    });
+
+    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'}`);
+    });
+
+    socket.on('error', (err) => {
+      logger.error(`Socket error on tunnel [${currentTunnelId}], uuid [${uuid}]:`, err);
+      delete state[wsPortKey]?.websocketTunnels?.[currentTunnelId]?.tcpConnections?.[uuid];
+    });
+  });
+
+  // Store reference
+  state[wsPortKey][tcpPortKey].tcpServer = server;
+
+  server.listen(port, () => {
+    logger.info(`TCP server listening on port ${port} for websocketPort ${websocketPort}`);
+  });
+
+  server.on('error', (err) => {
+    logger.error(`TCP server error on port ${port}:`, err);
+  });
+}
+
+module.exports = { startTCPServer };

package/server/websocketServer.js

@@ -0,0 +1,142 @@
+const WebSocket = require('ws');
+const { Buffer } = require('buffer');
+const state = require('./state');
+const { handleParsedMessage } = require('./messageHandler');
+const { PING_INTERVAL } = require('./constants');
+const { logger } = require('../utils/logger');
+
+/**
+ * Starts the WebSocket tunnel server.
+ * @param {Object} options
+ * @param {number} options.port - Port to listen on.
+ * @param {string} [options.host] - Host address to bind.
+ * @param {string} [options.path] - WebSocket path.
+ * @param {string} options.tunnelIdHeaderName - Header name for identifying the tunnel.
+ */
+function startWebSocketServer({ port, host, path, tunnelIdHeaderName }) {
+  const portKey = String(port);
+
+  state[portKey] = state[portKey] || {};
+  state[portKey].websocketTunnels = state[portKey].websocketTunnels || {};
+
+  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}` : ''}`);
+  });
+
+  state[portKey].webSocketServer.on('connection', (ws, req) => {
+    let tunnelId = null;
+    let buffer = Buffer.alloc(0);
+
+    const clientIp = req.socket.remoteAddress;
+    logger.info(`WebSocket connection established from ${clientIp}`);
+
+    // Setup heartbeat
+    ws.isAlive = true;
+    ws.on('pong', () => {
+      ws.isAlive = true;
+      logger.debug(`Pong received from client on tunnel [${tunnelId || 'unknown'}]`);
+    });
+
+    const interval = setInterval(() => {
+      if (!ws.isAlive) {
+        logger.warn(`No pong received from client on tunnel [${tunnelId || 'unknown'}], terminating.`);
+        return ws.terminate();
+      }
+      ws.isAlive = false;
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.ping();
+        logger.trace(`Ping sent to client on tunnel [${tunnelId || 'unknown'}]`);
+      }
+    }, PING_INTERVAL);
+
+    ws.on('message', (chunk) => {
+      logger.trace(`Received message chunk: ${chunk.length} bytes`);
+      buffer = Buffer.concat([buffer, chunk]);
+
+      while (buffer.length >= 4) {
+        const length = buffer.readUInt32BE(0);
+        if (buffer.length < 4 + length) break;
+
+        const message = buffer.slice(4, 4 + length);
+        buffer = buffer.slice(4 + length);
+
+        const messageTunnelId = message.slice(0, 36).toString();
+        const uuid = message.slice(36, 72).toString();
+        const type = message.readUInt8(72);
+        const payload = message.slice(73);
+
+        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.`);
+
+              // Assign tunnelId before closing so cleanup logs the correct value
+              tunnelId = messageTunnelId;
+
+              // Close the new connection immediately
+              ws.close(1008, `Duplicate tunnelId: ${messageTunnelId}`);
+              return;
+            } else {
+              logger.info(`Existing tunnel [${messageTunnelId}] has a closed connection. Allowing new connection.`);
+            }
+          }
+          tunnelId = messageTunnelId;
+        }
+
+        handleParsedMessage(ws, messageTunnelId, uuid, type, payload, tunnelIdHeaderName, portKey);
+      }
+    });
+
+    function cleanup(reason = 'unknown') {
+      logger.info(`Cleaning up tunnel [${tunnelId || 'unknown'}] (reason: ${reason})`);
+
+      if (tunnelId) {
+        // Only remove from state if this WebSocket is the one actually registered
+        const registeredTunnel = state[portKey]?.websocketTunnels?.[tunnelId];
+        if (registeredTunnel && registeredTunnel.ws === ws) {
+          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`);
+        }
+      } else {
+        logger.debug(`No tunnelId assigned yet, nothing to remove from state`);
+      }
+
+      clearInterval(interval);
+
+      try {
+        ws.terminate();
+      } catch (e) {
+        logger.debug(`Error in ws.terminate:`, e);
+      }
+
+      ws.removeAllListeners();
+    }
+
+    ws.on('close', () => {
+      logger.info(`WebSocket connection closed for tunnel [${tunnelId || 'unknown'}]`);
+      cleanup('close');
+    });
+
+    ws.on('error', (err) => {
+      logger.error(`WebSocket error on tunnel [${tunnelId || 'unknown'}]:`, err);
+      cleanup('error');
+    });
+  });
+
+  state[portKey].webSocketServer.on('error', (err) => {
+    logger.error('WebSocket server error:', err);
+  });
+
+  return state;
+}
+
+module.exports = { startWebSocketServer };

package/utils/index.js

@@ -0,0 +1,8 @@
+const { setLogLevel, getLogLevel } = require('./logger.js');
+const { loadConfig } = require('./loadConfig.js');
+
+module.exports = {
+  setLogLevel,
+  getLogLevel,
+  loadConfig,
+};

package/utils/loadConfig.js

@@ -0,0 +1,54 @@
+const fs = require('fs');
+const path = require('path');
+require('dotenv').config();
+const { logger, initLogger } = require('./logger');
+const FILE_CONFIG_NAME = 'config.toml';
+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);
+
+  console.log({ configPath });
+
+  initLogger(configPath);
+
+  let fileConfig = {};
+
+  if (fs.existsSync(configPath)) {
+    try {
+      const content = fs.readFileSync(configPath, 'utf8');
+      fileConfig = TOML.parse(content);
+      logger.info(`✅ Loaded configuration from config.toml at: ${configPath}`);
+      logger.debug(`Parsed config.toml content: ${JSON.stringify(fileConfig, null, 2)}`);
+    } catch (err) {
+      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.`);
+  }
+
+  const envConfig = {
+    tunnelId: process.env.TUNNEL_ID,
+    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,
+    headers: process.env.HEADERS,
+    allowInsicureCerts: process.env.ALLOW_INSICURE_CERTS === 'true',
+    logLevel: process.env.LOG_LEVEL || 'info',
+  };
+
+  logger.trace(`Loaded env config: ${JSON.stringify(envConfig, null, 2)}`);
+
+  const finalConfig = {
+    ...envConfig,
+    ...fileConfig, // config.toml has priority over .env
+  };
+
+  logger.debug(`Merged final configuration: ${JSON.stringify(finalConfig, null, 2)}`);
+
+  return finalConfig;
+}
+
+module.exports = { loadConfig };

package/utils/logger.js

@@ -0,0 +1,136 @@
+// logger.js
+const winston = require('winston');
+const fs = require('fs');
+const path = require('path');
+const TOML = require('@iarna/toml');
+const FILE_CONFIG_NAME = 'config.toml';
+
+let configFilePath = null;
+let logContext = null; // Can be set to 'CLIENT', 'SERVER', or any custom prefix
+
+const customLevels = {
+  levels: {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+    trace: 4,
+  },
+  colors: {
+    error: 'red',
+    warn: 'yellow',
+    info: 'green',
+    debug: 'blue',
+    trace: 'magenta',
+  },
+};
+
+winston.addColors(customLevels.colors);
+
+const logger = winston.createLogger({
+  levels: customLevels.levels,
+  level: 'info',
+  transports: [
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        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 coloredLevel = colorizer.colorize(rawLevel, rawLevel);
+          const coloredMessage = colorizer.colorize(rawLevel, `${contextPrefix}${info.message}`);
+          return `[${info.timestamp}] ${coloredLevel}: ${coloredMessage}`;
+        })
+      ),
+    }),
+  ],
+});
+
+function setLogLevel(level) {
+  level = level || 'info';
+  if (!(level in customLevels.levels)) {
+    logger.warn(`Invalid log level: ${level}`);
+    return;
+  }
+  logger.level = level;
+  logger.info(`Log level changed to: ${level}`);
+}
+
+function getLogLevel() {
+  return logger.level;
+}
+
+function setLogContext(context) {
+  logContext = context;
+  if (context) {
+    logger.info(`Log context set to: ${context}`);
+  }
+}
+
+function getLogContext() {
+  return logContext;
+}
+
+function loadConfigFromFile() {
+  try {
+    const content = fs.readFileSync(configFilePath, 'utf8');
+    const parsed = TOML.parse(content);
+    // const parsed = JSON.parse(content);
+    if (parsed.logLevel) {
+      setLogLevel(parsed.logLevel);
+    }
+  } catch (err) {
+    logger.warn(`Could not read or parse ${configFilePath}: ${err.message}`);
+  }
+}
+
+function watchLogConfig() {
+  fs.watchFile(configFilePath, { interval: 1000 }, (curr, prev) => {
+    if (curr.mtime !== prev.mtime) {
+      logger.debug('Detected change in log configuration file.');
+      loadConfigFromFile();
+    }
+  });
+}
+
+function initLogger(customPath = null) {
+  if (customPath) {
+    const resolvedPath = path.resolve(customPath);
+    try {
+      const stats = fs.statSync(resolvedPath);
+      if (stats.isFile()) {
+        configFilePath = resolvedPath;
+      } else if (stats.isDirectory()) {
+        configFilePath = path.join(resolvedPath, FILE_CONFIG_NAME);
+      } else {
+        logger.warn(`Invalid config path provided: ${resolvedPath}`);
+        return;
+      }
+    } catch (err) {
+      logger.warn(`Cannot access config path: ${resolvedPath} (${err.message})`);
+      return;
+    }
+  } else {
+    const baseDir = process.cwd();
+    configFilePath = path.join(baseDir, FILE_CONFIG_NAME);
+  }
+
+  logger.debug(`Logger will read config from: ${configFilePath}`);
+
+  loadConfigFromFile();
+  watchLogConfig();
+}
+
+// initLogger();
+
+module.exports = {
+  logger,
+  initLogger,
+  setLogLevel,
+  getLogLevel,
+  setLogContext,
+  getLogContext,
+};