Include compiled files in git

Author: Paxa

.gitignore

@@ -1,4 +1,4 @@
 .nyc_output
 node_modules/
-dist/
+# dist/
 .DS_Store

dist/Connection.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+interface Options {
+    username?: string;
+    password?: string;
+    privateKey?: string | Buffer;
+    agentForward?: boolean;
+    bastionHost?: string;
+    passphrase?: string;
+    endPort?: number;
+    endHost: string;
+    agentSocket?: string;
+    skipAutoPrivateKey?: boolean;
+    noReadline?: boolean;
+    readyTimeout?: number;
+}
+interface ForwardingOptions {
+    fromPort: number;
+    toPort: number;
+    toHost?: string;
+}
+declare class SSHConnection {
+    private options;
+    private debug;
+    private server;
+    private connections;
+    private isWindows;
+    constructor(options: Options);
+    shutdown(): Promise<void>;
+    tty(): Promise<void>;
+    executeCommand(command: any): Promise<void>;
+    private shell;
+    private establish;
+    private connectViaBastion;
+    private connect;
+    private getPassphrase;
+    forward(options: ForwardingOptions): Promise<{}>;
+}
+export { SSHConnection, Options };

dist/Connection.js

@@ -0,0 +1,201 @@
+"use strict";
+/*
+ * Copyright 2018 Stocard GmbH.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const ssh2_1 = require("ssh2");
+const net = require("net");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const readline = require("readline");
+const debug = require("debug");
+class SSHConnection {
+    constructor(options) {
+        this.options = options;
+        this.connections = [];
+        this.isWindows = process.platform === 'win32';
+        this.debug = debug('ssh');
+        if (!options.username) {
+            this.options.username = process.env['SSH_USERNAME'] || process.env['USER'];
+        }
+        if (!options.endPort) {
+            this.options.endPort = 22;
+        }
+        if (!options.privateKey && !options.agentForward && !options.skipAutoPrivateKey) {
+            const defaultFilePath = path.join(os.homedir(), '.ssh', 'id_rsa');
+            if (fs.existsSync(defaultFilePath)) {
+                this.options.privateKey = fs.readFileSync(defaultFilePath);
+            }
+        }
+    }
+    async shutdown() {
+        this.debug('Shutdown connections');
+        for (const connection of this.connections) {
+            connection.removeAllListeners();
+            connection.end();
+        }
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(resolve);
+            }
+            return resolve();
+        });
+    }
+    async tty() {
+        const connection = await this.establish();
+        this.debug('Opening tty');
+        await this.shell(connection);
+    }
+    async executeCommand(command) {
+        const connection = await this.establish();
+        this.debug('Executing command "%s"', command);
+        await this.shell(connection, command);
+    }
+    async shell(connection, command) {
+        return new Promise((resolve, reject) => {
+            connection.shell((err, stream) => {
+                if (err) {
+                    return reject(err);
+                }
+                stream.on('close', async () => {
+                    stream.end();
+                    process.stdin.unpipe(stream);
+                    process.stdin.destroy();
+                    connection.end();
+                    await this.shutdown();
+                    return resolve();
+                }).stderr.on('data', (data) => {
+                    return reject(data);
+                });
+                stream.pipe(process.stdout);
+                if (command) {
+                    stream.end(`${command}\nexit\n`);
+                }
+                else {
+                    process.stdin.pipe(stream);
+                }
+            });
+        });
+    }
+    async establish() {
+        let connection;
+        if (this.options.bastionHost) {
+            connection = await this.connectViaBastion(this.options.bastionHost);
+        }
+        else {
+            connection = await this.connect(this.options.endHost);
+        }
+        return connection;
+    }
+    async connectViaBastion(bastionHost) {
+        this.debug('Connecting to bastion host "%s"', bastionHost);
+        const connectionToBastion = await this.connect(bastionHost);
+        return new Promise((resolve, reject) => {
+            connectionToBastion.forwardOut('127.0.0.1', 22, this.options.endHost, this.options.endPort || 22, async (err, stream) => {
+                if (err) {
+                    return reject(err);
+                }
+                const connection = await this.connect(this.options.endHost, stream);
+                return resolve(connection);
+            });
+        });
+    }
+    async connect(host, stream) {
+        this.debug('Connecting to "%s"', host);
+        const connection = new ssh2_1.Client();
+        return new Promise(async (resolve, reject) => {
+            const options = {
+                host,
+                port: this.options.endPort,
+                username: this.options.username,
+                password: this.options.password,
+                privateKey: this.options.privateKey
+            };
+            if (this.options.readyTimeout) {
+                options['readyTimeout'] = this.options.readyTimeout;
+            }
+            if (this.options.agentForward) {
+                options['agentForward'] = true;
+                // see https://github.com/mscdex/ssh2#client for agents on Windows
+                // guaranteed to give the ssh agent sock if the agent is running (posix)
+                let agentDefault = process.env['SSH_AUTH_SOCK'];
+                if (this.isWindows) {
+                    // null or undefined
+                    if (agentDefault == null) {
+                        agentDefault = 'pageant';
+                    }
+                }
+                const agentSock = this.options.agentSocket ? this.options.agentSocket : agentDefault;
+                if (agentSock == null) {
+                    throw new Error('SSH Agent Socket is not provided, or is not set in the SSH_AUTH_SOCK env variable');
+                }
+                options['agent'] = agentSock;
+            }
+            if (stream) {
+                options['sock'] = stream;
+            }
+            // PPK private keys can be encrypted, but won't contain the word 'encrypted'
+            // in fact they always contain a `encryption` header, so we can't do a simple check
+            options['passphrase'] = this.options.passphrase;
+            const looksEncrypted = this.options.privateKey ? this.options.privateKey.toString().toLowerCase().includes('encrypted') : false;
+            if (looksEncrypted && !options['passphrase'] && !this.options.noReadline) {
+                options['passphrase'] = await this.getPassphrase();
+            }
+            connection.on('ready', () => {
+                this.connections.push(connection);
+                return resolve(connection);
+            });
+            connection.on('error', (error) => {
+                reject(error);
+            });
+            try {
+                connection.connect(options);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async getPassphrase() {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            rl.question('Please type in the passphrase for your private key: ', (answer) => {
+                return resolve(answer);
+            });
+        });
+    }
+    async forward(options) {
+        const connection = await this.establish();
+        return new Promise((resolve, reject) => {
+            this.server = net.createServer((socket) => {
+                this.debug('Forwarding connection from "localhost:%d" to "%s:%d"', options.fromPort, options.toHost, options.toPort);
+                connection.forwardOut('localhost', options.fromPort, options.toHost || 'localhost', options.toPort, (error, stream) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    socket.pipe(stream);
+                    stream.pipe(socket);
+                });
+            }).listen(options.fromPort, 'localhost', () => {
+                return resolve();
+            });
+        });
+    }
+}
+exports.SSHConnection = SSHConnection;