ssh_tunnel_proxy 1.2.9 → 1.2.11

package/README.md

@@ -1,94 +1,107 @@
 # ssh_tunnel_proxy
 Initiate a ssh reverse tunnel proxy with forwarding ports
 
-ssh_tunnel_proxy can function as a stand-alone api, nodejs command line script or as part of an electron_js app. To setup a ssh tunnel, parameters are suppled for host, port, authentication and a list of proxy ports. If a ngrok api key is provided the host and port of the ngrok tunnel are obtained. A list of port forwards is provided and is validated to restrict connections to system ports on the remote host to a list of pre-defined ports such as http or https. After establishing a ssh connection on the remote server, local proxy port forwards are opened. If the connection is interrupted or connection errors occur, attempts are made re-establish the tunnel.
+ssh_tunnel_proxy is a wrapper to ssh2 that provides async functionality as well as an extension to the api to include methods to setup a list of proxy forwards, exec a list of commands or startup a terminal shell. To setup a ssh tunnel, parameters are suppled for host, port, authentication and a list of proxy ports or commands to invoke. If a ngrok api key is provided the host and port of the ngrok tunnel are obtained. If the connection is interrupted or connection errors occur, attempts are made re-establish the tunnel.
 
-Example command line to establish a list of local forwards:
+In addition to the node api, a command line function called ssh-node2 is included to start ssh sessions in a manner similar to the ssh command line utility.
+
+### Command line examples
+
+Connect to remote host and establish local forwards:
+
+```
+./ssh2-node -u=<username> -h=192.168.1.1 -k=~/.ssh/<private_key> -L=8180:192.168.1.1:80
+```
+
+Connect to host using parameters stored in ~/.config/ssh_tunnel_proxy/config.json:
 
 ```
-node main.js -c
+./ssh2-node rh2
 ```
 
 default config file, located at:
 ~/.config/ssh_tunnel_proxy/config.json
 ```json
 [{
-  "enabled": true,
+  "hostname":"rh2",
   "username": "<username>",
-  "password": "",
-  "host": "",
-  "port": "",
   "proxy_ports": [
     "8280:127.0.0.1:80",
     "9000:127.0.0.1:9000",
     "8122:192.168.2.1:22"
   ],
-  "whitelist": {
-    "80": true,
-    "443": true,
-    "22": true
-  },
-  "service_name": "ssh_proxy_client",
-  "server_name": "test",
+  "private_key_filename":"~/.ssh/<private key>",
   "ngrok_api": "<ngrok api key>"
 }]
 ```
 
-Command line to execute a series of commands on remote host:
+Execute a series of commands on remote host
 ```
-node main.js -c -e='uptime' -e='ls -all'
+./ssh-node2 rh2 -e='uptime' -e='ls -all'
 ```
 
-Or execute commands defined in default config:
-```
-node main.js -c
-```
-```json
-[{
-  "enabled": true,
-  "username": "<username>",
-  "service_name": "ssh_proxy_client",
-  "server_name": "test",
-  "exec" : [
-    "uptime",
-    "ls -all"
-  ],
-  "ngrok_api": "<ngrok api key>"
-}]
-```
+### Api examples
 
-Start a terminal session on the remote host:
-```
-node main.js -c -S
-```
-
-Example use of api to exec remote commands using async await and processing result through streams. Complete example is in test/test_remote_exec_streams.js:
+Exec remote commands using async await and processing result through streams.
 
 ```js
-async function test_exec_stream(opts) {
-    sshTunnelProxy.debug_en = true;
-    await sshTunnelProxy.connectSSH(opts);
-
-    // exec remote command and save result to string
-    const uptime_result = await sshTunnelProxy.execCmd('uptime');
-    console.log('uptime:' + uptime_result.toString());
-
-    // exec remote command and pipe data through tunnel until end of data
-    const tunnel = new PassThrough();
-    tunnel.pipe(split())
-        .pipe(to_ls_JSON)
-        .pipe(to_JSON_string)
-        .pipe(process.stdout);
-
-    await sshTunnelProxy.execCmd('ls -all', tunnel);
-
-    // stream processing complete
-    console.log('done');
-    process.exit();
+// send result of cmd through pipeline, generating a stream of json objects
+function lsTest(cmdProxy, cmd, destination) {
+
+    return new Promise( (resolveCmd) => {
+
+             // set input of pipeline to split data into lines (npm i split)
+            const tunnel = split();
+
+            // when pipeline is ready exec shell cmd
+            const pipelineReady = (socket) => {
+
+                return new Promise((resolve) => {
+
+                  // invoke command on remote host and send results to pipeline
+                  cmdProxy.execCmd(cmd, tunnel)
+
+                        // stream processing complete, cleanup pipeline and exit
+                        .then(() => {
+                            //self.cleanupPipeline(socket);
+                            resolveCmd();
+                        });
+                    resolve();
+                })
+            }
+
+            // pipe shell cmd result through json parser pipeline to destination
+            pipeline(tunnel,
+                self.parse(),
+                self.toJSONString(),
+                destination,
+                pipelineReady
+            );
+    })
+}
+
+async function runCmd() {
+
+  const opts = {
+    "hostname":"rh2",
+    "username": "<username>",
+    "private_key_filename":"~/.ssh/<private key>",
+    "ngrok_api": "<ngrok api key>"
+  }
+
+  const sshTunnelProxy = new SSHTunnelProxy();
+
+  // connect to remote host
+  await sshTunnelProxy.connectSSH(opts);
+
+  // invoke ls -all on remote host and parse result to json object string
+  await lsTest(sshTunnelProxy, 'ls -all', process.stdout);
 }
+
+runCmd();
 ```
 
-The following code is an example of use of the api with electronjs.
+Example of use of the api with electronjs.
 
 main.js:
 ```js

package/lib/index.js

@@ -17,6 +17,7 @@ License: MIT
 */
 
 const net = require('net');
+const fs = require('fs');
 const process = require('process');
 const { Buffer } = require('node:buffer');
 const { Client } = require('electron-ssh2');
@@ -26,6 +27,8 @@ const NgrokApi = require('./ngrok_service');
 
 const keypairStorage = new KeypairStorage();
 
+const homedir = require('os').homedir();
+
 class SSHTunnelProxy extends Client {
 
     constructor() {
@@ -38,15 +41,16 @@ class SSHTunnelProxy extends Client {
     }
 
     // function to close all active sockets for tunnel restart and exception handling
-    close_sockets(server_name, proxy_ports) {
+    close_sockets(proxy_ports) {
 
-        if (!this.listener[server_name]) return;
+        if (!proxy_ports) return;
 
         proxy_ports.forEach(proxy_port => {
-            const server = this.listener[server_name][proxy_port];
+            const server = this.listener[proxy_port];
             if (server && server.listening) {
                 this.debug_en && this.debug('SSH Server :: closing forward:', proxy_port)
                 server.close();
+                delete this.listener[proxy_port];
             }
         });
     }
@@ -102,12 +106,17 @@ class SSHTunnelProxy extends Client {
     }
 
     // function to setup proxy forwards for ssh tunnel
-    setupProxyPorts(server_name, proxy_ports) {
+    setupProxyPorts(proxy_ports) {
 
         return new Promise((resolve, reject) => {
 
+            if (!proxy_ports) {
+                resolve();
+                return;
+            }
+
             var listeners = 0;
-            if (this.listener[server_name]) this.listener[server_name].isConnected = true;
+            this.listener.isConnected = true;
             const _this = this;
 
             // iterate through a list of local forward ports and create a local proxy port
@@ -116,13 +125,12 @@ class SSHTunnelProxy extends Client {
                 const [local_port, remote_hostname, remote_port] = proxy_port.split(':');
 
                 // create local socket server
-                const server = this.listener[server_name][proxy_port];
+                const server = _this.listener[proxy_port];
                 if (server && server.listening) {
-                    this.debug_en && this.debug('SSH Server :: closing forward 2:', proxy_port)
+                    _this.debug_en && this.debug('SSH Server :: closing forward 2:', proxy_port)
                     server.close();
                 }
-                this.listener[server_name][proxy_port] = null;
-                this.listener[server_name][proxy_port] = net.createServer({ keepAlive: true, allowHalfOpen: false }, socket => {
+                _this.listener[proxy_port] = net.createServer({ keepAlive: true, allowHalfOpen: false }, socket => {
 
                     if (this.debug_en) {
                         var debug_msg = 'SSH Server :: connection on ' + local_port + ' ' + socket.remotePort;
@@ -138,7 +146,7 @@ class SSHTunnelProxy extends Client {
                 try {
                     var status_msg = 'SSH Server :: before listen on ' + local_port;
                     _this.emit('debug', status_msg);
-                    _this.listener[server_name][proxy_port].listen(local_port, () => {
+                    _this.listener[proxy_port].listen(local_port, () => {
 
                         // emit server listening on port message
                         var status_msg = 'SSH Server :: bound on ' + local_port;
@@ -149,7 +157,7 @@ class SSHTunnelProxy extends Client {
                             _this.emit('ssh_tunnel_ready', {});
                             if (_this._tunnelReadyTimeout) {
                                 clearTimeout(this._tunnelReadyTimeout);
-                                _this._tunnelReadyTimeout = undefined
+                                _this._tunnelReadyTimeout = undefined;
                             }
                             resolve();
                         }
@@ -173,27 +181,24 @@ class SSHTunnelProxy extends Client {
                     reject(err);
                     return;
                 }
-                stream.on('close', () => {
+
+                const onClose = () => {
                     var buf = Buffer.concat(bufs);
                     var err = Buffer.concat(errs);
+                    stream.removeListener('close', onClose);
                     resolve(buf, err);
-                })
-
-                if (dataStream) {
-                    stream.pipe(dataStream);
-                } else {
-                    stream.on('data', (data) => {
-                        bufs.push(data);
-                    })
                 }
+                stream.on('close', onClose);
 
-                if (errStream) {
-                    stream.stderr.pipe(errStream);
-                } else {
-                    stream.stderr.on('data', (data) => {
-                        errs.push(data);
-                    });
-                }
+                stream.on('data', (data) => {
+                    if (dataStream) dataStream.write(data);
+                    else bufs.push(data);
+                })
+
+                stream.stderr.on('data', (data) => {
+                    if (errStream) errStream.write(data);
+                    else errs.push(data);
+                });
 
             }
             this.exec(cmd, remote_exec);
@@ -238,14 +243,10 @@ class SSHTunnelProxy extends Client {
         return new Promise((resolve) => {
 
             // exit if connection already established, avoid redundant connection on retry
-            if (_this.listener[opts.server_name] && _this.listener[opts.server_name].isConnected) resolve();
+            if (_this.listener.isConnected) resolve();
 
             // close open sockets on server, otherwise initialize open sockets storage
-            if (_this.listener[opts.server_name]) {
-                _this.close_sockets(opts.server_name, opts.proxy_ports);
-            } else {
-                _this.listener[opts.server_name] = {};
-            }
+            _this.close_sockets(opts.proxy_ports);
 
             _this.on('ready', async () => {
 
@@ -255,47 +256,48 @@ class SSHTunnelProxy extends Client {
                     _this._tunnelReadyTimeout = undefined;
                 }
 
+                // if local forwarding requested, setup local forwarding ports to remote host
+                if (opts.proxy_ports) {
+                    await _this.setupProxyPorts(opts.proxy_ports);
+                }
+
                 // if shell requested, enable remote terminal
                 if (opts.shell) {
                     _this.shell(_this.remote_shell);
 
-                // if exec requested, exec series of cmds
+                    // otherwise, if exec requested, exec series of cmds
                 } else {
                     if (opts.exec && opts.exec.length > 0) {
                         for (var i = 0; i < opts.exec.length; i++) {
                             var cmd = opts.exec[i];
-                            console.log(opts.username + '@' + opts.hostname + ':' + cmd);
+                            _this.debug_en && _this.debug(opts.username + '@' + opts.hostname + ':' + cmd);
                             var result = await _this.execCmd(cmd);
-                            console.log(result.toString());
+                            _this.debug_en && _this.debug(result.toString());
                         }
                         process.exit();
                     }
                 }
 
-                // if local forward requested, setup local forwarding ports to remote host
-                if (opts.proxy_ports) {
-                    await _this.setupProxyPorts(opts.server_name, opts.proxy_ports);
-                }
                 resolve();
             });
 
             _this.on('end', () => {
                 _this.debug_en && _this.debug('SSH Client :: end');
-                _this.close_sockets(opts.server_name, opts.proxy_ports);
+                _this.close_sockets(opts.proxy_ports);
             });
 
             _this.on('close', () => {
                 _this.debug_en && _this.debug('SSH Client :: close');
-                _this.close_sockets(opts.server_name, opts.proxy_ports);
+                _this.close_sockets(opts.proxy_ports);
             });
 
             _this.on('error', err => {
                 _this.debug_en && _this.debug('SSH Client :: error :: ' + err);
                 _this.emit('debug', err);
-                if (_this.listener[opts.server_name]) _this.listener[opts.server_name].isConnected = false;
+                _this.listener.isConnected = false;
                 if (_this._tunnelReadyTimeout) {
-                    clearTimeout(this._tunnelReadyTimeout);
-                    _this._tunnelReadyTimeout = undefined
+                    clearTimeout(this._tunnelReadyTimeout.elReadyTimeout);
+                    _this._tunnelReadyTimeout = undefined;
                 }
                 _this.ssh_retry_connect(opts);
                 resolve();
@@ -309,19 +311,19 @@ class SSHTunnelProxy extends Client {
                 _this.debug_en && _this.debug('SSH Client :: greeting:', message);
             });
 
-            // initiate ssh client connection to remote host
-            // ssh client debug function for verbose ssh connection details
-            const debug_client = (this.debug_ssh) ? (...args) => { console.log(...args); } : null;
-            _this.connect({
-                host: opts.host,
-                port: opts.port,
-                username: opts.username,
-                password: opts.password,
-                privateKey: opts.private_key,
-                debug: debug_client,
-                keepaliveInterval: 10000
-            });
+            // create deep copy of opts as connect options
+            const config = JSON.parse(JSON.stringify(opts));
+
+            // add default ssh2 config options
+            config.debug = (this.debug_ssh) ? (...args) => { console.log(...args); } : null;
+            config.keepaliveInterval = opts.keepaliveInterval || 10000;
 
+            // remove ssh_tunnel_proxy config extensions
+            const ssh_tunnel_extensions = ['alias', 'disabled', 'hostname', 'ngrok_api', 'server_name', 'service_name', 'whitelist', 'private_key_filename'];
+            for (var i = 0; i < ssh_tunnel_extensions.length; i++) delete config[ssh_tunnel_extensions[i]];
+
+            // connect to remote host
+            _this.connect(config);
         });
     }
 
@@ -330,7 +332,7 @@ class SSHTunnelProxy extends Client {
         if (isNaN(port_str)) return false;
         const port = parseInt(port_str);
         if (port < 1 || port > 65535) return false;
-        if (port < 1024 && whitelist[port] === undefined) return false;
+        if (port < 1024 && whitelist && whitelist[port] === undefined) return false;
         return true;
     }
 
@@ -396,13 +398,11 @@ class SSHTunnelProxy extends Client {
     // todo: if opts have changed while service is running, shutdown current service and restart with new opts
     async connectSSH(opts, whitelist) {
 
-        this.debug_en && this.debug('connectSSH:\n', JSON.stringify(opts, null, 2));
-
         // make deep copy of opts for modification
         var _opts = JSON.parse(JSON.stringify(opts));
 
         // setup whitelist from param or opts in case of error retry
-        _opts.whitelist = (whitelist !== undefined) ? whitelist : (_opts.whitelist) ? _opts.whitelist : {};
+        _opts.whitelist = (whitelist !== undefined) ? whitelist : (_opts.whitelist) ? _opts.whitelist : null;
 
         // validate local port forwards, emit error and quit if invalid
         try {
@@ -418,9 +418,24 @@ class SSHTunnelProxy extends Client {
             _opts.password = undefined;
         }
 
+        if (_opts.private_key_filename) {
+            try {
+                if (_opts.private_key_filename[0] == '~') {
+                    _opts.private_key_filename = homedir + _opts.private_key_filename.substr(1);
+                }
+                _opts.privateKey = fs.readFileSync(_opts.private_key_filename).toString();
+            } catch (err) {
+                console.log('Error loading key:', err);
+            }
+        }
+
         // retrieve private key from system keychain with supplied service name and server
         // if no key found, authentication is supplied username, password
-        _opts.private_key = await keypairStorage.get_keypair(opts.service_name, opts.server_name);
+        if (_opts.service_name && _opts.server_name) {
+            _opts.privateKey = await keypairStorage.get_keypair(opts.service_name, opts.server_name);
+        } else {
+            if (!_opts.server_name) _opts.server_name = 'sshtun';
+        }
 
         // if ngrok api key provided, obtain hostname and hostport from ngrok api
         // if no ngrok tunnel specified, use supplied host and port
@@ -430,7 +445,7 @@ class SSHTunnelProxy extends Client {
             var hostport = await ngrokApi.get_hostport()
                 .catch(() => {
                     _this.debug_en && _this.debug('ngrok get_hostport connection error');
-                    if (this.listener[opts.server_name]) this.listener[opts.server_name].isConnected = false;
+                    _this.listener.isConnected = false;
                     _this.ssh_retry_connect(_opts);
                 });
             if (hostport && hostport.host) {
@@ -440,6 +455,8 @@ class SSHTunnelProxy extends Client {
             else return null;
         }
 
+        this.debug_en && this.debug('connectSSH:\n', JSON.stringify(_opts, null, 2));
+
         // initiate ssh tunnel, block until tunnel is established or error
         return await this.ssh_start_tunnel(_opts)
             .catch((err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh_tunnel_proxy",
-  "version": "1.2.9",
+  "version": "1.2.11",
   "description": "obtain ngrok host port from api and establish a ssh connection",
   "main": "lib/index.js",
   "scripts": {

package/{main.js → ssh2-node}

@@ -1,3 +1,4 @@
+#!/usr/bin/node
 const process = require('process');
 const fs = require('fs');
 const { SSHTunnelProxy, KeypairStorage } = require('./lib/index.js');
@@ -21,14 +22,6 @@ var service = null;
 var account = null;
 var shell = null;
 
-function get_key_from_file(filename) {
-    try {
-        return fs.readFileSync(filename);
-    } catch (err) {
-        console.log('Error loading key:', err);
-    }
-}
-
 function get_config(filename) {
     try {
         configs = JSON.parse(fs.readFileSync(filename), 'utf8');
@@ -41,7 +34,7 @@ function get_default_config() {
     try {
         configs = JSON.parse(fs.readFileSync(homedir + '/.config/ssh_tunnel_proxy/config.json'), 'utf8');
     } catch (err) {
-        console.log('Error loading config file:', err);
+        //console.log('Error loading config file:', err);
     }
 }
 
@@ -114,15 +107,21 @@ function main(args) {
                 username = value;
                 break;
             default:
-                if (i > 1) console.log('Invalid argument:', arg);
+                if (i == 2) remote_host = cmd;
+                if (i > 2) console.log('Invalid argument:', arg);
         }
     }
 
     // prevent process from exiting
-    process.stdin.resume();
+    //process.stdin.resume();
 
-    // if no config file specified, build config from args
+    // if no config file specified attempt to load default config
     if (!configs) {
+        get_default_config();
+    }
+
+    // no default config build config from args
+    if (!remote_host) {
         var config = {
             enabled: true,
             username: username,
@@ -140,24 +139,28 @@ function main(args) {
     }
 
     // process each tunnel config in ssh proxy tunnel list
+    var remote_server = null;
     configs.forEach(async config => {
 
         // skip tunnel if not enabled
-        if (!config.enabled) return;
+        if (config.disabled) return;
 
         // if remote host specified, only select tunnel for remote host
-        if (remote_host && remote_host !== config.alias) return;
+        if (remote_host && remote_host !== config.hostname) return;
+        config.server_name = config.hostname || remote_host || 'ssh_tunnel_proxy';
+        remote_server = remote_host;
 
         // if system key storage name specified get key from system keychain
         if (config.server_name) {
             const service_name = config.service_name || 'ssh_tunnel_proxy';
             config.private_key = await keypairStorage.get_keypair(service_name, config.server_name);
         }
+
         // if private key filename specified, read private key
-        else if (config.private_key) {
-            config.private_key = get_key_from_file(config.private_key);
+        if (privateKey) {
+            config.private_key_filename = privateKey;
         }
-        if (shell) {
+        if (shell || exec.length === 0) {
             config.shell = true;
         }
         if (exec.length > 0) {
@@ -169,7 +172,9 @@ function main(args) {
         sshTunnelProxy.debug_en = debug;
         sshTunnelProxy.connectSSH(config);
     });
-
+    if (remote_host && !remote_server) {
+        console.log(`Remote host ${remote_host} not found`);
+    }
 
 }
 

package/test/test_remote_exec.js

@@ -0,0 +1,217 @@
+/*
+test exec cmd on remote server, parse to json object stream
+*/
+
+//const assert = require('assert');
+//const { describe, it } = require('mocha');
+
+const fs = require('fs');
+const process = require('node:process');
+const { SSHTunnelProxy } = require('..');
+const { PassThrough, pipeline } = require("stream");
+const through = require('through');
+const split = require('split');
+
+// get config file containing api keys
+const homedir = require('os').homedir();
+var config = null;
+try {
+    config = JSON.parse(fs.readFileSync(homedir + '/.config/ssh_tunnel_proxy/config.json'), 'utf8');
+} catch (err) {
+    console.log('Error reading config:' + err);
+    process.exit();
+}
+
+if (!config && !config[1]) {
+    console.log('Specified config not found in configs');
+    process.exit();
+}
+
+const opts = config[1];
+
+const sshTunnelProxy = new SSHTunnelProxy();
+
+// parse shell command result into array of strings
+function parse_cmd(str) {
+
+    let result = [];
+
+    let regex = /(([\w-/_~.\:\[\]]+)|("(.*?)")|('(.*?)'))/g;
+    let groups = [2, 4, 6];
+    let match;
+
+    while ((match = regex.exec(str)) !== null) {
+        // This is necessary to avoid infinite loops 
+        // with zero-width matches
+        if (match.index === regex.lastIndex) {
+            regex.lastIndex++;
+        }
+
+        // For this to work the regex groups need to 
+        // be mutually exclusive
+        groups.forEach(function (group) {
+            if (match[group]) {
+                result.push(match[group]);
+            }
+        });
+        /*
+        let log_matches = false;
+        // show matches for debugging
+        log_matches && match.forEach(function (m, group) {
+            if (m) {
+                console.log(`Match '${m}' found in group: ${group}`);
+            }
+        });
+        */
+    }
+    return result;
+}
+
+// generate object from arrays of names/values
+function toObj(names, values) {
+    const obj = {};
+    for (var i = 0; i < names.length; i++) {
+        obj[names[i]] = values[i];
+    }
+    return obj;
+}
+
+
+// merge array items beginning at start into single item and append back to array
+function mergeArray(ar, start) {
+    const ar2 = ar.slice(start);
+    const ar1 = ar.slice(0, start);
+    const item = ar2.join(' ');
+    ar1.push(item);
+    return ar1;
+}
+
+/*
+Feb  4 21:34:17 tim-ThinkPad-P50s systemd[1]: Started Run anacron jobs.
+*/
+function parseSyslog(line) {
+    const format = ['M', 'D', 'T', 'host', 'proc', 'msg'];
+    const values = parse_cmd(line);
+    const log = mergeArray(values, 5);
+    const obj = toObj(format, log);
+    if (obj.M && obj.D && obj.T) {
+        obj.date = obj.M + ' ' + obj.D + ' ' + obj.T;
+        delete obj.M;
+        delete obj.D;
+        delete obj.T;
+    }
+    return obj;
+}
+
+// parse ls long line output into json object
+function processLSLong(line) {
+    const format10 = ['pm', 'links', 'user', 'group', 'size', 'M', 'D', 'H', 'MM', 'name'];
+    const format9 = ['pm', 'links', 'user', 'group', 'size', 'M', 'D', 'Y', 'name'];
+    const values = parse_cmd(line);
+    const obj = toObj((values.length < 10) ? format9 : format10, values);
+    if (obj.pm) {
+        obj.type = obj.pm.substring(0, 1);
+        obj.pm = obj.pm.substring(1);
+    }
+    if (obj.M && obj.D) {
+        obj.date = obj.M + ' ' + obj.D;
+        delete obj.M;
+        delete obj.D;
+        if (obj.Y) {
+            obj.date += ' ' + obj.Y;
+            delete obj.Y;
+        }
+    }
+    if (obj.H && obj.MM) {
+        obj.time = obj.H + ':' + obj.MM;
+        delete obj.H;
+        delete obj.MM;
+    }
+    return obj;
+}
+
+function to_lsParse() {
+    return new through(function (data) {
+        const obj = processLSLong(data);
+        if (obj.name) this.queue(obj);
+    });
+}
+
+function to_syslogParse() {
+    return new through(function (data) {
+        const obj = parseSyslog(data);
+        if (obj.proc) this.queue(obj);
+    });
+}
+
+function to_JSONString() {
+    return new through(function (data) {
+        this.queue(JSON.stringify(data) + '\n');
+    })
+}
+
+// lsLongShellProc conversion tests
+async function lsTest(sshTunnelProxy) {
+    return new Promise(async (resolve) => {
+
+        // exec remote command and pipe data through tunnel until end of data
+        const tunnel = new PassThrough();
+        pipeline(tunnel,
+            split(),
+            to_lsParse(),
+            to_JSONString(),
+            process.stdout,
+            () => { }
+        );
+
+        const lscmd = 'ls -all';
+        console.log('\ninvoking ' + lscmd + ' on remote host:\n');
+        await sshTunnelProxy.execCmd(lscmd, tunnel);
+
+        // stream processing complete
+        console.log('ls -all completed');
+        resolve();
+    })
+}
+
+// lsLongShellProc conversion tests
+async function syslogTest(sshTunnelProxy) {
+    return new Promise(async (resolve) => {
+
+        // exec remote command and pipe data through tunnel until end of data
+        const tunnel = new PassThrough();
+        pipeline(tunnel,
+            split(),
+            to_syslogParse(),
+            to_JSONString(),
+            process.stdout,
+            () => { }
+        );
+        const syslogcmd = 'tail /var/log/syslog';
+        console.log('\ninvoking ' + syslogcmd + ' on remote host:\n');
+        await sshTunnelProxy.execCmd(syslogcmd, tunnel);
+
+        // stream processing complete
+        console.log(syslogcmd+' completed');
+        resolve();
+    })
+}
+
+async function runTests() {
+
+    // connect to remote host
+    sshTunnelProxy.debug_en = true;
+    await sshTunnelProxy.connectSSH(opts);
+
+    // invoke ls -all on remote host and parse result to json object string
+    await lsTest(sshTunnelProxy);
+
+    // invoke tail /var/log/syslog on remote host and parse result to json object string
+    await syslogTest(sshTunnelProxy);
+
+    process.exit();
+}
+
+runTests();
+
+

package/test/test_remote_exec_streams.js

@@ -1,140 +0,0 @@
-/*
-
-test remote exec streams
-
-*/
-
-//const assert = require('assert');
-//const { describe, it } = require('mocha');
-const process = require('process');
-const fs = require('fs');
-const { PassThrough } = require("stream");
-const through = require('through');
-const split = require('split');
-
-const { SSHTunnelProxy } = require('../lib/index.js');
-
-// get config file containing api keys
-const homedir = require('os').homedir();
-var config = null;
-try {
-    config = JSON.parse(fs.readFileSync(homedir + '/.config/ssh_tunnel_proxy/config.json'), 'utf8');
-} catch (err) {
-    console.log('Error reading config');
-    process.exit();
-}
-
-if (!config && !config[1]) {
-    console.log('Specified config not found in configs');
-    process.exit();
-}
-
-const opts = config[1];
-
-const sshTunnelProxy = new SSHTunnelProxy();
-
-// parse shell command result into array of strings
-function parse_cmd(str) {
-
-    let result = [];
-    let log_matches = false;
-
-    let regex = /(([\w-/_~]+)|("(.*?)")|('(.*?)'))/g;
-    let groups = [2, 4, 6];
-    let match;
-
-    while ((match = regex.exec(str)) !== null) {
-        // This is necessary to avoid infinite loops 
-        // with zero-width matches
-        if (match.index === regex.lastIndex) {
-            regex.lastIndex++;
-        }
-
-        // For this to work the regex groups need to 
-        // be mutually exclusive
-        groups.forEach(function (group) {
-            if (match[group]) {
-                result.push(match[group]);
-            }
-        });
-
-        // show matches for debugging
-        log_matches && match.forEach(function (m, group) {
-            if (m) {
-                console.log(`Match '${m}' found in group: ${group}`);
-            }
-        });
-    }
-    return result;
-}
-
-// generate object from arrays of names/values
-function toObj(names, values) {
-    const obj = {};
-    for (var i = 0; i < names.length; i++) {
-        obj[names[i]] = values[i];
-    }
-    return obj;
-}
-
-// stream that receives single line of ls long data and converts to json object
-const to_ls_JSON = new through(function (data) {
-    const file = processLSLong(data);
-    if (file.name) this.queue(file);
-});
-
-// stream that receives objects and converts to JSON strings
-const to_JSON_string = new through(function (data) {
-    this.queue(JSON.stringify(data) + '\n');
-});
-
-// parse ls long line output into json object
-function processLSLong(line) {
-    const format10 = ['pm', 'links', 'user', 'group', 'size', 'M', 'D', 'H', 'MM', 'name'];
-    const format9 = ['pm', 'links', 'user', 'group', 'size', 'M', 'D', 'Y', 'name'];
-    const values = parse_cmd(line);
-    const obj = toObj((values.length < 10) ? format9 : format10, values);
-    if (obj.pm) {
-        obj.type = obj.pm.substring(0, 1);
-        obj.pm = obj.pm.substring(1);
-    }
-    if (obj.M && obj.D) {
-        obj.date = obj.M + ' ' + obj.D;
-        delete obj.M;
-        delete obj.D;
-        if (obj.Y) {
-            obj.date += ' ' + obj.Y;
-            delete obj.Y;
-        }
-    }
-    if (obj.H && obj.MM) {
-        obj.time = obj.H + ':' + obj.MM;
-        delete obj.H;
-        delete obj.MM;
-    }
-    return obj;
-}
-
-async function test_exec_stream() {
-    sshTunnelProxy.debug_en = true;
-    await sshTunnelProxy.connectSSH(opts);
-
-    // exec remote command and save result to string
-    const uptime_result = await sshTunnelProxy.execCmd('uptime');
-    console.log('uptime:' + uptime_result.toString());
-
-    // exec remote command and pipe data through tunnel until no data
-    const tunnel = new PassThrough();
-    tunnel.pipe(split())
-        .pipe(to_ls_JSON)
-        .pipe(to_JSON_string)
-        .pipe(process.stdout);
-
-    await sshTunnelProxy.execCmd('ls -all', tunnel);
-
-    // stream processing complete
-    console.log('done');
-    process.exit();
-}
-
-test_exec_stream();