nport 1.0.0

package/Dockerfile

@@ -0,0 +1,15 @@
+FROM node:8
+
+# Create app directory
+RUN mkdir -p /usr/src/app
+WORKDIR /usr/src/app
+
+# Install app dependencies
+COPY package.json /usr/src/app/
+RUN npm install
+
+# Bundle app source
+COPY . /usr/src/app
+
+EXPOSE 3000
+CMD [ "node", "bin/server" ]

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2016 Noop Labs LLC http://nooplabs.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+# **NPort**
+
+NPort is a **Node.js-based tool** that tunnels HTTP connections through **Socket.IO** streams, enabling you to expose local servers via public URLs easily and securely. It is particularly useful for **development environments**, testing webhooks, and sharing projects on local servers.
+
+---
+
+## **Features**
+
+- **HTTP Tunneling**: Expose your local HTTP server to the internet using Socket.IO-based tunnels.
+- **Secure and Lightweight**: A minimal, fast, and secure way to share your server without requiring complicated infrastructure.
+- **Custom Subdomains**: Access your local server using easy-to-read public URLs.
+- **WebSocket Support**: Handles WebSocket connections seamlessly.
+- **Cross-Platform**: Works on Linux, macOS, and Windows systems.
+
+---
+
+## **Install**
+
+```sh
+npm install git+https://github.com/tuanngocptn/nport.git # local install
+
+npm install -g git+https://github.com/tuanngocptn/nport.git  # global install
+```
+
+---
+
+## **How to use**
+
+```sh
+npx nport --s xxx -p 3000 # https://xxx.nport.link (local install)
+
+nport --s xxx -p 3000 # https://xxx.nport.link (global install)
+```
+**OR**
+
+```sh
+npx nport --server https://nport.link --subdomain xxx --hostname 127.0.0.1 --port 3000 # https://xxx.nport.link (local install)
+
+nport --server https://nport.link --subdomain xxx --hostname 127.0.0.1 --port 3000 # https://xxx.nport.link (global install)
+```
+
+# Source from socket-tunnel
+
+Tunnel HTTP connections via socket.io streams. Inspired by [localtunnel](https://github.com/localtunnel/localtunnel).
+
+## Blog Post
+
+[Read all about it](https://ericbarch.com/post/sockettunnel/)

package/bin/client

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+const optimist = require('optimist');
+
+let argv = optimist
+  .usage('Usage: $0 --server [string] --subdomain [string] --hostname [string] --port [number]')
+  .options('se', {
+    alias: 'server',
+    default: 'https://nport.link',
+    describe: 'Tunnel server endpoint'
+  })
+  .options('s', {
+    alias: 'subdomain',
+    describe: '(Required) Public URL the tunnel server is forwarding to us'
+  })
+  .options('h', {
+    alias: 'hostname',
+    default: '127.0.0.1',
+    describe: 'Address of local server for forwarding over socket-tunnel'
+  })
+  .options('p', {
+    alias: 'port',
+    describe: '(Required) Port of local server for forwarding over socket-tunnel'
+  })
+  .argv;
+
+if (argv.help) {
+  optimist.showHelp();
+  process.exit();
+}
+
+if (!argv['server'] || !argv['subdomain'] || !argv['port']) {
+  for (var key in ['server', 'subdomain', 'port']) {
+    if (argv[key]) continue;
+
+    console.log('Error: Required option, but nothing found');
+
+    optimist.showHelp();
+
+    process.exit();
+  }
+}
+
+require('../client.js')(argv);

package/bin/server

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+var optimist = require('optimist');
+
+var argv = optimist
+  .usage('Usage: $0 --hostname [string] --port [number] --subdomain [string]')
+  .options('h', {
+    alias: 'hostname',
+    default: '0.0.0.0',
+    describe: 'Accept connections on this hostname'
+  })
+  .options('p', {
+    alias: 'port',
+    default: 3000,
+    describe: 'Server daemon port'
+  })
+  .options('s', {
+    alias: 'subdomain',
+    default: '',
+    describe: 'Name of subdomain used. Required when server listens on a subdomain (leave blank otherwise)'
+  })
+  .argv;
+
+if (argv.help) {
+  optimist.showHelp();
+  process.exit();
+}
+
+require('../server.js')(argv);

package/client.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const IDLE_SOCKET_TIMEOUT_MILLISECONDS = 1000 * 30;
+
+module.exports = (options) => {
+  return new Promise((resolve, reject) => {
+    // require the things we need
+    const net = require('net');
+    const ss = require('socket.io-stream');
+    let socket = require('socket.io-client')(options['server']);
+
+    socket.on('connect', () => {
+      console.log(new Date() + ': connected');
+      console.log(new Date() + ': requesting subdomain ' + options['subdomain'] + ' via ' + options['server']);
+
+      socket.emit('createTunnel', options['subdomain'], (err) => {
+        if (err) {
+          console.log(new Date() + ': [error] ' + err);
+
+          reject(err);
+        } else {
+          console.log(new Date() + ': registered with server successfully');
+          console.log(new Date() + ': your domain is: https://' + options['subdomain'] + '.nport.link');
+
+          // clean and concat requested url
+          let url;
+          let subdomain = options['subdomain'].toString();
+          let server = options['server'].toString();
+
+          if (server.includes('https://')) {
+            url = `https://${subdomain}.${server.slice(8)}`;
+          } else if (server.includes('http://')) {
+            url = `http://${subdomain}.${server.slice(7)}`;
+          } else {
+            url = `https://${subdomain}.${server}`;
+          }
+
+          // resolve promise with requested URL
+          resolve(url);
+        }
+      });
+    });
+
+    socket.on('incomingClient', (clientId) => {
+      let client = net.connect(options['port'], options['hostname'], () => {
+        let s = ss.createStream();
+        s.pipe(client).pipe(s);
+
+        s.on('end', () => {
+          client.destroy();
+        });
+
+        ss(socket).emit(clientId, s);
+      });
+
+      client.setTimeout(IDLE_SOCKET_TIMEOUT_MILLISECONDS);
+      client.on('timeout', () => {
+        client.end();
+      });
+
+      client.on('error', () => {
+        // handle connection refusal (create a stream and immediately close it)
+        let s = ss.createStream();
+        ss(socket).emit(clientId, s);
+        s.end();
+      });
+    });
+  });
+};

package/examples/api.js

@@ -0,0 +1,9 @@
+const socketTunnel = require('../lib/api');
+
+socketTunnel.connect('https://domain.example', 'deviceSubdomain', '2222')
+  .then((url) => {
+    console.log(url);
+  })
+  .catch((err) => {
+    console.error(err);
+  });

package/lib/api.js

@@ -0,0 +1,22 @@
+// client api
+const client = require('../client');
+
+let api = {
+  connect: (server, subdomain, port, hostname = '127.0.0.1') => {
+    if (!server || !subdomain || !port || !hostname) {
+      return Promise.reject(new Error('One or more options were not provided'));
+    }
+
+    let options = {
+      server: server,
+      subdomain: subdomain.toString(),
+      port: port.toString(),
+      hostname: hostname
+    };
+
+    // client returns a promise
+    return client(options);
+  }
+};
+
+module.exports = api;

package/nginx.conf.sample

@@ -0,0 +1,33 @@
+# Example of nginx config for proxying requests to socket-tunnel server
+
+server {
+    listen *:80;
+    server_name subdomain.example.com *.subdomain.example.com;
+    rewrite ^ https://$host$request_uri? permanent;
+}
+
+server {
+    listen *:443;
+
+    server_name subdomain.example.com *.subdomain.example.com;
+
+    ssl on;
+    ssl_certificate /path/to/certificate/file.crt;
+    ssl_certificate_key /path/to/key/file.key;
+    ssl_prefer_server_ciphers on;
+
+    location / {
+        proxy_pass http://127.0.0.1:3000/;
+
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header Host $http_host;
+        proxy_http_version 1.1;
+        proxy_set_header X-Forwarded-Proto https;
+        proxy_set_header X-NginX-Proxy true;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+
+        proxy_redirect off;
+    }
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "author": "Nick Pham <nickpham@nooplabs.com>, source from socket-tunnel (Eric Barch <ebarch@nooplabs.com>)",
+  "name": "nport",
+  "description": "Tunnel HTTP Connections via socket.io streams.",
+  "version": "1.0.0",
+  "dependencies": {
+    "is-valid-domain": "0.0.5",
+    "optimist": "^0.6.1",
+    "socket.io": "^2.1.0",
+    "socket.io-client": "^2.1.0",
+    "socket.io-stream": "^0.9.1",
+    "tldjs": "^2.3.1",
+    "uuid": "^3.2.1"
+  },
+  "bin": {
+    "nport": "./bin/client"
+  },
+  "license": "MIT"
+}

package/server.js

@@ -0,0 +1,200 @@
+'use strict';
+
+module.exports = (options) => {
+  // libs
+  const http = require('http');
+  const tldjs = require('tldjs');
+  const ss = require('socket.io-stream');
+  const uuid = require('uuid/v4');
+  const isValidDomain = require('is-valid-domain');
+
+  // association between subdomains and socket.io sockets
+  let socketsBySubdomain = {};
+
+  // bounce incoming http requests to socket.io
+  let server = http.createServer(async (req, res) => {
+    getTunnelClientStreamForReq(req).then((tunnelClientStream) => {
+      const reqBodyChunks = [];
+
+      req.on('error', (err) => {
+        console.error(err.stack);
+      });
+
+      // collect body chunks
+      req.on('data', (bodyChunk) => {
+        reqBodyChunks.push(bodyChunk);
+      });
+
+      // proxy finalized request to tunnel stream
+      req.on('end', () => {
+        // make sure the client didn't die on us
+        if (req.complete) {
+          const reqLine = getReqLineFromReq(req);
+          const headers = getHeadersFromReq(req);
+
+          let reqBody = null;
+          if (reqBodyChunks.length > 0) {
+            reqBody = Buffer.concat(reqBodyChunks);
+          }
+
+          streamResponse(reqLine, headers, reqBody, tunnelClientStream);
+        }
+      });
+    }).catch((subdomainErr) => {
+      res.statusCode = 502;
+      return res.end(subdomainErr.message);
+    });
+  });
+
+  // HTTP upgrades (i.e. websockets) are NOT currently supported because socket.io relies on them
+  // server.on('upgrade', (req, socket, head) => {
+  //   getTunnelClientStreamForReq(req).then((tunnelClientStream) => {
+  //     tunnelClientStream.on('error', () => {
+  //       req.destroy();
+  //       socket.destroy();
+  //       tunnelClientStream.destroy();
+  //     });
+
+  //     // get the upgrade request and send it to the tunnel client
+  //     let messageParts = getHeaderPartsForReq(req);
+
+  //     messageParts.push(''); // Push delimiter
+
+  //     let message = messageParts.join('\r\n');
+  //     tunnelClientStream.write(message);
+
+  //     // pipe data between ingress socket and tunnel client
+  //     tunnelClientStream.pipe(socket).pipe(tunnelClientStream);
+  //   }).catch((subdomainErr) => {
+  //     // if we get an invalid subdomain, this socket is most likely being handled by the root socket.io server
+  //     if (!subdomainErr.message.includes('Invalid subdomain')) {
+  //       socket.end();
+  //     }
+  //   });
+  // });
+
+  function getTunnelClientStreamForReq (req) {
+    return new Promise((resolve, reject) => {
+      // without a hostname, we won't know who the request is for
+      let hostname = req.headers.host;
+      if (!hostname) {
+        return reject(new Error('Invalid hostname'));
+      }
+
+      // make sure we received a subdomain
+      let subdomain = tldjs.getSubdomain(hostname).toLowerCase();
+      if (!subdomain) {
+        return reject(new Error('Invalid subdomain'));
+      }
+
+      // tldjs library return subdomain as all subdomain path from the main domain.
+      // Example:
+      // 1. super.example.com = super
+      // 2. my.super.example.com = my.super
+      // 3. If we are running the tunnel server on a subdomain, we must strip it from the provided hostname
+      if (options.subdomain) {
+        subdomain = subdomain.replace(`.${options.subdomain}`, '');
+      }
+
+      let subdomainSocket = socketsBySubdomain[subdomain];
+      if (!subdomainSocket) {
+        return reject(new Error(`${subdomain} is currently unregistered or offline.`));
+      }
+
+      if (req.connection.tunnelClientStream !== undefined && !req.connection.tunnelClientStream.destroyed && req.connection.subdomain === subdomain) {
+        return resolve(req.connection.tunnelClientStream);
+      }
+
+      let requestGUID = uuid();
+      ss(subdomainSocket).once(requestGUID, (tunnelClientStream) => {
+        req.connection.subdomain = subdomain;
+        req.connection.tunnelClientStream = tunnelClientStream;
+
+        // Pipe all data from tunnel stream to requesting connection
+        tunnelClientStream.pipe(req.connection);
+
+        resolve(tunnelClientStream);
+      });
+
+      subdomainSocket.emit('incomingClient', requestGUID);
+    });
+  }
+
+  function getReqLineFromReq (req) {
+    return `${req.method} ${req.url} HTTP/${req.httpVersion}`;
+  }
+
+  function getHeadersFromReq (req) {
+    const headers = [];
+
+    for (let i = 0; i < (req.rawHeaders.length - 1); i += 2) {
+      headers.push(req.rawHeaders[i] + ': ' + req.rawHeaders[i + 1]);
+    }
+
+    return headers;
+  }
+
+  function streamResponse (reqLine, headers, reqBody, tunnelClientStream) {
+    tunnelClientStream.write(reqLine);
+    tunnelClientStream.write('\r\n');
+    tunnelClientStream.write(headers.join('\r\n'));
+    tunnelClientStream.write('\r\n\r\n');
+    if (reqBody) {
+      tunnelClientStream.write(reqBody);
+    }
+  }
+
+  // socket.io instance
+  let io = require('socket.io')(server);
+  io.on('connection', (socket) => {
+    socket.on('createTunnel', (requestedName, responseCb) => {
+      if (socket.requestedName) {
+        // tunnel has already been created
+        return;
+      }
+
+      // domains are case insensitive
+      let reqNameNormalized = requestedName.toString().toLowerCase().replace(/[^0-9a-z-.]/g, '');
+
+      // make sure the client is requesting a valid subdomain
+      if (reqNameNormalized.length === 0 || !isValidDomain(`${reqNameNormalized}.example.com`)) {
+        console.log(new Date() + ': ' + reqNameNormalized + ' -- bad subdomain. disconnecting client.');
+        if (responseCb) {
+          responseCb('bad subdomain');
+        }
+        return socket.disconnect();
+      }
+
+      // make sure someone else hasn't claimed this subdomain
+      if (socketsBySubdomain[reqNameNormalized]) {
+        console.log(new Date() + ': ' + reqNameNormalized + ' requested but already claimed. disconnecting client.');
+        if (responseCb) {
+          responseCb('subdomain already claimed');
+        }
+        return socket.disconnect();
+      }
+
+      // store a reference to this socket by the subdomain claimed
+      socketsBySubdomain[reqNameNormalized] = socket;
+      socket.requestedName = reqNameNormalized;
+      console.log(new Date() + ': ' + reqNameNormalized + ' registered successfully');
+
+      if (responseCb) {
+        responseCb(null);
+      }
+    });
+
+    // when a client disconnects, we need to remove their association
+    socket.on('disconnect', () => {
+      if (socket.requestedName) {
+        delete socketsBySubdomain[socket.requestedName];
+        console.log(new Date() + ': ' + socket.requestedName + ' unregistered');
+      }
+    });
+  });
+
+  // http server
+  server.listen(options.port, options.hostname);
+
+  console.log(`${new Date()}: socket-tunnel server started on ${options.hostname}:${options.port}`);
+};