bdy 1.10.14-stage → 1.11.0-beta

package/distTs/src/tunnel/cfg.js

@@ -0,0 +1,234 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+const jsonwebtoken_1 = require("jsonwebtoken");
+const utils_1 = require("../utils");
+const input_1 = __importDefault(require("../input"));
+const texts_1 = require("../texts");
+class Cfg {
+    constructor() {
+        this.dir = (0, utils_1.getHomeDirectory)();
+        this.file = (0, path_1.resolve)(this.dir, 'cfg.json');
+        this.json = {};
+        this.load();
+    }
+    createDir() {
+        try {
+            (0, fs_1.mkdirSync)(this.dir, {
+                recursive: true,
+            });
+        }
+        catch {
+            throw new Error((0, texts_1.ERR_CANT_CREATE_DIR_IN_HOME)('.bdy'));
+        }
+        try {
+            (0, fs_1.chmodSync)(this.dir, 0o777);
+        }
+        catch {
+            // do nothing
+        }
+    }
+    createEmptyFile() {
+        try {
+            (0, fs_1.writeFileSync)(this.file, '{}', 'utf-8');
+        }
+        catch {
+            throw new Error((0, texts_1.ERR_CANT_CREATE_DIR_IN_HOME)('.bdy/cfg.json'));
+        }
+        try {
+            (0, fs_1.chmodSync)(this.file, 0o666);
+        }
+        catch {
+            // do nothing
+        }
+    }
+    ensureDir() {
+        try {
+            (0, fs_1.statSync)(this.dir);
+        }
+        catch {
+            this.createDir();
+        }
+    }
+    ensureFile() {
+        this.ensureDir();
+        try {
+            (0, fs_1.statSync)(this.file);
+        }
+        catch {
+            this.createEmptyFile();
+        }
+    }
+    ensureTunnels() {
+        if (!this.json.tunnels)
+            this.json.tunnels = {};
+    }
+    async prepareTunnel(tunnelType, target, options, useDefaults) {
+        const type = input_1.default.type(tunnelType);
+        const tunnel = {
+            type,
+            target: input_1.default.target(target, type),
+        };
+        if (options.region !== undefined)
+            tunnel.region = input_1.default.region(options.region);
+        else if (useDefaults)
+            tunnel.region = this.getRegion();
+        if (options.whitelist !== undefined)
+            tunnel.whitelist = input_1.default.whitelist(options.whitelist);
+        else if (useDefaults)
+            tunnel.whitelist = this.getWhitelist();
+        if (options.timeout !== undefined)
+            tunnel.timeout = input_1.default.timeout(options.timeout);
+        else if (useDefaults)
+            tunnel.timeout = this.getTimeout();
+        if (type === utils_1.TUNNEL_HTTP) {
+            if (options.host !== undefined)
+                tunnel.host = options.host;
+            if (options.auth !== undefined) {
+                const { password, login } = input_1.default.auth(options.auth);
+                tunnel.login = login;
+                tunnel.password = password;
+            }
+            if (options.ca !== undefined)
+                tunnel.ca = input_1.default.ca(options.ca);
+            if (options.serve !== undefined)
+                tunnel.serve = input_1.default.serve(options.serve);
+            if (options.useragent !== undefined)
+                tunnel.useragents = input_1.default.useragents(options.useragent);
+            if (options.header !== undefined)
+                tunnel.headers = input_1.default.headers(options.header);
+            if (options.responseHeader !== undefined)
+                tunnel.responseHeaders = input_1.default.headers(options.responseHeader);
+            if (options.circuitBreaker !== undefined)
+                tunnel.circuitBreaker = input_1.default.circuitBreaker(options.circuitBreaker);
+            tunnel.log = !!options.log;
+            tunnel.verify = !!options.verify;
+            tunnel.http2 = !!options.http2;
+            tunnel.compression = !!options.compression;
+        }
+        else if (type === utils_1.TUNNEL_TLS) {
+            tunnel.terminate = input_1.default.terminate(options.terminate);
+            if (options.key !== undefined || options.cert !== undefined) {
+                const { key, cert } = input_1.default.keyCert(options.key, options.cert);
+                tunnel.key = key;
+                tunnel.cert = cert;
+            }
+            if (options.ca !== undefined)
+                tunnel.ca = input_1.default.ca(options.ca);
+        }
+        if (options.name !== undefined)
+            tunnel.name = input_1.default.name(options.name);
+        return tunnel;
+    }
+    async addTunnel(name, type, target, options) {
+        this.ensureTunnels();
+        this.json.tunnels[name] = await this.prepareTunnel(type, target, {
+            name,
+            ...options,
+        }, false);
+        this.save();
+    }
+    removeTunnel(name) {
+        this.ensureTunnels();
+        delete this.json.tunnels[name];
+        this.save();
+    }
+    getTunnels() {
+        this.ensureTunnels();
+        return this.json.tunnels;
+    }
+    hasTunnel(name) {
+        this.ensureTunnels();
+        return !!this.json.tunnels[name];
+    }
+    getTunnel(name) {
+        this.ensureTunnels();
+        return this.json.tunnels[name];
+    }
+    setToken(token) {
+        if (!token)
+            delete this.json.token;
+        else
+            this.json.token = token;
+        this.save();
+    }
+    setWhitelist(whitelist) {
+        if (!whitelist || !whitelist.length)
+            delete this.json.whitelist;
+        else
+            this.json.whitelist = whitelist;
+        this.save();
+    }
+    setTimeout(timeout) {
+        if (!timeout)
+            delete this.json.timeout;
+        else
+            this.json.timeout = timeout;
+        this.save();
+    }
+    getToken() {
+        return this.json.token || '';
+    }
+    getTokenHost() {
+        const token = this.getToken();
+        if (!token) {
+            throw new Error(texts_1.ERR_TOKEN_NOT_PROVIDED);
+        }
+        const d = (0, jsonwebtoken_1.decode)(token);
+        if (d === null) {
+            throw new Error(texts_1.ERR_WRONG_TOKEN);
+        }
+        if (!d.host) {
+            throw new Error(texts_1.ERR_WRONG_TOKEN);
+        }
+        return d.host;
+    }
+    getRegion() {
+        return (this.json.region || '').toUpperCase();
+    }
+    getTimeout() {
+        return this.json.timeout || utils_1.DEFAULT_TIMEOUT;
+    }
+    getWhitelist() {
+        return this.json.whitelist || [];
+    }
+    setRegion(region) {
+        this.json.region = region;
+        this.save();
+    }
+    setRegionIfNotSet(region) {
+        if (!this.json.region && region)
+            this.json.region = region.toUpperCase();
+        this.save();
+    }
+    load() {
+        this.ensureFile();
+        try {
+            const txt = (0, fs_1.readFileSync)(this.file, 'utf-8');
+            this.json = JSON.parse(txt);
+        }
+        catch {
+            throw new Error(texts_1.ERR_CONFIG_CORRUPTED);
+        }
+    }
+    save() {
+        this.ensureDir();
+        try {
+            (0, fs_1.writeFileSync)(this.file, JSON.stringify(this.json, null, 4), 'utf-8');
+        }
+        catch {
+            throw new Error((0, texts_1.ERR_CANT_CREATE_DIR_IN_HOME)('.bdy/cfg.json'));
+        }
+        try {
+            (0, fs_1.chmodSync)(this.file, 0o666);
+        }
+        catch {
+            // do nothing
+        }
+    }
+}
+exports.default = new Cfg();

package/distTs/src/tunnel/http/log.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const events_1 = __importDefault(require("events"));
 const uuid_1 = require("uuid");
-const stream_js_1 = __importDefault(require("./stream.js"));
+const stream_1 = __importDefault(require("./stream"));
 const isbinaryfile_1 = require("isbinaryfile");
 const utils_1 = require("../../utils");
 class TunnelHttpLogRequest extends events_1.default {
@@ -19,11 +19,11 @@ class TunnelHttpLogRequest extends events_1.default {
         this.start = process.hrtime();
         this.finished = false;
         this.id = (0, uuid_1.v4)();
-        this.requestBody = new stream_js_1.default(utils_1.TUNNEL_HTTP_LOG_MAX_BODY);
+        this.requestBody = new stream_1.default(utils_1.TUNNEL_HTTP_LOG_MAX_BODY);
         this.requestBody.once('close', () => {
             this.emit(utils_1.EVENT_TUNNEL_HTTP_NEW_REQUEST_END);
         });
-        this.responseBody = new stream_js_1.default(utils_1.TUNNEL_HTTP_LOG_MAX_BODY);
+        this.responseBody = new stream_1.default(utils_1.TUNNEL_HTTP_LOG_MAX_BODY);
         this.responseBody.once('close', () => {
             this.emit(utils_1.EVENT_TUNNEL_HTTP_NEW_RESPONSE_END);
         });

package/distTs/src/tunnel/http.js

@@ -8,13 +8,13 @@ const uuid_1 = require("uuid");
 const http_1 = __importDefault(require("http"));
 const utils_1 = require("../utils");
 const stream_1 = __importDefault(require("stream"));
-const texts_js_1 = require("../texts.js");
-const logger_js_1 = __importDefault(require("../logger.js"));
-const serve_js_1 = __importDefault(require("./http/serve.js"));
+const texts_1 = require("../texts");
+const logger_1 = __importDefault(require("../logger"));
+const serve_1 = __importDefault(require("./http/serve"));
 const https_1 = __importDefault(require("https"));
-const compression_js_1 = __importDefault(require("./compression.js"));
-const html_js_1 = __importDefault(require("./html.js"));
-const agent_js_1 = __importDefault(require("./agent.js"));
+const compression_1 = __importDefault(require("./compression"));
+const html_1 = __importDefault(require("./html"));
+const agent_1 = __importDefault(require("./agent"));
 const punycode_js_1 = __importDefault(require("punycode.js"));
 class TunnelHttp extends events_1.default {
     constructor({ req, res, proto, host, port, hostHeader, serve, timeout, httpIdentify, verify, httpLog, compression, headers, responseHeaders, auth = null, }) {
@@ -73,7 +73,7 @@ class TunnelHttp extends events_1.default {
         return t;
     }
     output504() {
-        this.outputEnd(504, html_js_1.default.get504(this.getDisplayTarget()));
+        this.outputEnd(504, html_1.default.get504(this.getDisplayTarget()));
     }
     outputHeaders(statusCode, headers) {
         this.res.statusCode = statusCode;
@@ -193,7 +193,7 @@ class TunnelHttp extends events_1.default {
             ...this.getRequestHeaders(false),
         };
         const r = http_1.default.request({
-            agent: agent_js_1.default.getHttp1(),
+            agent: agent_1.default.getHttp1(),
             host: (0, utils_1.getRealTargetHost)(this.host),
             port: this.port,
             method,
@@ -208,17 +208,17 @@ class TunnelHttp extends events_1.default {
             this.proxyRes = proxyRes;
             const statusCode = this.proxyRes.statusCode;
             const resHeaders = this.proxyRes.headers;
-            const compressionMethod = compression_js_1.default.detect(this.compression, reqHeaders, resHeaders);
+            const compressionMethod = compression_1.default.detect(this.compression, reqHeaders, resHeaders);
             this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
             if (this.logRequest) {
                 this.proxyRes
                     .pipe(this.logRequest.responseBody)
-                    .pipe(compression_js_1.default.compress(compressionMethod))
+                    .pipe(compression_1.default.compress(compressionMethod))
                     .pipe(this.res);
             }
             else {
                 this.proxyRes
-                    .pipe(compression_js_1.default.compress(compressionMethod))
+                    .pipe(compression_1.default.compress(compressionMethod))
                     .pipe(this.res);
             }
             this.httpLog.newResponse(this.req, statusCode, resHeaders, this.logRequest);
@@ -235,7 +235,7 @@ class TunnelHttp extends events_1.default {
         };
         const path = this.getPath();
         const r = https_1.default.request({
-            agent: agent_js_1.default.getHttps1(),
+            agent: agent_1.default.getHttps1(),
             host: (0, utils_1.getRealTargetHost)(this.host),
             port: this.port,
             method,
@@ -251,17 +251,17 @@ class TunnelHttp extends events_1.default {
             this.proxyRes = proxyRes;
             const statusCode = this.proxyRes.statusCode;
             const resHeaders = this.proxyRes.headers;
-            const compressionMethod = compression_js_1.default.detect(this.compression, reqHeaders, resHeaders);
+            const compressionMethod = compression_1.default.detect(this.compression, reqHeaders, resHeaders);
             this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
             if (this.logRequest) {
                 this.proxyRes
                     .pipe(this.logRequest.responseBody)
-                    .pipe(compression_js_1.default.compress(compressionMethod))
+                    .pipe(compression_1.default.compress(compressionMethod))
                     .pipe(this.res);
             }
             else {
                 this.proxyRes
-                    .pipe(compression_js_1.default.compress(compressionMethod))
+                    .pipe(compression_1.default.compress(compressionMethod))
                     .pipe(this.res);
             }
             this.httpLog.newResponse(this.req, statusCode, resHeaders, this.logRequest);
@@ -270,7 +270,7 @@ class TunnelHttp extends events_1.default {
     }
     createServe() {
         const reqHeaders = this.req.headers;
-        const r = new serve_js_1.default(this.serve);
+        const r = new serve_1.default(this.serve);
         const method = this.getMethod();
         const path = this.getPath();
         this.logRequest = this.httpLog.newRequest(method, reqHeaders, path, utils_1.TUNNEL_IDENTIFIED_HTTP1, this.req);
@@ -280,17 +280,17 @@ class TunnelHttp extends events_1.default {
                 this.res.end();
             }
             else {
-                const compressionMethod = compression_js_1.default.detect(this.compression, reqHeaders, resHeaders);
+                const compressionMethod = compression_1.default.detect(this.compression, reqHeaders, resHeaders);
                 this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
                 if (this.logRequest) {
                     stream
                         .pipe(this.logRequest.responseBody)
-                        .pipe(compression_js_1.default.compress(compressionMethod))
+                        .pipe(compression_1.default.compress(compressionMethod))
                         .pipe(this.res);
                 }
                 else {
                     stream
-                        .pipe(compression_js_1.default.compress(compressionMethod))
+                        .pipe(compression_1.default.compress(compressionMethod))
                         .pipe(this.res);
                 }
             }
@@ -301,7 +301,7 @@ class TunnelHttp extends events_1.default {
     async createRequestHttps2() {
         const reqHeaders = this.req.headers;
         const authority = `${this.proto}://${(0, utils_1.getRealTargetHost)(this.host)}:${this.port}`;
-        const client = await agent_js_1.default.getHttp2Client(authority, this.host, this.verify);
+        const client = await agent_1.default.getHttp2Client(authority, this.host, this.verify);
         const method = this.getMethod();
         const path = this.getPath();
         const headers = {
@@ -313,15 +313,15 @@ class TunnelHttp extends events_1.default {
         this.logRequest = this.httpLog.newRequest(method, headers, path, utils_1.TUNNEL_IDENTIFIED_HTTP2, this.req);
         r.on('response', (resHeaders) => {
             const status = resHeaders[':status'] || 200;
-            const compressionMethod = compression_js_1.default.detect(this.compression, reqHeaders, resHeaders);
+            const compressionMethod = compression_1.default.detect(this.compression, reqHeaders, resHeaders);
             this.outputHeaders(status, this.getClearedHeaders(resHeaders, compressionMethod));
             if (this.logRequest) {
                 r.pipe(this.logRequest.responseBody)
-                    .pipe(compression_js_1.default.compress(compressionMethod))
+                    .pipe(compression_1.default.compress(compressionMethod))
                     .pipe(this.res);
             }
             else {
-                r.pipe(compression_js_1.default.compress(compressionMethod)).pipe(this.res);
+                r.pipe(compression_1.default.compress(compressionMethod)).pipe(this.res);
             }
             this.httpLog.newResponse(this.req, status, resHeaders, this.logRequest);
         });
@@ -407,8 +407,8 @@ class TunnelHttp extends events_1.default {
                 this.proxyReq = this.createServe();
             }
             catch (err) {
-                logger_js_1.default.debug(texts_js_1.LOG_ERROR);
-                logger_js_1.default.debug(err);
+                logger_1.default.debug(texts_1.LOG_ERROR);
+                logger_1.default.debug(err);
                 this.output504();
                 return;
             }
@@ -427,8 +427,8 @@ class TunnelHttp extends events_1.default {
                 this.proxyReq = await this.createRequest();
             }
             catch (err) {
-                logger_js_1.default.debug(texts_js_1.LOG_ERROR);
-                logger_js_1.default.debug(err);
+                logger_1.default.debug(texts_1.LOG_ERROR);
+                logger_1.default.debug(err);
                 if (this.logRequest) {
                     this.req.pipe(this.logRequest.requestBody);
                     // no real request waiting for this data -> push it into the void
@@ -446,8 +446,8 @@ class TunnelHttp extends events_1.default {
                 this.output504();
             });
             this.proxyReq.on('error', (err) => {
-                logger_js_1.default.debug(texts_js_1.LOG_ERROR);
-                logger_js_1.default.debug(err);
+                logger_1.default.debug(texts_1.LOG_ERROR);
+                logger_1.default.debug(err);
                 this.output504();
             });
             this.proxyReq.on('close', () => {

package/distTs/src/tunnel/identification.js

@@ -6,18 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const events_1 = __importDefault(require("events"));
 const tls_1 = __importDefault(require("tls"));
 const net_1 = __importDefault(require("net"));
-const utils_js_1 = require("../utils.js");
 const utils_1 = require("../utils");
+const utils_2 = require("../utils");
 const CHECK_INTERVAL = 300000;
 const CHECK_TIMEOUT = 5000;
 class TunnelIdentification extends events_1.default {
     constructor(proto, host, port, forceHttp2) {
         super();
         this.proto = proto;
-        this.host = (0, utils_js_1.getRealTargetHost)(host);
+        this.host = (0, utils_1.getRealTargetHost)(host);
         this.port = port;
         this.forceHttp2 = forceHttp2;
-        this.type = utils_1.TUNNEL_IDENTIFIED_HTTP1;
+        this.type = utils_2.TUNNEL_IDENTIFIED_HTTP1;
         this.identify();
         this.ts = setInterval(() => this.identify(), CHECK_INTERVAL);
     }
@@ -29,8 +29,8 @@ class TunnelIdentification extends events_1.default {
     }
     identify() {
         if (this.forceHttp2) {
-            this.type = utils_1.TUNNEL_IDENTIFIED_HTTP2;
-            this.emit(utils_1.EVENT_TUNNEL_IDENTIFIED, utils_1.TUNNEL_IDENTIFIED_HTTP2);
+            this.type = utils_2.TUNNEL_IDENTIFIED_HTTP2;
+            this.emit(utils_2.EVENT_TUNNEL_IDENTIFIED, utils_2.TUNNEL_IDENTIFIED_HTTP2);
             return;
         }
         let socket;
@@ -46,12 +46,12 @@ class TunnelIdentification extends events_1.default {
         const connected = () => {
             if (socket.alpnProtocol) {
                 if (socket.alpnProtocol === 'h2') {
-                    this.type = utils_1.TUNNEL_IDENTIFIED_HTTP2;
-                    this.emit(utils_1.EVENT_TUNNEL_IDENTIFIED, utils_1.TUNNEL_IDENTIFIED_HTTP2);
+                    this.type = utils_2.TUNNEL_IDENTIFIED_HTTP2;
+                    this.emit(utils_2.EVENT_TUNNEL_IDENTIFIED, utils_2.TUNNEL_IDENTIFIED_HTTP2);
                 }
                 else {
-                    this.type = utils_1.TUNNEL_IDENTIFIED_HTTP1;
-                    this.emit(utils_1.EVENT_TUNNEL_IDENTIFIED, utils_1.TUNNEL_IDENTIFIED_HTTP1);
+                    this.type = utils_2.TUNNEL_IDENTIFIED_HTTP1;
+                    this.emit(utils_2.EVENT_TUNNEL_IDENTIFIED, utils_2.TUNNEL_IDENTIFIED_HTTP1);
                 }
                 close();
             }
@@ -59,12 +59,12 @@ class TunnelIdentification extends events_1.default {
                 socket.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n');
                 socket.on('data', (d) => {
                     if (/HTTP\/1/.test(d.toString('utf8'))) {
-                        this.type = utils_1.TUNNEL_IDENTIFIED_HTTP1;
-                        this.emit(utils_1.EVENT_TUNNEL_IDENTIFIED, utils_1.TUNNEL_IDENTIFIED_HTTP1);
+                        this.type = utils_2.TUNNEL_IDENTIFIED_HTTP1;
+                        this.emit(utils_2.EVENT_TUNNEL_IDENTIFIED, utils_2.TUNNEL_IDENTIFIED_HTTP1);
                     }
                     else {
-                        this.type = utils_1.TUNNEL_IDENTIFIED_HTTP2;
-                        this.emit(utils_1.EVENT_TUNNEL_IDENTIFIED, utils_1.TUNNEL_IDENTIFIED_HTTP2);
+                        this.type = utils_2.TUNNEL_IDENTIFIED_HTTP2;
+                        this.emit(utils_2.EVENT_TUNNEL_IDENTIFIED, utils_2.TUNNEL_IDENTIFIED_HTTP2);
                     }
                     close();
                 });

package/distTs/src/tunnel/latency.js

@@ -5,14 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const net_1 = require("net");
 const events_1 = __importDefault(require("events"));
-const utils_js_1 = require("../utils.js");
+const utils_1 = require("../utils");
 class TunnelLatency extends events_1.default {
     constructor(host, port) {
         super();
         this.latency = -1;
         this.isChecking = false;
         this.port = port;
-        this.host = (0, utils_js_1.getRealTargetHost)(host);
+        this.host = (0, utils_1.getRealTargetHost)(host);
         this.ts = null;
     }
     check() {
@@ -52,7 +52,7 @@ class TunnelLatency extends events_1.default {
         socket.on('ready', () => {
             const elapsed = process.hrtime(start);
             if (this.latency < 0)
-                this.emit(utils_js_1.TUNNEL_LATENCY_EVENT_RECONNECTED);
+                this.emit(utils_1.TUNNEL_LATENCY_EVENT_RECONNECTED);
             this.latency = elapsed[0] * 1000 + elapsed[1] / 1000000; // ms
             clear();
         });