@yousolution/node-red-contrib-you-tunnel-websocket 0.0.1

package/README.md

@@ -0,0 +1,11 @@
+# @yousolution/node-red-contrib-you-tunnel-websocket
+
+A Node-RED node to create a tunnel websocket
+
+## Install
+
+Run the following command in the root directory of your Node-RED install
+
+    npm install @yousolution/node-red-contrib-you-tunnel-websocket
+
+See [license](https://github.com/yousolution-cloud/node-red-contrib-you-tunnel-websocket/blob/master/LICENSE) (Apache License Version 2.0).

package/docker-compose.yml

@@ -0,0 +1,35 @@
+version: '3.7'
+
+services:
+  nodered:
+    image: nodered/node-red:3.1.9-18
+    # network_mode: host
+    extra_hosts:
+      - 'api.yousolution.local:192.168.178.100'
+    volumes:
+      - ./data:/data
+    ports:
+      - '1880:1880'
+      # - '4443:4443'
+    deploy:
+      resources:
+        limits:
+          memory: 800M
+    environment:
+      NODE_ENV: 'dev'
+      # VIRTUAL_HOST: websocket.yousolution.local
+      # VIRTUAL_PORT: '4443'
+
+    networks:
+      ys_tools_net:
+        aliases:
+          - nodered_659eafe98b4d8400110381f1
+      # ys_ingress_net:
+      #   aliases:
+      #     - nodered_659eafe98b4d8400110381f1
+
+networks:
+  ys_tools_net:
+    external: true
+  # ys_ingress_net:
+  #   external: true

package/nodes/wsTunnel.html

@@ -0,0 +1,236 @@
+<!--
+ Copyright 2023 Andrea Trentin.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+		 http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<script type="text/x-red" data-template-name="wstunnel">
+  <div class="form-row">
+    <label for="node-config-input-name"><i class="fa fa-bookmark"></i> name</label>
+    <input type="text" id="node-config-input-name" placeholder="tunnel name" />
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-host"><i class="fa fa-bookmark"></i> Host</label>
+    <input type="text" id="node-config-input-host" placeholder="localhost" style="width: 40%;" />
+    <label for="node-config-input-port" style="margin-left: 10px; width: 35px; "> Port</label>
+    <input type="text" id="node-config-input-port" placeholder="22" style="width:45px">
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-srcAddr"><i class="fa fa-gear"></i> Source Address</label>
+    <input type="text" id="node-config-input-srcAddr" placeholder="localhost">
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-srcPort"><i class="fa fa-gear"></i> Source Port</label>
+    <input type="text" id="node-config-input-srcPort">
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-dstAddr"><i class="fa fa-gear"></i> Destination Address</label>
+    <input type="text" id="node-config-input-dstAddr" placeholder="localhost">
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-dstPort"><i class="fa fa-gear"></i> Destination Port</label>
+    <input type="text" id="node-config-input-dstPort">
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-timeout"><i class="fa fa-gear"></i> Timeout</label>
+    <input type="text" id="node-config-input-timeout">
+  </div>
+</script>
+
+<script type="text/javascript">
+  RED.nodes.registerType('wstunnel', {
+    category: 'config',
+    color: '#AAAA66',
+    defaults: {
+      name: { value: '', required: true },
+      host: { value: '' },
+      port: { value: '' },
+      srcAddr: { value: '' },
+      srcPort: { value: '', required: true },
+      dstAddr: { value: '' },
+      dstPort: { value: '' },
+      timeout: { value: '' },
+    },
+    label: function () {
+      return this.name;
+    },
+    oneditprepare: function () {},
+  });
+</script>
+
+<script type="text/x-red" data-template-name="wstunnel client">
+  <div class="form-row">
+    <label for="node-input-url"><i class="fa fa-bookmark"></i> Url</label>
+    <input type="text" id="node-input-url" placeholder="Url tunnel" />
+  </div>
+</script>
+
+<script type="text/x-red" data-help-name="wstunnel client">
+  <p>
+    This node establishes a WebSocket client connection to a remote WebSocket server,
+    enabling the creation of an HTTP tunnel over the WebSocket connection. It can be
+    used for creating secure connections for web services or routing HTTP traffic through
+    a WebSocket channel.
+  </p>
+
+  <h3>Parameters</h3>
+  <table class="node-help">
+    <tr>
+      <td><strong>Url</strong></td>
+      <td>The URL of the WebSocket server to connect to. This should be in the format `ws://` or `wss://` for secure WebSocket connections. For example: `wss://example.com/socket`.</td>
+    </tr>
+  </table>
+
+  <h3>Usage</h3>
+  <p>
+    Once configured, this node will initiate a WebSocket connection to the specified server URL.
+    After the connection is established, the node can be used to tunnel HTTP traffic to the remote server.
+    This can be useful for scenarios like securely forwarding HTTP requests over a WebSocket connection.
+  </p>
+
+  <h3>Example</h3>
+  <pre>
+    [
+      {
+        "id": "wstunnel-client-node",
+        "type": "wstunnel client",
+        "url": "wss://example.com/socket",
+        "x": 300,
+        "y": 200,
+        "wires": []
+      }
+    ]
+  </pre>
+
+  <h3>Notes</h3>
+  <ul>
+    <li>The node initiates a WebSocket connection when deployed and listens for incoming HTTP requests to tunnel.</li>
+    <li>If the connection is closed or fails, the node will attempt to reconnect based on internal reconnection logic.</li>
+    <li>Ensure the WebSocket server you're connecting to supports tunneling or is configured to handle this type of traffic.</li>
+  </ul>
+</script>
+
+<script type="text/javascript">
+  RED.nodes.registerType('wstunnel client', {
+    category: 'network',
+    color: '#a7c957',
+    defaults: {
+      url: { value: '' },
+    },
+    inputs: 1,
+    outputs: 0,
+    icon: 'font-awesome/fa-lock',
+    label: function () {
+      return this.name || 'tunnel Websocket client';
+    },
+    labelStyle: function () {
+      return this.name ? 'node_label_italic' : '';
+    },
+  });
+</script>
+
+<script type="text/x-red" data-template-name="wstunnel server">
+  <div class="form-row">
+    <label for="node-input-wstunnnel"><i class="fa fa-gears"></i> Cofigure Tunnel Websocket server</label>
+    <input type="text" id="node-input-wstunnel">
+  </div>
+</script>
+
+<script type="text/x-red" data-help-name="wstunnel server">
+  <p>
+    This node is used to configure and manage a WebSocket server tunnel. It allows the establishment
+    of WebSocket-based communication between a server and a client. You can define the source and destination
+    addresses and ports to tunnel the traffic through WebSocket connections.
+  </p>
+
+  <h3>Parameters</h3>
+  <table class="node-help">
+    <tr>
+      <td><strong>Name</strong></td>
+      <td>A unique name for the tunnel configuration. This will help you identify the tunnel in Node-RED.</td>
+    </tr>
+    <tr>
+      <td><strong>Host</strong></td>
+      <td>The host address to which the WebSocket server should connect. This is typically the address of your server hosting the WebSocket server.</td>
+    </tr>
+    <tr>
+      <td><strong>Port</strong></td>
+      <td>The port on which the WebSocket server will listen. This is the port used to accept WebSocket connections from clients.</td>
+    </tr>
+    <tr>
+      <td><strong>Source Address</strong></td>
+      <td>The source address (IP or hostname) for the WebSocket connection. This is typically set to the address of the service initiating the WebSocket connection.</td>
+    </tr>
+    <tr>
+      <td><strong>Source Port</strong></td>
+      <td>The source port that the WebSocket server will use. This is required to define the source of the communication.</td>
+    </tr>
+    <tr>
+      <td><strong>Destination Address</strong></td>
+      <td>The destination address where the WebSocket connection should forward the tunneled HTTP traffic. This is usually set to the IP or hostname of the remote service.</td>
+    </tr>
+    <tr>
+      <td><strong>Destination Port</strong></td>
+      <td>The destination port where the tunneled HTTP traffic will be sent. This corresponds to the port of the destination service.</td>
+    </tr>
+    <tr>
+      <td><strong>Timeout</strong></td>
+      <td>Timeout in milliseconds for the WebSocket connection. If the WebSocket connection does not establish within this time, the connection attempt will be aborted.</td>
+    </tr>
+  </table>
+
+  <h3>Usage</h3>
+  <p>
+    After configuring the tunnel server, the node will act as the WebSocket server. It listens for incoming
+    WebSocket connection requests and forwards any received HTTP traffic to the specified destination address and port.
+  </p>
+
+  <h3>Example</h3>
+  <pre>
+    [
+      {
+        "id": "wstunnel-server-node",
+        "type": "wstunnel server",
+        "wstunnel": "wstunnel-config",
+        "name": "My WebSocket Tunnel Server",
+        "x": 300,
+        "y": 200,
+        "wires": []
+      }
+    ]
+  </pre>
+
+  <h3>Notes</h3>
+  <ul>
+    <li>The server node requires a valid tunnel configuration to function. You can link a configuration node using the 'Configure Tunnel WebSocket server' field.</li>
+    <li>If the WebSocket server is not running, the node will attempt to reconnect based on the configured timeout.</li>
+    <li>Ensure the WebSocket server and client are compatible with the tunneling protocol.</li>
+  </ul>
+</script>
+
+<script type="text/javascript">
+  RED.nodes.registerType('wstunnel server', {
+    category: 'network',
+    color: '#a7c957',
+    defaults: {
+      wstunnel: { type: 'wstunnel', required: true },
+      name: { value: '' },
+    },
+    inputs: 0,
+    outputs: 0,
+    icon: 'font-awesome/fa-lock',
+    label: function () {
+      return this.name || 'tunnel Websocket server';
+    },
+    labelStyle: function () {
+      return this.name ? 'node_label_italic' : '';
+    },
+  });
+</script>

package/nodes/wsTunnel.js

@@ -0,0 +1,501 @@
+/**
+ * Copyright 2015 Atsushi Kojo.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ **/
+const WebSocket = require('ws');
+const { Buffer } = require('buffer');
+const net = require('net');
+const { v4: uuidv4 } = require('uuid');
+const tls = require('tls');
+
+const PING_INTERVAL = 1000 * 30; // in seconds
+const instances = {};
+const HTTP_TIMEOUT = 1000 * 30; // in seconds
+const RECONNECT_INTERVAL = 1000 * 5;
+
+module.exports = function (RED) {
+  'use strict';
+
+  function WSTunnelNode(n) {
+    RED.nodes.createNode(this, n);
+
+    const [dstProtocol, dstHost, dstPort] = getProtocolAndHostAndDefautlPort(n.dstAddr);
+
+    // console.log('{}{}{}{}{}{}{}{}');
+    // console.log(dstProtocol);
+    // console.log(dstHost);
+    // console.log(dstPort);
+    // console.log('{}{}{}{}{}{}{}{}');
+
+    this.options = {
+      name: n.name || 'websocket tunnel',
+      host: n.host || 'localhost',
+      port: n.port || 8083,
+
+      srcAddr: n.srcAddr || 'localhost',
+      srcPort: n.srcPort,
+      dstAddr: dstHost || 'localhost',
+      dstPort: n.dstPort || dstPort || 80,
+      timeout: n.timeout || HTTP_TIMEOUT,
+    };
+  }
+
+  RED.nodes.registerType('wstunnel', WSTunnelNode);
+
+  function WSTunnelClient(n) {
+    RED.nodes.createNode(this, n);
+    let node = this;
+    this.status({});
+
+    const websocketURL = n.url;
+
+    if (!websocketURL) {
+      node.status({ fill: 'red', shape: 'dot', text: 'The URL is invalid or not defined.' });
+      return;
+    }
+
+    function connectWebSocket() {
+      let options = undefined;
+      // Crea una connessione al server WebSocket
+      const ws = new WebSocket(websocketURL, options);
+
+      // Quando la connessione è aperta, invia un messaggio al server
+      ws.on('open', () => {
+        console.log('Connected to the WebSocket server');
+        node.status({ fill: 'green', shape: 'dot', text: 'WebSocket tunnel established' });
+      });
+
+      // Quando ricevi un messaggio dal server, stampalo
+      ws.on('message', async (data) => {
+        // console.log('Received from server: ', data);
+        // console.log('Received Base64 encoded HTTP RAW request:');
+
+        // Decodifica la stringa Base64
+        try {
+          // const request = JSON.parse(Buffer.from(data, 'base64').toString('utf-8'));
+          // const rawHttpRequest = Buffer.from(request.httpRequest, 'base64').toString('utf-8');
+          // console.log('Decoded HTTP RAW Request:', request.httpRequest);
+
+          const extractedUUID = data.slice(0, 36);
+          // console.log(extractedUUID);
+          const res = await incomingRequest(data.slice(36)); // tolgo dal buffer uuid
+          // console.log('======');
+          // console.log(res.toString('utf-8'));
+          // console.log('======');
+          ws.send(Buffer.concat([extractedUUID, res]));
+        } catch (error) {
+          console.log(error);
+        }
+      });
+
+      // Gestione degli errori di connessione
+      ws.on('error', (error) => {
+        node.status({ fill: 'red', shape: 'dot', text: 'Websocket error.' });
+        console.error('Error occurred: ', error);
+      });
+
+      // Quando la connessione è chiusa, stampa un messaggio
+      ws.on('close', () => {
+        console.log('Disconnected from the WebSocket server');
+        node.status({ fill: 'red', shape: 'ring', text: 'Disconnected from the WebSocket server' });
+        setTimeout(connectWebSocket, RECONNECT_INTERVAL);
+      });
+    }
+
+    connectWebSocket();
+
+    async function incomingRequest(rawHttpRequest) {
+      const { hostname, port } = extractHostAndPort(rawHttpRequest);
+
+      if (port == 443) {
+        return await tlsRequest(rawHttpRequest);
+      }
+
+      return await tcpRequest(rawHttpRequest);
+    }
+
+    function tlsRequest(rawHttpRequest) {
+      return new Promise((resolve, reject) => {
+        const { hostname, port } = extractHostAndPort(rawHttpRequest);
+
+        let responseData = Buffer.alloc(0); // Inizializza un buffer vuoto per accumulare i dati
+
+        // console.log(hostname);
+        // console.log(port);
+        // Creazione di un socket TCP
+        const client = tls.connect(port, hostname, { servername: hostname }, () => {
+          client.write(rawHttpRequest); // Invia la richiesta HTTP raw
+        });
+
+        // Ricevi i dati dalla risposta del server
+        client.on('data', (data) => {
+          // console.log('Received response from server:');
+          // console.log(data.toString()); // Converte i dati ricevuti in stringa e li stampa
+          // return resolve(data);
+          responseData = Buffer.concat([responseData, data]); // Accumula i dati ricevuti
+        });
+
+        // Quando la connessione si chiude
+        client.on('end', () => {
+          console.log('Connection closed');
+          resolve(responseData);
+          // client.destroy()
+        });
+
+        // Gestione degli errori
+        client.on('error', (err) => {
+          reject(err);
+          console.error('Error:', err);
+        });
+      });
+    }
+
+    function tcpRequest(rawHttpRequest) {
+      return new Promise((resolve, reject) => {
+        const { hostname, port } = extractHostAndPort(rawHttpRequest);
+
+        let responseData = Buffer.alloc(0); // Inizializza un buffer vuoto per accumulare i dati
+
+        // console.log(hostname);
+        // console.log(port);
+
+        // Creazione di un socket TCP
+        const client = net.createConnection(port, hostname, () => {
+          client.write(rawHttpRequest); // Invia la richiesta HTTP raw
+        });
+
+        // Ricevi i dati dalla risposta del server
+        client.on('data', (data) => {
+          responseData = Buffer.concat([responseData, data]); // Accumula i dati ricevuti
+        });
+
+        // Quando la connessione si chiude
+        client.on('end', () => {
+          console.log('Connection closed');
+          resolve(responseData);
+        });
+
+        // Gestione degli errori
+        client.on('error', (err) => {
+          reject(err);
+          console.error('Error:', err);
+        });
+      });
+    }
+
+    function extractHostAndPort(rawHttp) {
+      const hostPattern = /Host:\s*([^\r\n]+)/i; // Regex per trovare la linea Host
+      const rawHttpString = rawHttp.toString('utf-8');
+      const match = rawHttpString.match(hostPattern);
+
+      if (!match) {
+        throw new Error('Host non trovato nella stringa HTTP raw');
+      }
+
+      const host = match[1];
+      const [hostname, port = 443] = host.split(':'); // Porta di default 443 per HTTPS
+
+      return { hostname, port: parseInt(port, 10) };
+    }
+
+    this.url = n.url;
+    // this.operation = n.operation;
+    // this.filename = n.filename;
+    // this.fileExtension = n.fileExtension;
+    // this.workdir = n.workdir;
+    // this.tunnelConfig = RED.nodes.getNode(this.tunnel);
+
+    // const globalContext = this.context().global;
+
+    // if (!this.tunnelConfig) {
+    //   this.error('missing tunnel Websocket configuration');
+    //   return;
+    // }
+
+    // Hack for async function
+    // setTimeout(async () => {
+    //   await connect(node);
+    // });
+
+    // node.on('input', async (msg, send, done) => {
+    //   setTimeout(async () => {
+    //     await connect(node);
+    //   }, node.tunnelConfig.options.reconnectTimeout);
+    // });
+  }
+  RED.nodes.registerType('wstunnel client', WSTunnelClient);
+
+  function WSTunnelServer(n) {
+    instances[n.id] = instances[n.id] || {};
+    instances[n.id].server = instances[n.id].server || null;
+    instances[n.id].wss = instances[n.id].wss || null;
+    instances[n.id].websocketServer = instances[n.id].websocketServer || null;
+
+    RED.nodes.createNode(this, n);
+    this.tunnelConfig = RED.nodes.getNode(n.wstunnel);
+    let node = this;
+    const id = n.id;
+
+    node.status({ fill: 'red', shape: 'ring', text: 'disconnected' });
+
+    const port = node.tunnelConfig.options.port;
+    const srcAddr = node.tunnelConfig.options.srcAddr || 'localhost';
+    const srcPort = node.tunnelConfig.options.srcPort || 8083;
+    const dstAddr = node.tunnelConfig.options.dstAddr || 'localhost';
+    const dstPort = node.tunnelConfig.options.dstPort || 80;
+    const timeout = node.tunnelConfig.options.timeout || HTTP_TIMEOUT;
+    // const port = 4443;
+
+    // console.log('+++++++++ OPTIONS ++++++++');
+    // console.log(port);
+    // console.log(dstPort);
+    // console.log(dstAddr);
+    // console.log(timeout);
+    // console.log('+++++++++ OPTIONS ++++++++');
+    const options = {
+      id,
+      port,
+      srcAddr,
+      srcPort,
+      dstAddr,
+      dstPort,
+      timeout,
+    };
+
+    if (instances[options.id].server) {
+      instances[options.id].server.close(() => {
+        TCPServer(options);
+      });
+    } else {
+      TCPServer(options);
+    }
+
+    if (instances[n.id].wss) {
+      instances[n.id].wss.close(() => {
+        webSocketServer(node, options);
+      });
+    } else {
+      webSocketServer(node, options);
+    }
+  }
+
+  function requestFromServer(message, options) {
+    return new Promise((resolve, reject) => {
+      if (!instances[options.id].websocketServer) {
+        return reject(new WebsocketTunnelError('WebSocket connection not established.', 500));
+      }
+
+      const uuid = uuidv4();
+      const uuidBuffer = Buffer.from(uuid);
+      const resultBuffer = Buffer.concat([uuidBuffer, Buffer.from(message)]);
+
+      const timeoutId = setTimeout(() => {
+        clearTimeout(timeoutId);
+        reject('Timeout: No response from the client.');
+      }, options.timeout);
+
+      const onMessage = (response) => {
+        // console.log(response.toString());
+        const extractedUUID = response.slice(0, 36);
+        if (Buffer.compare(uuidBuffer, extractedUUID) === 0) {
+          resolve(response.slice(36));
+          instances[options.id].websocketServer.removeListener('message', onMessage);
+          clearTimeout(timeoutId);
+        }
+      };
+      instances[options.id].websocketServer.on('message', onMessage);
+
+      instances[options.id].websocketServer.send(resultBuffer);
+    });
+  }
+
+  function webSocketServer(node, options) {
+    try {
+      instances[node.id].wss = new WebSocket.Server({ port: options.port });
+    } catch (error) {
+      console.log(error);
+    }
+
+    instances[node.id].wss.on('listening', () => {
+      console.log(`WebSocket server is listening on port ${options.port}`);
+    });
+
+    instances[node.id].wss.on('connection', (ws) => {
+      if (instances[node.id].websocketServer) {
+        console.log('WebSocket tunnel is already active');
+        ws.close();
+        return;
+      }
+
+      console.log('WebSocket tunnel established');
+      node.status({ fill: 'green', shape: 'dot', text: 'WebSocket tunnel established' });
+      instances[node.id].websocketServer = ws;
+
+      // Invia un messaggio di benvenuto al client appena connesso
+      // ws.send('Ciao dal server WebSocket!');
+
+      const interval = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.ping(); // invia un ping al client
+          console.log('Ping inviato al client');
+        }
+      }, PING_INTERVAL);
+
+      // Quando si verifica un errore
+      ws.on('error', function error(err) {
+        instances[node.id].websocketServer = null;
+        console.error('WebSocket error:', err);
+        clearInterval(interval); // pulisci l'intervallo quando la connessione è chiusa
+        node.error(err, { payload: 'Open websockeet tunnel error', message: err.message });
+        node.status({ fill: 'red', shape: 'dot', text: 'Error' });
+      });
+
+      // Gestiamo i messaggi ricevuti dal client
+      // ws.on('message', (message) => {
+      //   console.log(`Messaggio ricevuto dal client: ${message}`);
+      //   // Rispondiamo al client
+      //   // ws.send(`Hai detto: ${message}`);
+      // });
+
+      // Gestiamo la chiusura della connessione
+      ws.on('close', () => {
+        console.log('WebSocket tunnel closed');
+        instances[node.id].websocketServer = null;
+        node.status({ fill: 'red', shape: 'ring', text: 'disconnected' });
+        clearInterval(interval); // pulisci l'intervallo quando la connessione è chiusa
+      });
+
+      // Quando ricevi un pong dal client
+      ws.on('pong', () => {
+        console.log('Pong ricevuto dal client');
+      });
+    });
+
+    instances[node.id].wss.on('error', (error) => {
+      console.log(error);
+    });
+  }
+
+  function TCPServer(options) {
+    instances[options.id].server = net.createServer((socket) => {
+      // console.log('Client connesso');
+
+      // Variabile per memorizzare i dati grezzi della richiesta
+      let rawRequestData = '';
+
+      // Leggi i dati grezzi dal socket
+      socket.on('data', async (data) => {
+        rawRequestData += data.toString(); // Aggiungi i dati ricevuti alla variabile rawRequestData
+
+        // Puoi scegliere di processare la richiesta solo quando hai ricevuto tutto il contenuto, ad esempio quando la richiesta termina
+        if (rawRequestData.includes('\r\n\r\n')) {
+          // Quando i dati contengono l'header completo, puoi trattarli come una richiesta completa
+
+          // Sostituire il campo Host con il nuovo valore
+          rawRequestData = rawRequestData.replace(/Host:\s*([^\r\n]*)/, `Host: ${options.dstAddr}:${options.dstPort}`);
+          console.log('Richiesta HTTP raw ricevuta:');
+          console.log(rawRequestData);
+
+          try {
+            const response = await requestFromServer(rawRequestData, options);
+            // console.log('-----------');
+            // console.log(response);
+            // console.log('-----------');
+            socket.write(response);
+            // Rispondi al client (opzionale)
+            // socket.write('HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nResponse OK');
+            // Chiudi la connessione (opzionale)
+          } catch (error) {
+            console.log(error);
+            let errorRespose =
+              `HTTP/1.1 408 Request Timeout\r\n` +
+              `Content-Type: text/plain; charset=utf-8\r\n` +
+              // `Content-Length: 29\r\n` +
+              `Connection: close\r\n` +
+              `Date: ${new Date().toUTCString()}\r\n\r\n` + // usa toUTCString() invece di toGMTString
+              `Request Timeout: The server timed out waiting for the request.`;
+
+            if (error instanceof WebsocketTunnelError) {
+              errorRespose =
+                `HTTP/1.1 ${error.code} ${error.name}\r\n` +
+                `Content-Type: text/plain; charset=utf-8\r\n` +
+                // `Content-Length: 29\r\n` +
+                `Connection: close\r\n` +
+                `Date: ${new Date().toUTCString()}\r\n\r\n` + // usa toUTCString() invece di toGMTString
+                `${error.message}`;
+            }
+
+            socket.write(errorRespose); // Invia la risposta di timeout
+          }
+          socket.end();
+        }
+      });
+
+      socket.on('end', () => {
+        console.log('Client disconnected');
+      });
+
+      socket.on('error', (err) => {
+        console.error('Connection error:', err);
+      });
+    });
+
+    try {
+      instances[options.id].server.listen(options.srcPort, () => {
+        console.log(`HTTP server listening on port ${options.srcPort}`);
+      });
+      instances[options.id].server.on('error', (error) => {
+        console.log(error);
+      });
+    } catch (error) {
+      console.log(error);
+    }
+  }
+
+  function getProtocolAndHostAndDefautlPort(url) {
+    try {
+      const protocolPorts = {
+        http: 80,
+        https: 443,
+        ftp: 21,
+        ssh: 22,
+      };
+      // Add "http://" as a default protocol
+      if (!/^https?:\/\//i.test(url)) {
+        url = 'http://' + url;
+      }
+      const parsedUrl = new URL(url);
+      const protocol = parsedUrl.protocol.replace(':', '');
+      const host = parsedUrl.hostname;
+
+      const port = parsedUrl.port || protocolPorts[protocol] || null;
+
+      return [protocol, host, port];
+    } catch (error) {
+      console.error('Invalid URL:', error);
+      return null;
+    }
+  }
+
+  class WebsocketTunnelError extends Error {
+    constructor(message, code) {
+      super(message);
+      this.name = this.constructor.name;
+      this.code = code;
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+
+  RED.nodes.registerType('wstunnel server', WSTunnelServer);
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@yousolution/node-red-contrib-you-tunnel-websocket",
+  "version": "0.0.1",
+  "description": "Module to create websockeet tunnel for NODE-RED",
+  "license": "MIT",
+  "scripts": {
+    "update": "npm pack && mv yousolution-node-red-contrib-you-tunnel-websocket-$npm_package_version.tgz ./data && cd data && rm -rf node_modules && npm i yousolution-node-red-contrib-you-tunnel-websocket-$npm_package_version.tgz && docker-compose restart",
+    "test": "mocha 'test/**/*.spec.js'",
+    "coverage": "nyc npm run test"
+  },
+  "keywords": [
+    "node-red",
+    "websocket",
+    "tunnel",
+    "integration",
+    "youSolution.Cloud"
+  ],
+  "author": "Andrea Trentin <andrea.trentin@yousolution.cloud>",
+  "node-red": {
+    "version": ">=2.0.0",
+    "nodes": {
+      "wsTunnel": "/nodes/wsTunnel.js"
+    }
+  },
+  "dependencies": {
+    "uuid": "^11.0.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yousolution-cloud/node-red-contrib-you-tunnel-websocket.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "jest": "^29.5.0",
+    "node-red": "^3.0.2",
+    "node-red-node-test-helper": "^0.3.1"
+  }
+}