hsync 0.30.1 → 0.31.0

package/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [22, 24]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Lint
+        run: npm run lint
+
+      - name: Test
+        run: npm run test:run

package/.husky/pre-commit

@@ -0,0 +1 @@
+npx lint-staged

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "trailingComma": "es5",
+  "printWidth": 100
+}

package/Readme.md

@@ -1,5 +1,6 @@
 # hsync
 
+[![CI](https://github.com/monteslu/hsync/actions/workflows/ci.yml/badge.svg)](https://github.com/monteslu/hsync/actions/workflows/ci.yml)
 [![NPM](https://nodei.co/npm/hsync.svg)](https://nodei.co/npm/hsync/)
 
 hsync is a [reverse-proxy](https://en.wikipedia.org/wiki/Reverse_proxy) client for node.js and browsers that connects to an [hsync-server](https://github.com/monteslu/hsync-server).

package/cli.js

@@ -1,82 +1,129 @@
 #!/usr/bin/env node
 
-const { program, Option } = require('commander');
+import { program, Option } from 'commander';
+import { createRequire } from 'module';
+import config from './config.js';
+import { createConnection } from './hsync.js';
+import shell from './shell.js';
+
+// For JSON imports (package.json)
+const require = createRequire(import.meta.url);
 const pack = require('./package.json');
-const config = require('./config');
-const { createConnection } = require('./hsync');
-const shell = require('./shell');
 
 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('-hs, --hsync-secret <string>', 'password to connect to hsync-server').env('HSYNC_SECRET'))
-  .addOption(new Option('-llp, --listener-local-port <number>', 'local port to open for listener').env('HSYNC_LLP'))
-  .addOption(new Option('-lth, --listener-target-host <url>', 'target host for listener').env('HSYNC_LTH'))
-  .addOption(new Option('-ltp, --listener-target-port <number>', 'target port for listener').env('HSYNC_LTP'))
-  .addOption(new Option('-rip, --relay-inbound-port <number>', 'inbound port for remote relay requests').env('HSYNC_RIP'))
-  .addOption(new Option('-rth, --relay-target-host <url>', 'target host for relay to open tcp connection on').env('HSYNC_RTH'))
-  .addOption(new Option('-rtp, --relay-target-port <number>', 'target port for relay to open tcp connection on').env('HSYNC_RTP'))
-  .addOption(new Option('-rwl, --relay-whitelist <string>', 'whitelist of domains that can access this relay').env('HSYNC_RWL'))
-  .addOption(new Option('-rbl, --relay-blacklist <string>', 'blacklist of domains that should be blocked from this relay').env('HSYNC_RBL'))
-  .addOption(new Option('-sh, --shell', 'shell to localhost and --port for piping data to a listener'));
+  .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('-hs, --hsync-secret <string>', 'password to connect to hsync-server').env(
+      'HSYNC_SECRET'
+    )
+  )
+  .addOption(
+    new Option('-llp, --listener-local-port <number>', 'local port to open for listener').env(
+      'HSYNC_LLP'
+    )
+  )
+  .addOption(
+    new Option('-lth, --listener-target-host <url>', 'target host for listener').env('HSYNC_LTH')
+  )
+  .addOption(
+    new Option('-ltp, --listener-target-port <number>', 'target port for listener').env('HSYNC_LTP')
+  )
+  .addOption(
+    new Option('-rip, --relay-inbound-port <number>', 'inbound port for remote relay requests').env(
+      'HSYNC_RIP'
+    )
+  )
+  .addOption(
+    new Option(
+      '-rth, --relay-target-host <url>',
+      'target host for relay to open tcp connection on'
+    ).env('HSYNC_RTH')
+  )
+  .addOption(
+    new Option(
+      '-rtp, --relay-target-port <number>',
+      'target port for relay to open tcp connection on'
+    ).env('HSYNC_RTP')
+  )
+  .addOption(
+    new Option(
+      '-rwl, --relay-whitelist <string>',
+      'whitelist of domains that can access this relay'
+    ).env('HSYNC_RWL')
+  )
+  .addOption(
+    new Option(
+      '-rbl, --relay-blacklist <string>',
+      'blacklist of domains that should be blocked from this relay'
+    ).env('HSYNC_RBL')
+  )
+  .addOption(
+    new Option('-sh, --shell', 'shell to localhost and --port for piping data to a listener')
+  );
 
 program.parse();
 
 const options = program.opts();
 
-if(options.port) {
+if (options.port) {
   options.port = Number(options.port);
 }
 
 if (options.shell) {
   shell(options.port);
-  return;
-}
+} else {
+  if (options.listenerLocalPort) {
+    options.listenerLocalPort = options.listenerLocalPort.split(',').map((p) => Number(p));
+  }
+  if (options.listenerTargetHost) {
+    options.listenerTargetHost = options.listenerTargetHost.split(',');
+  }
+  if (options.listenerTargetPort) {
+    options.listenerTargetPort = options.listenerTargetPort.split(',').map((p) => Number(p));
+  }
 
-if(options.listenerLocalPort) {
-  options.listenerLocalPort = options.listenerLocalPort.split(',').map((p) => Number(p));
-}
-if (options.listenerTargetHost) {
-  options.listenerTargetHost = options.listenerTargetHost.split(',');
-}
-if (options.listenerTargetPort) {
-  options.listenerTargetPort = options.listenerTargetPort.split(',').map((p) => Number(p));
-}
+  if (options.relayInboundPort) {
+    options.relayInboundPort = options.relayInboundPort.split(',').map((p) => Number(p));
+  }
+  if (options.relayTargetHost) {
+    options.relayTargetHost = options.relayTargetHost.split(',');
+  }
+  if (options.relayTargetPort) {
+    options.relayTargetPort = options.relayTargetPort.split(',').map((p) => Number(p));
+  }
 
+  // console.log('options', options);
 
-if (options.relayInboundPort) {
-  options.relayInboundPort = options.relayInboundPort.split(',').map((p) => Number(p));
-}
-if (options.relayTargetHost) {
-  options.relayTargetHost = options.relayTargetHost.split(',');
-}
-if (options.relayTargetPort) {
-  options.relayTargetPort = options.relayTargetPort.split(',').map((p) => Number(p));
-}
-
-// console.log('options', options);
+  let [defaultCon] = config.connections;
+  defaultCon = { ...defaultCon, ...options };
 
+  if (!defaultCon.hsyncServer && !defaultCon.dynamicHost) {
+    defaultCon.dynamicHost = config.defaultDynamicHost;
+  }
 
-let [defaultCon] = config.connections;
-defaultCon = {...defaultCon, ...options};
+  config.connections[0] = defaultCon;
 
-if (!defaultCon.hsyncServer && !defaultCon.dynamicHost) {
-  defaultCon.dynamicHost = config.defaultDynamicHost;
+  config.connections.forEach(async (conConfig) => {
+    const con = await createConnection(conConfig);
+    console.log();
+    console.log('Listening for requests on: ', con.webUrl);
+    console.log('And forwarding to: ', 'http://localhost:' + con.port);
+    console.log();
+    console.log('Admin ui at: ', con.webAdmin);
+    console.log('Secret: ', con.hsyncSecret);
+    console.log();
+  });
 }
-
-config.connections[0] = defaultCon;
-
-config.connections.forEach(async (conConfig) => {
-  const con = await createConnection(conConfig);
-  console.log();
-  console.log('Listening for requests on: ', con.webUrl);
-  console.log('And forwarding to: ', 'http://localhost:' + con.port);
-  console.log();
-  console.log('Admin ui at: ', con.webAdmin);
-  console.log('Secret: ', con.hsyncSecret);
-  console.log();
-});

package/config.js

@@ -1,4 +1,4 @@
-const p = globalThis.process || {env: {}};
+const p = globalThis.process || { env: {} };
 const { env } = p;
 
 const baseConfig = {
@@ -13,11 +13,10 @@ const baseConfig = {
   another: 'another',
 };
 
-
 const connections = [baseConfig];
 const keys = Object.keys(env);
 keys.forEach((k) => {
-  if(k.startsWith('HSYNC_SERVER_')) {
+  if (k.startsWith('HSYNC_SERVER_')) {
     const name = k.substring(13);
     const value = env[k];
     if (name && value) {
@@ -33,8 +32,9 @@ keys.forEach((k) => {
       });
     }
   }
-})
+});
 
-const config = Object.assign({}, baseConfig, {connections});
+const config = Object.assign({}, baseConfig, { connections });
 
-module.exports = config;
+export default config;
+export { baseConfig, connections };

package/connection.js

@@ -1,18 +1,14 @@
-const EventEmitter = require('events').EventEmitter;
-const debug = require('debug')('hsync:info');
-const debugVerbose = require('debug')('hsync:verbose');
-const debugError = require('debug')('hsync:error');
-const { initPeers } = require('./lib/peers');
-const { createWebHandler, setNet: webSetNet } = require('./lib/web-handler');
-const { 
-  setNet: listenSetNet,
-  initListeners,
-} = require('./lib/socket-listeners');
-const {
-  setNet: relaySetNet,
-  initRelays,
-} = require('./lib/socket-relays');
-const fetch = require('./lib/fetch');
+import { EventEmitter } from 'events';
+import createDebug from 'debug';
+import { initPeers } from './lib/peers.js';
+import { createWebHandler, setNet as webSetNet } from './lib/web-handler.js';
+import { setNet as listenSetNet, initListeners } from './lib/socket-listeners.js';
+import { setNet as relaySetNet, initRelays } from './lib/socket-relays.js';
+import fetch from './lib/fetch.js';
+
+const debug = createDebug('hsync:info');
+const debugVerbose = createDebug('hsync:verbose');
+const debugError = createDebug('hsync:error');
 
 debug.color = 3;
 debugVerbose.color = 2;
@@ -20,25 +16,22 @@ debugError.color = 1;
 
 let mqtt;
 
-function setNet(netImpl) {
+export function setNet(netImpl) {
   webSetNet(netImpl);
   listenSetNet(netImpl);
   relaySetNet(netImpl);
 }
 
-function setMqtt(mqttImpl) {
+export function setMqtt(mqttImpl) {
   mqtt = mqttImpl;
 }
 
-async function createHsync(config) {
-  let {
-    hsyncServer,
-    hsyncSecret,
+export async function createHsync(config) {
+  const {
     localHost,
     port,
     hsyncBase,
     keepalive,
-    dynamicHost,
     listenerLocalPort,
     listenerTargetHost,
     listenerTargetPort,
@@ -46,6 +39,8 @@ async function createHsync(config) {
     relayTargetHost,
     relayTargetPort,
   } = config;
+  const { dynamicHost } = config;
+  let { hsyncServer, hsyncSecret } = config;
 
   // console.log('config', config);
 
@@ -73,12 +68,12 @@ async function createHsync(config) {
   hsyncClient.relays = initRelays(hsyncClient);
 
   const events = new EventEmitter();
-  
+
   hsyncClient.on = events.on.bind(events);
   hsyncClient.emit = events.emit.bind(events);
   hsyncClient.removeListener = events.removeListener.bind(events);
   hsyncClient.removeAllListeners = events.removeAllListeners.bind(events);
-  
+
   let lastConnect;
   const hsu = new URL(hsyncServer.toLowerCase());
   // console.log(hsu);
@@ -93,18 +88,27 @@ async function createHsync(config) {
   // console.log('connectURL', connectURL);
   const myHostName = hsu.hostname;
   hsyncClient.myHostName = myHostName;
-  
-  debug('connecting to', connectURL, '…' );
-  const mqConn = mqtt.connect(connectURL, { password: hsyncSecret, username: myHostName, keepalive });
+
+  debug('connecting to', connectURL, '…');
+  const mqConn = mqtt.connect(connectURL, {
+    password: hsyncSecret,
+    username: myHostName,
+    keepalive,
+  });
   mqConn.myHostName = myHostName;
   hsyncClient.mqConn = mqConn;
 
-  const webHandler = config.webHandler || createWebHandler({myHostName, localHost, port, mqConn});
+  const webHandler = config.webHandler || createWebHandler({ myHostName, localHost, port, mqConn });
   hsyncClient.webHandler = webHandler;
 
   mqConn.on('connect', () => {
     const now = Date.now();
-    debug('connected to', myHostName, lastConnect ? (now - lastConnect) : '', lastConnect ? 'since last connect' : '');
+    debug(
+      'connected to',
+      myHostName,
+      lastConnect ? now - lastConnect : '',
+      lastConnect ? 'since last connect' : ''
+    );
     lastConnect = now;
     hsyncClient.emit('connected', config);
     hsyncClient.status = 'connected';
@@ -112,7 +116,7 @@ async function createHsync(config) {
 
   mqConn.on('error', (error) => {
     debugError('error on mqConn', myHostName, error.code, error);
-    if ((error.code === 4) || (error.code === 5)) {
+    if (error.code === 4 || error.code === 5) {
       debug('ending');
       mqConn.end();
       // if (globalThis.process) {
@@ -127,8 +131,8 @@ async function createHsync(config) {
       return;
     }
     // message is Buffer
-    const [name, hostName, segment3, action, segment5] = topic.split('/');
-    debugVerbose('\n↓ MQTT' , topic);
+    const [name, hostName, segment3, action] = topic.split('/');
+    debugVerbose('\n↓ MQTT', topic);
     if (name === 'web') {
       webHandler.handleWebRequest(hostName, segment3, action, message);
       return;
@@ -139,15 +143,13 @@ async function createHsync(config) {
           const msg = JSON.parse(message.toString());
           msg.from = from;
           hsyncClient.emit('json', msg);
-        } catch (e) {
+        } catch (_e) {
           debugError('error parsing json message');
         }
-      }
-      else if (!action && (segment3 === 'srpc')) {
+      } else if (!action && segment3 === 'srpc') {
         hsyncClient.serverPeer.transport.receiveData(message.toString());
       }
     }
-
   });
 
   function endClient(force, callback) {
@@ -167,7 +169,7 @@ async function createHsync(config) {
       if (callback) {
         callback(a, b);
       }
-    })
+    });
   }
 
   const serverReplyMethods = {
@@ -182,7 +184,7 @@ async function createHsync(config) {
       requestInfo.hsyncClient = hsyncClient;
       const { msg } = requestInfo;
       debug('peerRpc handler', requestInfo.fromHost, msg.method);
-      const peer = hsyncClient.peers.getRPCPeer({hostName: requestInfo.fromHost, hsyncClient});
+      const peer = hsyncClient.peers.getRPCPeer({ hostName: requestInfo.fromHost, hsyncClient });
       requestInfo.peer = peer;
       if (!msg.id) {
         // notification
@@ -190,9 +192,9 @@ async function createHsync(config) {
           msg.params.unshift(peer);
         }
         peer.transport.emit('rpc', msg);
-        return { result: {}, id: msg.id};
+        return { result: {}, id: msg.id };
       }
-      const reply = {id: msg.id, jsonrpc:'2.0'};
+      const reply = { id: msg.id, jsonrpc: '2.0' };
       try {
         if (!peer.localMethods[msg.method]) {
           const notFoundError = new Error('method not found');
@@ -210,7 +212,7 @@ async function createHsync(config) {
         };
         return reply;
       }
-    }
+    },
   };
 
   const peerMethods = {
@@ -251,7 +253,7 @@ async function createHsync(config) {
   } else {
     hsyncClient.webUrl = hsyncServer;
   }
-  
+
   debug('URL', hsu.host, hsu.protocol, hsyncClient.webUrl);
   hsyncClient.webAdmin = `${hsyncClient.webUrl}/${hsyncBase}/admin`;
   hsyncClient.webBase = `${hsyncClient.webUrl}/${hsyncBase}`;
@@ -289,9 +291,3 @@ async function createHsync(config) {
 
   return hsyncClient;
 }
-
-module.exports = {
-  createHsync,
-  setNet,
-  setMqtt,
-};