hsync 0.9.0 → 0.10.0

package/Readme.md

@@ -5,7 +5,6 @@
 Client for the ([hsync-server](https://github.com/monteslu/hsync-server)).
 Share your local webserver as a secure public URL, and more.
 
-
 ## basic usage
 
 clone repo
@@ -27,6 +26,3 @@ set enviroment:
 ### run
 `node index`
 
-
-
-

package/cli.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+const { program, Option } = require('commander');
+const pack = require('./package.json');
+const config = require('./config');
+const { createConnection } = require('./hsync');
+
+program
+  .name(pack.name)
+  .description(pack.description)
+  .version(pack.version)
+  .addOption(new Option('-p, --port <number>', 'port for local webserver', 3000).env('PORT'))
+  .addOption(new Option('-d, --dynamic-host <url>', 'host to get a dynamic connection from').env('HSYNC_DYNAMIC_HOST'))
+  .addOption(new Option('-s, --hsync-server <url>', 'hsync-server location ex: wss://sub.mydomain.com').env('HSYNC_SERVER'))
+  .addOption(new Option('-p, --hsync-password <url>', 'password to connect to hsync-server').env('HSYNC_SECRET'));
+
+program.parse();
+
+const options = program.opts();
+
+console.log(options);
+
+const [defaultCon] = config.connections;
+if (!defaultCon.hsyncServer && !defaultCon.dynamicHost) {
+  defaultCon.dynamicHost = config.defaultDynamicHost;
+}
+
+config.connections.forEach(async (conConfig) => {
+  const con = await createConnection(conConfig);
+  console.log('Listening for requests on: ', con.webUrl);
+  console.log('Secret: ', con.hsyncSecret);
+  console.log('Admin instance at: ', con.webAdmin);
+});

package/config.js

@@ -1,10 +1,12 @@
 const baseConfig = {
-  hsyncServer: process.env.HSYNC_SERVER || 'ws://localhost:3101',
+  hsyncServer: process.env.HSYNC_SERVER, // something like 'wss://mydevice.mydomain.com'
   hsyncSecret: process.env.HSYNC_SECRET, // keep it secret, keep it safe!
   localHost: process.env.LOCAL_HOST || 'localhost', // host of local server
   port: process.env.PORT || 3000, // port of local server
   hsyncBase: process.env.HSYNC_BASE || '_hs',
-  keepalive: parseInt(process.env.HSYNC_KEEP_ALIVE) || 60,
+  keepalive: parseInt(process.env.HSYNC_KEEP_ALIVE) || 300,
+  dynamicHost: process.env.HSYNC_DYNAMIC_HOST,
+  defaultDynamicHost: 'https://demo.hsync.tech',
 };
 
 
@@ -23,7 +25,8 @@ keys.forEach((k) => {
         port: process.env['PORT_' + name] || baseConfig.port,
         hsyncBase: process.env['HSYNC_BASE_' + name] || baseConfig.hsyncBase,
         keepalive: parseInt(process.env['HSYNC_KEEP_ALIVE_' + name]) || baseConfig.keepalive,
-      })
+        dynamicHost: process.env['HSYNC_DYNAMIC_HOST_' + name],
+      });
     }
   }
 })

package/connection.js

@@ -1,27 +1,61 @@
-const mqtt = require('mqtt');
+const fetch = require('isomorphic-fetch');
 const EventEmitter = require('events').EventEmitter;
 const b64id = require('b64id');
 const debug = require('debug')('hsync:info');
 const debugVerbose = require('debug')('hsync:verbose');
 const debugError = require('debug')('hsync:error');
 const { createRPCPeer, createServerReplyPeer } = require('./lib/rpc');
-const createWebHandler = require('./lib/web-handler');
-const createSocketListenHandler = require('./lib/socket-listen-handler');
+const { createWebHandler, setNet: webSetNet } = require('./lib/web-handler');
+const { createSocketListenHandler, setNet: listenSetNet } = require('./lib/socket-listen-handler');
 
 debug.color = 3;
 debugVerbose.color = 2;
 debugError.color = 1;
 
-function createHsync(config) {
-  const {
+let mqtt;
+
+function setNet(netImpl) {
+  webSetNet(netImpl);
+  listenSetNet(netImpl);
+}
+
+function setMqtt(mqttImpl) {
+  mqtt = mqttImpl;
+}
+
+async function createHsync(config) {
+  let {
     hsyncServer,
     hsyncSecret,
     localHost,
     port,
     hsyncBase,
-    keepalive
+    keepalive,
+    dynamicHost,
   } = config;
 
+  let dynamicTimeout;
+
+  if (dynamicHost) {
+    const options = {
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      method: 'POST',
+      body: '{}',
+    };
+    const resp = await fetch(`${dynamicHost}/${hsyncBase}/dyn`, options);
+    const result = await resp.json();
+    // console.log('resutl', result);
+    if (dynamicHost.toLowerCase().startsWith('https')) {
+      hsyncServer = `wss://${result.url}`;
+    } else {
+      hsyncServer = `ws://${result.url}`;
+    }
+    hsyncSecret = result.secret;
+    dynamicTimeout = result.timeout;
+  }
+
   const hsyncClient = {};
   hsyncClient.config = config;
   const peers = {};
@@ -53,7 +87,11 @@ function createHsync(config) {
   });
 
   mqConn.on('error', (error) => {
-    debugError('error on mqConn', myHostName, error);
+    debugError('error on mqConn', myHostName, error.code, error);
+    if ((error.code === 4) || (error.code === 5)) {
+      debug('ending');
+      mqConn.end();
+    }
   });
 
   mqConn.on('message', (topic, message) => {
@@ -180,10 +218,21 @@ function createHsync(config) {
   hsyncClient.serverReplyMethods = serverReplyMethods;
   hsyncClient.getPeer = getPeer;
   hsyncClient.peerMethods = peerMethods;
+  hsyncClient.hsyncSecret = hsyncSecret;
+  hsyncClient.hsyncServer = hsyncServer;
+  hsyncClient.dynamicTimeout = dynamicTimeout;
+  if (hsyncServer.toLowerCase().startsWith('wss://')) {
+    hsyncClient.webUrl = `https://${myHostName}`;
+  } else {
+    hsyncClient.webUrl = `https://${myHostName}`;
+  }
+  hsyncClient.webAdmin = `${hsyncClient.webUrl}/${hsyncBase}/admin`;
 
   return hsyncClient;
 }
 
 module.exports = {
   createHsync,
+  setNet,
+  setMqtt,
 };

package/hsync-web.js

@@ -0,0 +1,56 @@
+const mqtt = require('precompiled-mqtt');
+const buffer = require('buffer');
+const net = require('net-web');
+const { createHsync, setNet, setMqtt } = require('./connection');
+const config = require('./config');
+
+// TODO need to make this work with web/service workers
+window.Buffer = buffer.Buffer;
+
+setNet(net);
+setMqtt(mqtt);
+
+async function dynamicConnect(dynamicHost, useLocalStorage) {
+  let con;
+  if (useLocalStorage) {
+    const localConfigStr = localStorage.getItem('hsyncConfig');
+    if (localConfigStr) {
+      const localConfig = JSON.parse(localConfigStr);
+      if ((Date.now() - localConfig.created) < (localConfig.timeout * 0.66)) {
+        config.hsyncSecret = localConfig.hsyncSecret;
+        config.hsyncServer = localConfig.hsyncServer;
+      }
+    }
+  
+    if (!config.hsyncSecret) {
+      config.dynamicHost = dynamicHost || config.defaultDynamicHost;
+    }
+  
+    con = await createHsync(config);
+  
+    if (config.dynamicHost) {
+      const storeConfig = {
+        hsyncSecret: con.hsyncSecret,
+        hsyncServer: con.hsyncServer,
+        timeout: con.dynamicTimeout,
+        created: Date.now(),
+      };
+      localStorage.setItem('hsyncConfig', JSON.stringify(storeConfig));
+    }
+
+    return con;
+  }
+
+  config.dynamicHost = dynamicHost || config.defaultDynamicHost;
+  con = await createHsync(config);
+
+  return con;
+  
+}
+
+module.exports = {
+  createConnection: createHsync,
+  dynamicConnect,
+  net,
+  config,
+};

package/hsync.js

@@ -0,0 +1,23 @@
+const net = require('net');
+const mqtt = require('mqtt');
+const { createHsync, setNet, setMqtt } = require('./connection');
+const config = require('./config');
+
+setNet(net);
+setMqtt(mqtt);
+
+async function dynamicConnect(dynamicHost) {
+  let con;
+
+  config.dynamicHost = dynamicHost || config.defaultDynamicHost;
+  con = await createHsync(config);
+
+  return con;
+}
+
+module.exports = {
+  createConnection: createHsync,
+  dynamicConnect,
+  config,
+};
+

package/index.js

@@ -1,7 +1,11 @@
-
 const config = require('./config');
-const { createHsync } = require('./connection');
+const { createConnection } = require('./hsync');
+
+const [defaultCon] = config.connections;
+if (!defaultCon.hsyncServer && !defaultCon.dynamicHost) {
+  defaultCon.dynamicHost = config.defaultDynamicHost;
+}
 
 config.connections.forEach((conConfig) => {
-  const con = createHsync(conConfig);
-});
+  const con = createConnection(conConfig);
+});

package/lib/socket-listen-handler.js

@@ -1,12 +1,16 @@
-const net = require('net');
 const debug = require('debug')('hsync:listener');
 const debugError = require('debug')('hsync:error');
 
 const { createRPCPeer } = require('./rpc');
 
 debugError.color = 1;
+let net;
 
-function createHandler({hostName, port, targetPort, targetHost, hsyncClient}) {
+function setNet(netImpl) {
+  net = netImpl;
+}
+
+function createSocketListenHandler({hostName, port, targetPort, targetHost, hsyncClient}) {
   debug('creating handler', hostName, port, targetPort, targetHost);
 
   const sockets = {};
@@ -63,7 +67,6 @@ function createHandler({hostName, port, targetPort, targetHost, hsyncClient}) {
       socket.end();
     }
     
-
   });
 
   socketServer.listen(port);
@@ -89,4 +92,7 @@ function createHandler({hostName, port, targetPort, targetHost, hsyncClient}) {
   };
 }
 
-module.exports = createHandler;
+module.exports = {
+  createSocketListenHandler,
+  setNet,
+};

package/lib/socket-relay-handler.js

@@ -1,4 +1,3 @@
-const net = require('net');
 const debug = require('debug')('hsync:relay');
 const debugError = require('debug')('hsync:error');
 
@@ -6,13 +5,19 @@ const { createRPCPeer } = require('./rpc');
 
 debugError.color = 1;
 
+let net;
+
+function setNet(netImpl) {
+  net = netImpl;
+}
+
 function createHandler({hostName, port, targetPort, targetHost, hsyncClient}) {
 
   const sockets = {};
   
   const peer = createRPCPeer({hostName, hsyncClient});
 
-  const socketServer = net.createServer((socket) => {
+  const socketServer = net.createServer(async (socket) => {
 
     socket.socketId = b64id.generateId();
     sockets[socket.socketId] = socket;
@@ -85,4 +90,7 @@ function createHandler({hostName, port, targetPort, targetHost, hsyncClient}) {
   };
 }
 
-module.exports = createHandler;
+module.exports = {
+  createHandler,
+  setNet,
+};

package/lib/web-handler.js

@@ -1,10 +1,15 @@
-const net = require('net');
 const debug = require('debug')('hsync:web');
 const debugError = require('debug')('hsync:error');
 
 debugError.color = 1;
 
-function createHanlder({myHostName, localHost, port, mqConn}) {
+let net;
+
+function setNet(netImpl) {
+  net = netImpl;
+}
+
+function createWebHandler({myHostName, localHost, port, mqConn}) {
 
   const sockets = {};
 
@@ -26,11 +31,6 @@ function createHanlder({myHostName, localHost, port, mqConn}) {
         socket = new net.Socket();
         socket.socketId = socketId;
         sockets[socketId] = socket;
-        socket.connect(port, localHost, () => {
-          debug(`\nCONNECTED TO ${localHost}:${port}`, socket.socketId);
-          debug('← ' + message.slice(0, 200).toString().split('\r\n')[0], message.length);
-          socket.write(message);
-        });
         socket.on('data', (data) => {
           if (!socket.dataRecieved) {
             const logData = data.slice(0, 200).toString().split('\r\n')[0];
@@ -51,6 +51,11 @@ function createHanlder({myHostName, localHost, port, mqConn}) {
           delete sockets[socket.socketId];
           debugError('error connecting', localHost, port, err);
         });
+        socket.connect(port, localHost, () => {
+          debug(`\nCONNECTED TO ${localHost}:${port}`, socket.socketId);
+          debug('← ' + message.slice(0, 200).toString().split('\r\n')[0], message.length);
+          socket.write(message);
+        });
         return;
       }
 
@@ -80,4 +85,7 @@ function createHanlder({myHostName, localHost, port, mqConn}) {
   };
 }
 
-module.exports = createHanlder;
+module.exports = { 
+  createWebHandler,
+  setNet,
+};

package/lib/web-net.js

@@ -0,0 +1,67 @@
+const EventEmitter = require('events').EventEmitter;
+
+const events = new EventEmitter();
+
+const listeners = {};
+
+function Socket() {
+  const socket = new EventEmitter();
+  
+  socket.connect = function(port, host, clientCallback) {
+    events.emit(('socket_connect_' + port), {
+      port,
+      host,
+      clientSocket: socket,
+      clientCallback,
+    });  
+  }
+
+  socket.write = function(message) {
+    if (socket.serverSocket) {
+      socket.serverSocket.emit('data', message);
+    }
+  };
+
+  socket.end = function() {
+    if (socket.serverSocket) {
+      socket.serverSocket.emit('close');
+    }
+    
+  }
+
+  return socket;
+}
+
+function createServer(cb) {
+  const server = new EventEmitter();
+  server.listen = (port) => {
+    console.log('server.listen', port);
+    listeners['l' + port] = server;
+    events.on('socket_connect_' + port, ({ clientSocket, clientCallback }) => {
+      console.log('socket_connect_' + port, clientSocket);
+      const serverSocket = new EventEmitter();
+      clientSocket.serverSocket = serverSocket;
+      if (server.cb) {
+        server.cb(serverSocket);
+      }
+      serverSocket.write = (data) => {
+        clientSocket.emit('data', data);
+      }
+      serverSocket.end = () => {
+        clientSocket.emit('close');
+      }
+      
+      if (clientCallback) {
+        clientCallback();
+      }
+    });
+  };
+  server.cb = cb;
+  return server;
+}
+
+module.exports = {
+  Socket,
+  createServer,
+  events,
+};

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "hsync",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "client for hsync-server",
-  "main": "index.js",
+  "main": "hsync.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "dev": "nodemon --inspect index.js",
@@ -19,15 +19,26 @@
     "websocket",
     "mqtt"
   ],
+  "browser": {
+    "./hsync": "./hsync-web"
+  },
+  "bin": {
+    "hsync": "./cli.js"
+  },
   "author": "Luis Montes",
   "license": "ISC",
   "dependencies": {
     "b64id": "^1.0.0",
+    "buffer": "^6.0.3",
+    "commander": "^10.0.0",
     "debug": "^4.3.1",
+    "isomorphic-fetch": "^3.0.0",
     "mqtt": "^4.2.6",
+    "net-web": "^0.2.0",
+    "precompiled-mqtt": "^4.3.14-beta",
     "rawr": "^0.14.0"
   },
   "devDependencies": {
-    "nodemon": "^2.0.7"
+    "nodemon": "^2.0.20"
   }
 }