bdy 1.8.3-dev → 1.8.4-dev

package/distTs/src/output/noninteractive/agent/tunnels.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = require("../../../utils.js");
+const texts_js_1 = require("../../../texts.js");
+const format_1 = __importDefault(require("../../../format"));
+class OutputNoninteractiveAgentTunnels {
+    constructor(terminal, tunnels) {
+        this.terminal = terminal;
+        this.tunnels = tunnels;
+    }
+    start(output) {
+        if (!this.tunnels.length) {
+            output.exitNormal(texts_js_1.NO_TUNNELS_STARTED);
+        }
+        else {
+            const tunnels = [
+                ['Id', 'Type', 'Target / Latency', 'Entry / Latency', 'Status'],
+            ];
+            this.tunnels.forEach((tunnel) => {
+                let target;
+                let status;
+                if (tunnel.serve)
+                    target = format_1.default.serve(tunnel.serve) + ' / 0ms';
+                else
+                    target =
+                        format_1.default.target(tunnel.type, tunnel.target) +
+                            ` / ${format_1.default.latency(tunnel.targetLatency)}`;
+                const entry = format_1.default.entry(tunnel) + ` / ${format_1.default.latency(tunnel.regionLatency)}`;
+                if (tunnel.status === utils_js_1.TUNNEL_OPEN)
+                    status = 'Open';
+                else
+                    status = 'Closed';
+                tunnels.push([tunnel.id, tunnel.type, target, entry, status]);
+            });
+            output.table(tunnels);
+            output.exitNormal();
+        }
+    }
+}
+exports.default = OutputNoninteractiveAgentTunnels;

package/distTs/src/output/noninteractive/config/tunnel.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = require("../../../utils.js");
+const format_1 = __importDefault(require("../../../format"));
+class OutputNoninteractiveConfigTunnel {
+    constructor(terminal, tunnel) {
+        this.terminal = terminal;
+        this.tunnel = tunnel;
+    }
+    start(output) {
+        const data = [
+            ['Name', this.tunnel.name],
+            ['Type', format_1.default.type(this.tunnel.type)],
+        ];
+        if (this.tunnel.type === utils_js_1.TUNNEL_HTTP && this.tunnel.serve) {
+            data.push(['Serve', format_1.default.serve(this.tunnel.serve)]);
+        }
+        else {
+            data.push([
+                'Target',
+                format_1.default.target(this.tunnel.type, this.tunnel.target),
+            ]);
+        }
+        data.push(['Region', format_1.default.tunnelRegion(this.tunnel.region)]);
+        data.push(['Timeout', format_1.default.tunnelTimeout(this.tunnel.timeout)]);
+        data.push(['Whitelist', format_1.default.tunnelWhitelist(this.tunnel.whitelist)]);
+        data.push(['Domain', format_1.default.tunnelDomain(this.tunnel.domain)]);
+        data.push(['Subdomain', format_1.default.tunnelDomain(this.tunnel.subdomain)]);
+        if (this.tunnel.type === utils_js_1.TUNNEL_HTTP) {
+            data.push(['Host Header', format_1.default.hostHeader(this.tunnel.host)]);
+            data.push([
+                'Basic Auth',
+                format_1.default.basicAuth(this.tunnel.login, this.tunnel.password),
+            ]);
+            data.push([
+                'User Agents',
+                format_1.default.tunnelUserAgent(this.tunnel.useragents),
+            ]);
+            data.push(['Request Headers', format_1.default.tunnelHeaders(this.tunnel.headers)]);
+            data.push([
+                'Response Headers',
+                format_1.default.tunnelHeaders(this.tunnel.responseHeaders),
+            ]);
+            data.push([
+                'Circuit Breaker',
+                format_1.default.tunnelCircuitBreaker(this.tunnel.circuitBreaker),
+            ]);
+            data.push(['Log Requests', format_1.default.yesNo(this.tunnel.log)]);
+            data.push(['TLS Auth', format_1.default.yesNo(!!this.tunnel.ca)]);
+            data.push(['TLS Verify', format_1.default.yesNo(this.tunnel.verify)]);
+            data.push(['Force HTTP/2', format_1.default.yesNo(this.tunnel.http2)]);
+            data.push(['Compression', format_1.default.yesNo(this.tunnel.compression)]);
+        }
+        else if (this.tunnel.type === utils_js_1.TUNNEL_TLS) {
+            data.push(['Terminate TLS At', this.tunnel.terminate]);
+            data.push(['TLS Key', format_1.default.yesNo(!!this.tunnel.key)]);
+            data.push(['TLS Cert', format_1.default.yesNo(!!this.tunnel.cert)]);
+            data.push(['TLS Auth', format_1.default.yesNo(!!this.tunnel.ca)]);
+        }
+        output.table(data);
+        output.exitNormal();
+    }
+}
+exports.default = OutputNoninteractiveConfigTunnel;

package/distTs/src/output/noninteractive/config/tunnels.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class OutputNoninteractiveConfigTunnels {
+    constructor(terminal, tunnels) {
+        this.terminal = terminal;
+        this.tunnels = tunnels;
+    }
+    start(output) {
+        const data = [['Name', 'Type', 'Target']];
+        Object.keys(this.tunnels).forEach((name) => {
+            const t = this.tunnels[name];
+            data.push([name, t.type, String(t.target)]);
+        });
+        output.table(data);
+        output.exitNormal();
+    }
+}
+exports.default = OutputNoninteractiveConfigTunnels;

package/distTs/src/output/noninteractive/tunnel.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const format_1 = __importDefault(require("../../format"));
+class OutputNoninteractiveTunnel {
+    constructor(terminal, tunnel) {
+        this.tunnel = tunnel;
+        this.terminal = terminal;
+    }
+    status(t, status) {
+        this.terminal(`${format_1.default.date()}: Tunnel ${t.type} to ${t.serve || t.target} ${status}\n`);
+    }
+    onOpen(t) {
+        this.status(t, `open. Entry: ${format_1.default.entry(t)}`);
+    }
+    onClosed(t) {
+        this.status(t, 'closed');
+    }
+    onTcpOpen(t) {
+        this.status(t, 'has incoming tcp connection');
+    }
+    onTcpClosed(t) {
+        this.status(t, 'closed tcp connection');
+    }
+    onTlsOpen(t) {
+        this.status(t, 'has incoming tls connection');
+    }
+    onTlsClosed(t) {
+        this.status(t, 'closed tls connection');
+    }
+    onHttpIdentified(t, type) {
+        this.status(t, `identified as ${type}`);
+    }
+    onHttpRequest(t, logRequest) {
+        this.status(t, `Request ${logRequest.method} ${logRequest.url}`);
+    }
+    onHttpResponse(t, logRequest) {
+        this.status(t, `Response ${logRequest.method} ${logRequest.url} ${logRequest.status} in ${logRequest.time}ms`);
+    }
+    onStopped() {
+        process.exit();
+    }
+    start() {
+        this.tunnel.on(utils_1.TUNNEL_EVENT_OPEN, (t) => this.onOpen(t));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_CLOSED, (t) => this.onClosed(t));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_TCP_OPEN, (t) => this.onTcpOpen(t));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_TCP_CLOSED, (t) => this.onTcpClosed(t));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_TLS_OPEN, (t) => this.onTlsOpen(t));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_TLS_CLOSED, (t) => this.onTlsClosed(t));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_HTTP_IDENTIFIED, (t, type) => this.onHttpIdentified(t, type));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_HTTP_REQUEST, (t, logRequest) => this.onHttpRequest(t, logRequest));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_HTTP_RESPONSE, (t, logRequest) => this.onHttpResponse(t, logRequest));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_STOPPED, (t) => this.onStopped(t));
+    }
+}
+exports.default = OutputNoninteractiveTunnel;

package/distTs/src/output.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const termkit_no_lazy_require_1 = __importDefault(require("terminal-kit/lib/termkit-no-lazy-require"));
+const tunnel_js_1 = __importDefault(require("./output/interactive/tunnel.js"));
+const tunnel_js_2 = __importDefault(require("./output/noninteractive/tunnel.js"));
+const tunnel_js_3 = __importDefault(require("./output/noninteractive/config/tunnel.js"));
+const tunnels_js_1 = __importDefault(require("./output/noninteractive/config/tunnels.js"));
+const texts_js_1 = require("./texts.js");
+const tunnels_js_2 = __importDefault(require("./output/noninteractive/agent/tunnels.js"));
+const context_1 = require("./visualTest/context");
+const terminal = termkit_no_lazy_require_1.default.terminal;
+class Output {
+    static s;
+    static exitSuccess(msg) {
+        this.killSpinner();
+        terminal.green(`${msg}\n`);
+        process.exit(0);
+    }
+    static exitNormal(msg) {
+        this.killSpinner();
+        if (msg)
+            terminal(`${msg}\n`);
+        process.exit(0);
+    }
+    static newline() {
+        terminal('\n');
+    }
+    static normal(txt) {
+        terminal(`${txt}\n`);
+    }
+    static warning(txt) {
+        terminal.yellow(`${txt}\n`);
+    }
+    static error(txt) {
+        terminal.red(`${txt}\n`);
+    }
+    static async debug(text, action) {
+        if (context_1.debug) {
+            const t1 = performance.now();
+            const result = await action;
+            const t2 = performance.now();
+            this.normal(`${text} time: ${t2 - t1}`);
+            return result;
+        }
+        else {
+            return action;
+        }
+    }
+    static killSpinner() {
+        if (this.s) {
+            this.s.destroy();
+            this.s = null;
+            terminal.eraseLine();
+            terminal.left();
+        }
+    }
+    static async spinner(txt) {
+        if (!this.s && terminal.isTTY) {
+            this.s = await terminal.spinner();
+            if (txt)
+                terminal(` ${txt}`);
+        }
+    }
+    static agentTunnels(tunnels) {
+        const on = new tunnels_js_2.default(terminal, tunnels);
+        on.start(this);
+    }
+    static tunnelInteractive(tunnel) {
+        this.killSpinner();
+        const oi = new tunnel_js_1.default(terminal, tunnel);
+        oi.start();
+    }
+    static tunnelNonInteractive(tunnel) {
+        this.killSpinner();
+        const on = new tunnel_js_2.default(terminal, tunnel);
+        on.start();
+    }
+    static newCliVersion(version) {
+        terminal.gray((0, texts_js_1.TXT_NEW_CLI_VERSION)(version));
+    }
+    static newCliDockerVersion(version) {
+        terminal.gray((0, texts_js_1.TXT_NEW_CLI_DOCKER_VERSION)(version));
+    }
+    static newAgentVersion() {
+        terminal.gray(texts_js_1.TXT_NEW_AGENT_VERSION);
+    }
+    static tunnel(tunnel) {
+        if (terminal.isTTY)
+            this.tunnelInteractive(tunnel);
+        else
+            this.tunnelNonInteractive(tunnel);
+    }
+    static table(data) {
+        // apply padding
+        for (let i = 0; i < data.length; i += 1) {
+            for (let j = 0; j < data[i].length; j += 1) {
+                const s = data[i][j].split('\n');
+                const tmp = [];
+                for (let k = 0; k < s.length; k += 1) {
+                    tmp.push(` ${s[k]} `);
+                }
+                data[i][j] = tmp.join('\n');
+            }
+        }
+        terminal.table(data, {
+            fit: false,
+        });
+    }
+    static configTunnels(tunnels) {
+        const on = new tunnels_js_1.default(terminal, tunnels);
+        on.start(this);
+    }
+    static configTunnel(tunnel) {
+        const on = new tunnel_js_3.default(terminal, tunnel);
+        on.start(this);
+    }
+    static exitError(err) {
+        this.killSpinner();
+        terminal.fullscreen(false);
+        terminal.hideCursor(false);
+        terminal.grabInput(false);
+        let msg;
+        if (err instanceof Error) {
+            msg = err.message;
+            if (process.env.DEBUG === '1')
+                msg += `\n${err.stack}`;
+        }
+        else
+            msg = err;
+        terminal.red.error(`${msg}\n`);
+        process.exit(1);
+    }
+}
+exports.default = Output;

package/distTs/src/server/cert.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_forge_1 = __importDefault(require("node-forge"));
+const toPositiveHex = (hexString) => {
+    let hexAsInt = parseInt(hexString[0], 16);
+    if (hexAsInt < 8) {
+        return hexString;
+    }
+    hexAsInt -= 8;
+    return hexAsInt.toString() + hexString.substring(1);
+};
+class ServerCert {
+    constructor() {
+        const keyPair = node_forge_1.default.pki.rsa.generateKeyPair(2048);
+        const cert = node_forge_1.default.pki.createCertificate();
+        cert.serialNumber = toPositiveHex(node_forge_1.default.util.bytesToHex(node_forge_1.default.random.getBytesSync(9)));
+        cert.validity.notBefore = new Date();
+        const notAfter = new Date();
+        notAfter.setTime(notAfter.getTime() + 622080000000);
+        cert.validity.notAfter = notAfter;
+        const attrs = [
+            {
+                name: 'commonName',
+                value: 'buddy.tunnel',
+            },
+        ];
+        cert.setSubject(attrs);
+        cert.setIssuer(attrs);
+        cert.publicKey = keyPair.publicKey;
+        cert.setExtensions([
+            {
+                name: 'basicConstraints',
+                cA: true,
+            },
+            {
+                name: 'keyUsage',
+                keyCertSign: true,
+                digitalSignature: true,
+                nonRepudiation: true,
+                keyEncipherment: true,
+                dataEncipherment: true,
+            },
+        ]);
+        cert.sign(keyPair.privateKey, node_forge_1.default.md.sha256.create());
+        this.key = node_forge_1.default.pki.privateKeyToPem(keyPair.privateKey);
+        this.cert = node_forge_1.default.pki.certificateToPem(cert);
+    }
+}
+exports.default = ServerCert;

package/distTs/src/server/http1.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("events"));
+const logger_js_1 = __importDefault(require("../logger.js"));
+const uuid_1 = require("uuid");
+const http_1 = __importDefault(require("http"));
+const texts_js_1 = require("../texts.js");
+const utils_1 = require("../utils");
+class ServerHttp1 extends events_1.default {
+    constructor(host) {
+        super();
+        this.server = http_1.default.createServer((req, res) => this.processRequest(req, res, host));
+        this.server.on('connection', (socket) => {
+            socket.id = (0, uuid_1.v4)();
+            this.emit(utils_1.HTTP1_SOCKET_OPEN, socket);
+            socket.once('close', () => {
+                this.emit(utils_1.HTTP1_SOCKET_CLOSED, socket);
+            });
+        });
+        this.server.listen();
+    }
+    stop() {
+        this.server.close();
+        this.server.removeAllListeners();
+        this.server = null;
+    }
+    handleSshTunnel(stream, info, ip) {
+        logger_js_1.default.debug((0, texts_js_1.LOG_HTTP1_CONNECTION)(ip));
+        stream.remoteAddress = ip;
+        this.server.emit('connection', stream);
+    }
+    retryRequest(logRequest) {
+        const address = this.server.address();
+        if (!address || !address.port)
+            return;
+        let req = http_1.default.request({
+            host: 'localhost',
+            port: address.port,
+            method: logRequest.method,
+            setHost: false,
+            path: logRequest.url,
+            headers: logRequest.headers,
+        });
+        if (logRequest.requestBody.data.length > 0)
+            req.write(logRequest.requestBody.data);
+        req.on('response', (res) => {
+            res.resume();
+        });
+        req.on('close', () => {
+            req.removeAllListeners();
+            req = null;
+        });
+        req.end();
+    }
+    checkHostHeader(req, res, host) {
+        if (req.headers.host === host)
+            return true;
+        else {
+            res.statusCode = 421;
+            res.end('Misdirected Request');
+            return false;
+        }
+    }
+    async processRequest(req, res, host) {
+        if (!this.checkHostHeader(req, res, host))
+            return;
+        logger_js_1.default.debug((0, texts_js_1.LOG_HTTP1_REQUEST)(req.method, req.url));
+        this.emit(utils_1.HTTP1_REQUEST, req, res);
+    }
+}
+exports.default = ServerHttp1;

package/distTs/src/server/http2.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("events"));
+const http2_1 = __importDefault(require("http2"));
+const logger_js_1 = __importDefault(require("../logger.js"));
+const uuid_1 = require("uuid");
+const texts_js_1 = require("../texts.js");
+const utils_1 = require("../utils");
+class ServerHttp2 extends events_1.default {
+    constructor(host) {
+        super();
+        this.server = http2_1.default.createServer((req, res) => this.processRequest(req, res, host));
+        this.server.on('session', (session) => {
+            session.id = (0, uuid_1.v4)();
+            this.emit(utils_1.HTTP2_SESSION_OPEN, session);
+            session.once('close', () => {
+                this.emit(utils_1.HTTP2_SESSION_CLOSED, session);
+            });
+        });
+        this.server.listen();
+    }
+    stop() {
+        this.server.close();
+        this.server.removeAllListeners();
+        this.server = null;
+    }
+    handleSshTunnel(stream, info, ip) {
+        logger_js_1.default.debug((0, texts_js_1.LOG_HTTP2_CONNECTION)(ip));
+        stream.remoteAddress = ip;
+        this.server.emit('connection', stream);
+    }
+    retryRequest(logRequest) {
+        const address = this.server.address();
+        if (!address || !address.port)
+            return;
+        let client = http2_1.default.connect(`http://localhost:${address.port}`);
+        let req = client.request(logRequest.headers);
+        if (logRequest.requestBody.data.length > 0)
+            req.write(logRequest.requestBody.data);
+        req.on('response', () => {
+            req.resume();
+        });
+        req.on('error', (err) => {
+            logger_js_1.default.debug(texts_js_1.LOG_ERROR);
+            logger_js_1.default.debug(err);
+        });
+        req.on('close', () => {
+            req.removeAllListeners();
+            client.close();
+            req = null;
+            client = null;
+        });
+        req.end();
+    }
+    checkHostHeader(req, res, host) {
+        if (req.headers[':authority'] === host)
+            return true;
+        else {
+            res.statusCode = 421;
+            res.end('Misdirected Request');
+            return false;
+        }
+    }
+    async processRequest(req, res, host) {
+        if (!this.checkHostHeader(req, res, host))
+            return;
+        logger_js_1.default.debug((0, texts_js_1.LOG_HTTP2_REQUEST)(req.method, req.url));
+        this.emit(utils_1.HTTP2_REQUEST, req, res);
+    }
+}
+exports.default = ServerHttp2;