ssh_tunnel_proxy 1.2.11 → 2.0.1

package/README.md

@@ -7,16 +7,20 @@ In addition to the node api, a command line function called ssh-node2 is include
 
 ### Command line examples
 
+Initialize ssh2 command:
+```
+npm i ssh_tunnel_proxy -g
+```
 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
+ssh2-node -i=~/.ssh/<private_key> -L=8180:192.168.1.1:80 <username>@<hostname>
 ```
 
-Connect to host using parameters stored in ~/.config/ssh_tunnel_proxy/config.json:
+Connect to host with parameters stored in ~/.config/ssh_tunnel_proxy/config.json:
 
 ```
-./ssh2-node rh2
+ssh2-node rh2
 ```
 
 default config file, located at:
@@ -35,11 +39,88 @@ default config file, located at:
 }]
 ```
 
-Execute a series of commands on remote host
+Execute command on remote host
 ```
-./ssh-node2 rh2 -e='uptime' -e='ls -all'
+ssh2-node rh2 "ls -all"
 ```
 
+### List of command-line options (compatible with original ssh2 command):
+```
+Usage: ssh2-node [options] [userhost] [exec...]
+
+Nodejs ssh2 command line client
+
+Arguments:
+  userhost                                          Connect to hostname in config.
+  exec                                              Command to exec on remote host (must be in quotes)
+
+Options:
+  -V, --version                                     output the version number
+  -2 --protocolv2 [protocolv2]                      Forces ssh to try protocol version 2 only.
+  -4 --ipv4only [ipv4only]                          Forces ssh to use IPv4 addresses only.
+  -6 --ipv6only [ipv6only]                          Forces ssh to use IPv6 addresses only.
+  -A --forward_enable [forward_enable]              Enables forwarding of the authentication agent
+                                                    connection.
+  -a --forward_disable [forward_disable]            Disables forwarding of the authentication agent
+                                                    connection.
+  -b --bind [bind]                                  bind_address
+  -C --compress [compress]                          Requests compression of all data
+  -c --cipher [cipher]                              cipher_spec
+  -D --dynamic_forward [dynamic_forward]             Specifies a local 'dynamic' application-level
+                                                    port forwarding.
+  -e --escape [escape]                              escape_char Sets the escape character for
+                                                    sessions with a pty.
+  -F --config [config]                              configfile
+  -f --background [background]                      Requests ssh to go to background just before
+                                                    command execution.
+  -g --local_forward_remote [local_forward_remote]  Allows remote hosts to connect to local forwarded
+                                                    ports.
+  -I --smartcard [smartcard]                        smartcard_device Specify the device ssh.
+  -i --identity [identity]                          Private key filename.
+  -K --gssapi_auth [gssapi_auth]                    Enables GSSAPI-based authentication and
+                                                    forwarding (delegation) of GSSAPI credentials to
+                                                    the server.
+  -k --gssapi_disable [gssapi_disable]              Disables forwarding (delegation) of GSSAPI
+                                                    credentials to the server.
+  -L --local_forward_out [local_forward_out...]     bind_address:port:host:hostport
+  -l --login_name [login_name]                      login_name
+  -M --master_mode [master_mode]                    Places the ssh client into 'master' mode for
+                                                    connection sharing. Multiple -M options
+  -m --mac_spec [mac_spec]                          mac_spec
+  -N --no_exec [no_exec]                            Do not execute a remote command.
+  -n --redirect_stdin [redirect_stdin]              Redirects stdin from /dev/null
+  -O --ctl_cmd [ctl_cmd]                            ctl_cmd
+  -o --option [option]                              option
+  -p --port [port]                                  port Port to connect to on the remote host.
+  -q --quiet [quiet]                                Quiet mode. Causes most warning and diagnostic
+                                                    messages to be suppressed.
+  -R --local_forward_in [local_forward_in...]       bind_address:port:host:hostport
+  -S --ctl_path [ctl_path]                          ctl_path Specifies the location of a control
+                                                    socket for connection sharing.
+  -s --subsystem [subsystem]                        May be used to request invocation of a subsystem
+                                                    on the remote system.
+  -T --disable_tty [disable_tty]                    Disable pseudo-tty allocation.
+  -t --force_tty [force_tty]                        Force pseudo-tty allocation.
+  -V --version [version]                            Display the version number and exit.
+  -v --verbose [verbose]                            Verbose mode. Causes ssh to print debugging
+                                                    messages about its progress.
+  -W --forward_stdin_stdout [forward_stdin_stdout]  host:port Requests that standard input and output
+                                                    on the client be forwarded to host on port ver
+                                                    the secure channel.
+  -w --tunnel [tunnel]                              Requests tunnel device forwarding with the
+                                                    specified tun(4) devices between the client
+                                                    (local_tun) and the server (remote_tun).
+  -X --x11 [x11]                                    Enables X11 forwarding.
+  -x --x11_disable [x11_disable]                    Disables X11 forwarding.
+  -Y --x11_trusted [x11_trusted]                    Enables trusted X11 forwarding.
+  -y --log [log]                                    Send log information using the syslog(3)
+  -H --ngrok [ngrok]                                Obtain connectiion hostport from ngrok
+  -J --keychain_service [keychain_service]          Service name to obtain private key from system
+                                                    keychain.
+  -j --keychain_account [keychain_account]          Account name to obtain private key from system
+                                                    keychain.
+  -h, --help                                        display help for command
+```
 ### Api examples
 
 Exec remote commands using async await and processing result through streams.

package/dist/cjs/index.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Server, Socket } from 'net';
+import { Writable } from 'stream';
+import { EventEmitter } from 'events';
+import { Client, Channel } from 'electron-ssh2';
+import { KeypairStorage } from './keypair_storage';
+import { NgrokApi } from './ngrok_service';
+import { main } from './ssh2-node';
+interface Listener {
+    [key: string]: Server;
+}
+export type SSHConfig = {
+    hostname: string;
+    username: string;
+    password?: string;
+    host?: string;
+    port?: string;
+    proxy_ports?: Array<string>;
+    remote_ports?: Array<string>;
+    private_key?: string | null;
+    private_key_filename?: string | null;
+    disabled?: boolean;
+    server_name?: string;
+    service_name?: string;
+    compress?: string;
+    cypher?: string;
+    exec?: Array<string>;
+    shell?: boolean;
+    ngrok_api?: string;
+    keepaliveInterval?: number;
+};
+export declare class SSHTunnelProxy extends EventEmitter {
+    protected client: Client;
+    protected keypairStorage: KeypairStorage;
+    protected config: SSHConfig;
+    protected listener: Listener;
+    protected retries: number;
+    protected networkOnline: boolean;
+    protected _tunnelReadyTimeout: ReturnType<typeof setTimeout>;
+    debug_en: boolean;
+    debug_ssh: boolean;
+    constructor();
+    protected close_sockets(proxy_ports: Array<string>): void;
+    protected setup_ssh_forward(socket: Socket, remote_hostname: string, remote_port: string): void;
+    setupProxyPorts(proxy_ports: Array<string>): Promise<void>;
+    execCmd(cmd: string, dataStream?: Writable, errStream?: Writable): Promise<void>;
+    protected remote_shell(err: Error, stream: Channel): void;
+    protected cleanup_events(client: Client): void;
+    do_ssh_connect(opts: SSHConfig): Promise<void>;
+    validate_port_number(port: number, whitelist: object): boolean;
+    validate_local_forward(proxy_ports: Array<string>, whitelist: object): boolean;
+    protected ssh_retry_connect(opts: SSHConfig): void;
+    protected ssh_start_tunnel(opts: SSHConfig): Promise<unknown>;
+    connectSSH(opts: SSHConfig, whitelist: object | null): Promise<void>;
+    onNetworkOnline(): void;
+    onNetworkOffline(): void;
+    generateAndStoreKeypair(serviceName: string, account: string): void;
+    getPublicKey(serviceName: string, account: string): void;
+    getClient(): Client;
+    protected debug(...args: any[]): void;
+}
+export { KeypairStorage, NgrokApi, main as sshcli };

package/dist/cjs/index.js

@@ -0,0 +1,496 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sshcli = exports.NgrokApi = exports.KeypairStorage = exports.SSHTunnelProxy = void 0;
+var net_1 = require("net");
+var fs_1 = require("fs");
+var process_1 = require("process");
+var events_1 = require("events");
+var electron_ssh2_1 = require("electron-ssh2");
+var keypair_storage_1 = require("./keypair_storage");
+Object.defineProperty(exports, "KeypairStorage", { enumerable: true, get: function () { return keypair_storage_1.KeypairStorage; } });
+var ngrok_service_1 = require("./ngrok_service");
+Object.defineProperty(exports, "NgrokApi", { enumerable: true, get: function () { return ngrok_service_1.NgrokApi; } });
+var ssh2_node_1 = require("./ssh2-node");
+Object.defineProperty(exports, "sshcli", { enumerable: true, get: function () { return ssh2_node_1.main; } });
+var os_1 = require("os");
+var SSHTunnelProxy = (function (_super) {
+    __extends(SSHTunnelProxy, _super);
+    function SSHTunnelProxy() {
+        var _this = _super.call(this) || this;
+        _this.listener = {};
+        _this.retries = 0;
+        _this.debug_en = false;
+        _this.debug_ssh = false;
+        _this._tunnelReadyTimeout = undefined;
+        _this.networkOnline = false;
+        _this.config = null;
+        _this.client = new electron_ssh2_1.Client();
+        _this.keypairStorage = new keypair_storage_1.KeypairStorage();
+        return _this;
+    }
+    SSHTunnelProxy.prototype.close_sockets = function (proxy_ports) {
+        var _this = this;
+        if (!proxy_ports)
+            return;
+        proxy_ports.forEach(function (proxy_port) {
+            var 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];
+            }
+        });
+    };
+    SSHTunnelProxy.prototype.setup_ssh_forward = function (socket, remote_hostname, remote_port) {
+        var _this = this;
+        var on_setup_ssh_forward = function (err, stream) {
+            if (err) {
+                _this.emit('debug', err);
+                _this.debug_en && _this.debug('socket forward error:', err);
+                return;
+            }
+            stream.on('end', function () {
+                socket.resume();
+            });
+            stream.pipe(socket).pipe(stream);
+            var shutdown_forward = function () {
+                stream.unpipe(socket);
+                socket.unpipe(stream);
+                stream.end();
+            };
+            socket.on('close', function () {
+                shutdown_forward();
+            });
+            socket.on('error', function (err) {
+                _this.emit('debug', err);
+                _this.debug_en && _this.debug('socket on error:', err);
+                shutdown_forward();
+            });
+        };
+        this.client.forwardOut(socket.remoteAddress, socket.remotePort, remote_hostname, remote_port, on_setup_ssh_forward);
+    };
+    SSHTunnelProxy.prototype.setupProxyPorts = function (proxy_ports) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (!proxy_ports) {
+                resolve();
+                return;
+            }
+            var listeners = 0;
+            proxy_ports.forEach(function (proxy_port) {
+                var _a = proxy_port.split(':'), local_port = _a[0], remote_hostname = _a[1], remote_port = _a[2];
+                var server = _this.listener[proxy_port];
+                if (server && server.listening) {
+                    _this.debug_en && _this.debug('SSH Server :: closing forward 2:', proxy_port);
+                    server.close();
+                }
+                _this.listener[proxy_port] = (0, net_1.createServer)({ allowHalfOpen: false }, function (socket) {
+                    if (_this.debug_en) {
+                        var debug_msg = 'SSH Server :: connection on ' + local_port + ' ' + socket.remotePort;
+                        _this.emit('debug', debug_msg);
+                        _this.debug(debug_msg);
+                    }
+                    _this.setup_ssh_forward(socket, remote_hostname, remote_port);
+                });
+                try {
+                    var status_msg = 'SSH Server :: before listen on ' + local_port;
+                    _this.emit('debug', status_msg);
+                    _this.listener[proxy_port].listen(local_port, function () {
+                        var status_msg = 'SSH Server :: bound on ' + local_port;
+                        _this.emit('debug', status_msg);
+                        if (listeners++ >= proxy_ports.length - 1) {
+                            _this.emit('ssh_tunnel_ready', {});
+                            if (_this._tunnelReadyTimeout) {
+                                clearTimeout(_this._tunnelReadyTimeout);
+                                _this._tunnelReadyTimeout = undefined;
+                            }
+                            resolve();
+                        }
+                    });
+                }
+                catch (err) {
+                    _this.debug_en && _this.debug('listen err:', err);
+                    reject(err);
+                }
+            });
+        });
+    };
+    SSHTunnelProxy.prototype.execCmd = function (cmd, dataStream, errStream) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var remote_exec = function (err, stream) {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                var onClose = function () {
+                    stream.removeListener('close', onClose);
+                    resolve();
+                };
+                stream.on('close', onClose);
+                stream.on('data', function (data) {
+                    if (dataStream)
+                        dataStream.write(data);
+                    else
+                        process_1.stdout.write(data);
+                });
+                stream.stderr.on('data', function (data) {
+                    if (errStream)
+                        errStream.write(data);
+                    else
+                        process_1.stderr.write(data);
+                });
+            };
+            _this.client.exec(cmd, remote_exec);
+        });
+    };
+    SSHTunnelProxy.prototype.remote_shell = function (err, stream) {
+        var _this = this;
+        if (err)
+            throw err;
+        process_1.stdin.setRawMode(true);
+        var stdinData = function (data) {
+            stream.stdin.write(data);
+        };
+        process_1.stdin.on('data', stdinData);
+        var stdoutData = function (data) {
+            process_1.stdout.write(data);
+        };
+        stream.stdout.on('data', stdoutData);
+        stream
+            .on('close', function () {
+            process_1.stdin.setRawMode(false);
+            process_1.stdin.removeListener('data', stdinData);
+            stream.stdout.removeListener('data', stdoutData);
+            (0, process_1.exit)();
+        })
+            .stderr.on('data', function (data) {
+            _this.debug_en && _this.debug('shell' + data);
+        });
+    };
+    SSHTunnelProxy.prototype.cleanup_events = function (client) {
+        var eventNames = ['close', 'end', 'error', 'greeting', 'handshake', 'ready'];
+        for (var j = 0; j < eventNames.length; j++) {
+            var eventName = eventNames[j];
+            var events = client._events[eventName];
+            if (events) {
+                if (events instanceof Array) {
+                    for (var i = 0; i < events.length; i++) {
+                        client.removeListener(eventName, events[i]);
+                    }
+                }
+                if (events instanceof Function) {
+                    client.removeListener(eventName, events);
+                }
+            }
+        }
+    };
+    SSHTunnelProxy.prototype.do_ssh_connect = function (opts) {
+        var _this = this;
+        var _client = this.client;
+        return new Promise(function (resolve) {
+            _this.close_sockets(opts.proxy_ports);
+            _this.cleanup_events(_client);
+            _client.on('ready', function () { return __awaiter(_this, void 0, void 0, function () {
+                var i, cmd;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (this._tunnelReadyTimeout) {
+                                clearTimeout(this._tunnelReadyTimeout);
+                                delete this._tunnelReadyTimeout;
+                            }
+                            if (!opts.proxy_ports) return [3, 2];
+                            return [4, this.setupProxyPorts(opts.proxy_ports)];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2:
+                            if (!opts.shell) return [3, 3];
+                            this.client.shell(this.remote_shell);
+                            return [3, 7];
+                        case 3:
+                            if (!(opts.exec && opts.exec.length > 0)) return [3, 7];
+                            i = 0;
+                            _a.label = 4;
+                        case 4:
+                            if (!(i < opts.exec.length)) return [3, 7];
+                            cmd = opts.exec[i];
+                            this.debug_en && this.debug(opts.username + '@' + opts.hostname + ':' + cmd);
+                            return [4, this.execCmd(cmd)];
+                        case 5:
+                            _a.sent();
+                            _a.label = 6;
+                        case 6:
+                            i++;
+                            return [3, 4];
+                        case 7:
+                            resolve();
+                            return [2];
+                    }
+                });
+            }); });
+            _client.on('end', function () {
+                _this.debug_en && _this.debug('SSH Client :: end');
+                _this.close_sockets(opts.proxy_ports);
+            });
+            _client.on('close', function () {
+                _this.debug_en && _this.debug('SSH Client :: close');
+                _this.close_sockets(opts.proxy_ports);
+            });
+            _client.on('error', function (err) {
+                _this.debug_en && _this.debug('SSH Client :: error :: ' + err);
+                _this.emit('debug', err);
+                if (_this._tunnelReadyTimeout) {
+                    clearTimeout(_this._tunnelReadyTimeout);
+                    _this._tunnelReadyTimeout = undefined;
+                }
+                _this.ssh_retry_connect(opts);
+                resolve();
+            });
+            var config = JSON.parse(JSON.stringify(opts));
+            config.debug = _this.debug_ssh
+                ? function () {
+                    var args = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        args[_i] = arguments[_i];
+                    }
+                    console.log.apply(console, args);
+                }
+                : null;
+            config.keepaliveInterval = opts.keepaliveInterval || 10000;
+            var 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]];
+            _client.connect(config);
+        });
+    };
+    SSHTunnelProxy.prototype.validate_port_number = function (port, whitelist) {
+        if (isNaN(port))
+            return false;
+        if (port < 1 || port > 65535)
+            return false;
+        if (port < 1024 && whitelist && whitelist[port] === undefined)
+            return false;
+        return true;
+    };
+    SSHTunnelProxy.prototype.validate_local_forward = function (proxy_ports, whitelist) {
+        var _this = this;
+        if (!proxy_ports)
+            return;
+        var local_ports = [];
+        var remote_ports = [];
+        proxy_ports.forEach(function (proxy_port) {
+            var _a = proxy_port.split(':'), local_port = _a[0], remote_hostname = _a[1], remote_port = _a[2];
+            var ilocal_port = parseInt(local_port);
+            var iremote_port = parseInt(remote_port);
+            if (remote_hostname.length < 1)
+                remote_ports.push(remote_port);
+            if (!_this.validate_port_number(ilocal_port, whitelist))
+                local_ports.push(local_port);
+            if (!_this.validate_port_number(iremote_port, whitelist))
+                remote_ports.push(remote_port);
+        });
+        if (local_ports.length || remote_ports.length) {
+            var err = new Error('Invalid local forward');
+            this.debug_en &&
+                this.debug('invalid ports found:\n', JSON.stringify(proxy_ports, null, 2), '\n', JSON.stringify(whitelist, null, 2));
+            throw err;
+        }
+        return true;
+    };
+    SSHTunnelProxy.prototype.ssh_retry_connect = function (opts) {
+        var _this = this;
+        var invoke = function () {
+            _this.connectSSH(opts, null);
+        };
+        if (this.retries++ < 10)
+            this._tunnelReadyTimeout = setTimeout(invoke, 5000);
+    };
+    SSHTunnelProxy.prototype.ssh_start_tunnel = function (opts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var do_ssh_connect;
+            var _this = this;
+            return __generator(this, function (_a) {
+                do_ssh_connect = function (resolve) { return __awaiter(_this, void 0, void 0, function () {
+                    var _this = this;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4, this.do_ssh_connect(opts).then(function () {
+                                    var hostport = opts.host + ':' + opts.port;
+                                    if (_this.debug_en) {
+                                        var msg = 'SSH connection to ' + opts.server_name + ' established at ' + hostport;
+                                        _this.debug(msg);
+                                    }
+                                    _this.emit('status', '', 'ready', hostport);
+                                    _this.retries = 0;
+                                    resolve();
+                                })];
+                            case 1:
+                                _a.sent();
+                                return [2];
+                        }
+                    });
+                }); };
+                return [2, new Promise(do_ssh_connect)];
+            });
+        });
+    };
+    SSHTunnelProxy.prototype.connectSSH = function (opts, whitelist) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _opts, _a, ngrokApi, hostport, err;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _opts = JSON.parse(JSON.stringify(opts));
+                        _opts.whitelist = whitelist !== undefined ? whitelist : _opts.whitelist ? _opts.whitelist : null;
+                        try {
+                            this.validate_local_forward(_opts.proxy_ports, _opts.whitelist);
+                        }
+                        catch (err) {
+                            this.emit('debug', err);
+                            this.debug_en && this.debug(err);
+                            throw (err);
+                        }
+                        if (opts.password && !opts.password.length) {
+                            _opts.password = undefined;
+                        }
+                        if (_opts.private_key_filename) {
+                            try {
+                                if (_opts.private_key_filename[0] == '~') {
+                                    _opts.private_key_filename = os_1.homedir + _opts.private_key_filename.substr(1);
+                                }
+                                _opts.privateKey = (0, fs_1.readFileSync)(_opts.private_key_filename).toString();
+                            }
+                            catch (err) {
+                                console.log('Error loading key:', err);
+                                throw (err);
+                            }
+                        }
+                        if (!(_opts.service_name && _opts.server_name)) return [3, 2];
+                        _a = _opts;
+                        return [4, this.keypairStorage.get_keypair(opts.service_name, opts.server_name)];
+                    case 1:
+                        _a.privateKey = _b.sent();
+                        return [3, 3];
+                    case 2:
+                        if (!_opts.server_name)
+                            _opts.server_name = 'sshtun';
+                        _b.label = 3;
+                    case 3:
+                        if (!_opts.ngrok_api) return [3, 5];
+                        ngrokApi = new ngrok_service_1.NgrokApi(_opts.ngrok_api);
+                        return [4, ngrokApi.get_hostport().catch(function () {
+                                _this.debug_en && _this.debug('ngrok get_hostport connection error');
+                                _this.ssh_retry_connect(_opts);
+                            })];
+                    case 4:
+                        hostport = _b.sent();
+                        if (hostport && hostport.host) {
+                            _opts.host = hostport.host;
+                            _opts.port = hostport.port;
+                        }
+                        else {
+                            err = new Error('invalid hostport obtained from ngrok api');
+                            throw (err);
+                        }
+                        _b.label = 5;
+                    case 5:
+                        this.debug_en && this.debug('connectSSH.ts:\n', JSON.stringify(_opts, null, 2));
+                        return [4, this.ssh_start_tunnel(_opts).catch(function (err) {
+                                _this.debug_en && _this.debug('ssh_start_tunnel catch:' + err);
+                            })];
+                    case 6:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    SSHTunnelProxy.prototype.onNetworkOnline = function () {
+        this.networkOnline = true;
+    };
+    SSHTunnelProxy.prototype.onNetworkOffline = function () {
+        this.networkOnline = false;
+    };
+    SSHTunnelProxy.prototype.generateAndStoreKeypair = function (serviceName, account) {
+        this.keypairStorage.generate_and_store_keypair(serviceName, account);
+    };
+    SSHTunnelProxy.prototype.getPublicKey = function (serviceName, account) {
+        this.keypairStorage.get_public_key_from_keychain(serviceName, account);
+    };
+    SSHTunnelProxy.prototype.getClient = function () {
+        return this.client;
+    };
+    SSHTunnelProxy.prototype.debug = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        console.log.apply(console, args);
+    };
+    return SSHTunnelProxy;
+}(events_1.EventEmitter));
+exports.SSHTunnelProxy = SSHTunnelProxy;
+//# sourceMappingURL=index.js.map