bdy 1.8.3-dev → 1.8.5-dev

package/distTs/src/format.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+class Format {
+    static date() {
+        const dt = new Date();
+        return dt.toISOString();
+    }
+    static token(token) {
+        if (!token || token.length < 6)
+            return 'Not provided';
+        return token.substring(0, 3) + '...' + token.substring(token.length - 3);
+    }
+    static region(region) {
+        if (!region)
+            return 'Autodetect';
+        return region.toUpperCase();
+    }
+    static timeout(timeout) {
+        if (timeout === 1)
+            return '1 second';
+        return `${timeout} seconds`;
+    }
+    static tunnelTimeout(timeout) {
+        if (!timeout)
+            return 'Default';
+        return this.timeout(timeout);
+    }
+    static whitelist(whitelist) {
+        if (!whitelist || !whitelist.length)
+            return 'Everyone';
+        if (whitelist.includes('*'))
+            return 'Everyone';
+        return whitelist.join('\n');
+    }
+    static tunnelWhitelist(whitelist) {
+        if (!whitelist)
+            return 'Default';
+        return this.whitelist(whitelist);
+    }
+    static tunnelHeaders(headers) {
+        if (!headers || !headers.length)
+            return 'Not set';
+        return headers.map((h) => `${h.name}: ${h.value}`).join('\n');
+    }
+    static tunnelCircuitBreaker(cb) {
+        if (cb === undefined || cb === null)
+            return 'Not set';
+        return String(cb);
+    }
+    static tunnelUserAgent(userAgents) {
+        if (!userAgents || !userAgents.length)
+            return 'Everyone';
+        return userAgents.join('\n');
+    }
+    static tunnelDomain(domain) {
+        if (!domain)
+            return 'Default';
+        return domain;
+    }
+    static type(type) {
+        return type.toUpperCase();
+    }
+    static tunnelRegion(region) {
+        if (!region)
+            return 'Default';
+        return this.region(region);
+    }
+    static identify(identifyType) {
+        if (identifyType === utils_1.TUNNEL_IDENTIFIED_HTTP1)
+            return 'Ver. 1.1';
+        return 'Ver. 2';
+    }
+    static terminate(terminate) {
+        if (terminate === utils_1.TLS_TERMINATE_AT_AGENT)
+            return 'AGENT';
+        if (terminate === utils_1.TLS_TERMINATE_AT_REGION)
+            return 'REGION';
+        return 'TARGET';
+    }
+    static serve(serve) {
+        return serve;
+    }
+    static hostHeader(host) {
+        if (!host)
+            return 'Not set';
+        return host;
+    }
+    static basicAuth(login, pass) {
+        if (!login || !pass)
+            return 'Not set';
+        return `${login}:${pass}`;
+    }
+    static latency(latency) {
+        if (latency < 0)
+            return 'Unreachable';
+        if (latency < 1000)
+            return `${latency.toFixed(0)}ms`;
+        return `${(latency / 1000).toFixed(0)}s`;
+    }
+    static yesNo(val) {
+        if (!val)
+            return 'No';
+        return 'Yes';
+    }
+    static entryHost(tunnel) {
+        let host = '';
+        host += tunnel.subdomain;
+        host += '.';
+        // todo custom domain
+        host += tunnel.region.toLowerCase();
+        host += '-';
+        host += tunnel.sshId;
+        host += '.';
+        host += tunnel.domain;
+        return host;
+    }
+    static entry(tunnel) {
+        let entry = '';
+        if (tunnel.type === utils_1.TUNNEL_HTTP)
+            entry += 'https://';
+        entry += this.entryHost(tunnel);
+        if (tunnel.type === utils_1.TUNNEL_TCP)
+            entry += `:${tunnel.sshForwardPort}`;
+        else if (tunnel.type === utils_1.TUNNEL_TLS)
+            entry += ':443';
+        return entry;
+    }
+    static target(type, target) {
+        if (type === utils_1.TUNNEL_HTTP) {
+            let port = '80';
+            let host = 'localhost';
+            let proto = 'http';
+            let m = target.match(utils_1.TARGET_ONLY_PORT_REGEX);
+            if (m) {
+                port = m[0];
+            }
+            else {
+                m = target.match(utils_1.TARGET_HTTP_REGEX);
+                if (m) {
+                    if (m[2])
+                        proto = m[2];
+                    if (m[4])
+                        host = m[4];
+                    if (m[6])
+                        port = m[6];
+                    else if (proto === 'https')
+                        port = '443';
+                }
+            }
+            let t = `${proto}://${host}`;
+            if (proto === 'http' && port !== '80')
+                t += `:${port}`;
+            else if (proto === 'https' && port !== '443')
+                t += `:${port}`;
+            return t;
+        }
+        else {
+            let host = 'localhost';
+            let port = '80';
+            const m = target.match(utils_1.TARGET_TCP_TLS_REGEX);
+            if (m) {
+                if (m[3])
+                    port = m[3];
+                if (m[2])
+                    host = m[2];
+            }
+            return `${host}:${port}`;
+        }
+    }
+}
+exports.default = Format;

package/distTs/src/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_js_1 = __importDefault(require("./command/config.js"));
+const output_js_1 = __importDefault(require("./output.js"));
+const tcp_js_1 = __importDefault(require("./command/tcp.js"));
+const tls_js_1 = __importDefault(require("./command/tls.js"));
+const http_js_1 = __importDefault(require("./command/http.js"));
+const start_js_1 = __importDefault(require("./command/start.js"));
+const agent_js_1 = __importDefault(require("./command/agent.js"));
+const logger_js_1 = __importDefault(require("./logger.js"));
+const version_js_1 = __importDefault(require("./command/version.js"));
+const pre_js_1 = __importDefault(require("./command/pre.js"));
+const stream_1 = __importDefault(require("stream"));
+const utils_1 = require("./utils");
+const texts_1 = require("./texts");
+const vt_1 = __importDefault(require("./command/vt"));
+stream_1.default.setDefaultHighWaterMark(false, 67108864);
+process.title = 'bdy';
+process.on('uncaughtException', (err) => {
+    logger_js_1.default.fatal(err);
+    output_js_1.default.exitError(err);
+});
+const program = (0, utils_1.newCommand)(null, texts_1.DESC_PROGRAM);
+program.hook('preAction', pre_js_1.default);
+program.configureHelp({
+    formatHelp: utils_1.formatHelp,
+});
+program.addCommand(config_js_1.default);
+program.addCommand(tcp_js_1.default);
+program.addCommand(tls_js_1.default);
+program.addCommand(http_js_1.default);
+program.addCommand(start_js_1.default);
+if (!(0, utils_1.isDocker)())
+    program.addCommand(agent_js_1.default);
+program.addCommand(version_js_1.default);
+program.addCommand(vt_1.default);
+program.parse();

package/distTs/src/input.js

@@ -0,0 +1,286 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const output_js_1 = __importDefault(require("./output.js"));
+const netmask_1 = __importDefault(require("netmask"));
+const fs_1 = __importStar(require("fs"));
+const tls_1 = __importDefault(require("tls"));
+const crypto_1 = __importDefault(require("crypto"));
+const utils_js_1 = require("./utils.js");
+const texts_js_1 = require("./texts.js");
+class Input {
+    static timeout(timeout) {
+        const t = parseInt(timeout, 10);
+        if (isNaN(t) || t <= 0 || t > 999) {
+            output_js_1.default.exitError((0, texts_js_1.ERR_TIMEOUT_IS_NOT_VALID)(timeout));
+        }
+        return t;
+    }
+    static serve(serve) {
+        if (!serve)
+            return serve;
+        try {
+            const info = (0, fs_1.statSync)(serve);
+            if (!info.isDirectory()) {
+                output_js_1.default.exitError((0, texts_js_1.ERR_PATH_IS_NOT_DIRECTORY)(serve));
+            }
+        }
+        catch {
+            output_js_1.default.exitError((0, texts_js_1.ERR_DIRECTORY_DOES_NOT_EXISTS)(serve));
+        }
+        return serve;
+    }
+    static circuitBreaker(threshold) {
+        if (threshold === undefined)
+            return null;
+        const n = parseFloat(threshold);
+        if (isNaN(n) || n < 0 || n > 1) {
+            output_js_1.default.exitError((0, texts_js_1.ERR_CB_THRESHOLD_IS_NOT_VALID)(n));
+        }
+        return n;
+    }
+    static headers(headers) {
+        const r = [];
+        (headers || []).forEach((h) => {
+            if (!h)
+                return;
+            const s = h.split(':');
+            if (s.length !== 2)
+                return;
+            r.push({
+                name: s[0],
+                value: s[1],
+            });
+        });
+        return r;
+    }
+    static subdomain(subdomain) {
+        if (!/^[a-z0-9-]+$/i.test(subdomain)) {
+            output_js_1.default.exitError((0, texts_js_1.ERR_SUBDOMAIN_IS_NOT_VALID)(subdomain));
+        }
+        if (subdomain.length < 5) {
+            output_js_1.default.exitError((0, texts_js_1.ERR_SUBDOMAIN_IS_TOO_SHORT)(subdomain));
+        }
+        if (subdomain.length > 63) {
+            output_js_1.default.exitError((0, texts_js_1.ERR_SUBDOMAIN_IS_TOO_LONG)(subdomain));
+        }
+        return subdomain;
+    }
+    static domain(domain) {
+        if (!/^(?:[A-z0-9](?:[A-z0-9-]{0,61}[A-z0-9])?\.)+[A-z0-9][A-z0-9-]{0,61}[A-z0-9]$/i.test(domain)) {
+            output_js_1.default.exitError((0, texts_js_1.ERR_DOMAIN_IS_NOT_VALID)(domain));
+        }
+        return domain;
+    }
+    static auth(auth) {
+        const s = auth.split(':');
+        if (s.length !== 2) {
+            output_js_1.default.exitError((0, texts_js_1.ERR_BA_IS_NOT_VALID)(auth));
+        }
+        if (!s[0]) {
+            output_js_1.default.exitError(texts_js_1.ERR_BA_LOGIN_NOT_PROVIDED);
+        }
+        if (!s[1]) {
+            output_js_1.default.exitError(texts_js_1.ERR_BA_PASSWORD_NOT_PROVIDED);
+        }
+        return {
+            login: s[0],
+            password: s[1],
+        };
+    }
+    static useragents(useragents) {
+        if (!useragents || !useragents.length)
+            return [];
+        useragents.forEach((ua) => {
+            if ((0, utils_js_1.isStringRegExp)(ua)) {
+                try {
+                    new RegExp(ua);
+                }
+                catch {
+                    output_js_1.default.exitError((0, texts_js_1.ERR_USER_AGENT_IS_NOT_VALID)(ua));
+                }
+            }
+        });
+        return useragents;
+    }
+    static whitelist(whitelist) {
+        if (!whitelist || !whitelist.length)
+            return [];
+        for (let i = 0; i < whitelist.length; i += 1) {
+            const wh = whitelist[i];
+            if (wh === '*')
+                return ['*'];
+            try {
+                new netmask_1.default.Netmask(wh);
+            }
+            catch {
+                output_js_1.default.exitError((0, texts_js_1.ERR_WHITELIST_IS_NOT_VALID)(wh));
+            }
+        }
+        return whitelist;
+    }
+    static region(region) {
+        if (!region)
+            output_js_1.default.exitError((0, texts_js_1.ERR_REGION_IS_NOT_VALID)(''));
+        region = region.toUpperCase();
+        if (![utils_js_1.REGION_EU, utils_js_1.REGION_US].includes(region)) {
+            output_js_1.default.exitError((0, texts_js_1.ERR_REGION_IS_NOT_VALID)(region));
+        }
+        return region;
+    }
+    static terminate(terminate) {
+        if (!terminate)
+            return utils_js_1.TLS_TERMINATE_AT_REGION;
+        terminate = terminate.toUpperCase();
+        if (![
+            utils_js_1.TLS_TERMINATE_AT_AGENT,
+            utils_js_1.TLS_TERMINATE_AT_REGION,
+            utils_js_1.TLS_TERMINATE_AT_TARGET,
+        ].includes(terminate)) {
+            output_js_1.default.exitError((0, texts_js_1.ERR_TERMINATE_IS_NOT_VALID)(terminate));
+        }
+        return terminate;
+    }
+    static target(target, type) {
+        if (!target)
+            return '80';
+        if (target.length > 200) {
+            output_js_1.default.exitError((0, texts_js_1.ERR_TARGET_IS_NOT_VALID)(target));
+        }
+        target = target.toLowerCase();
+        // 80
+        // localhost
+        // localhost:80
+        // http://localhost:80
+        // http://localhost
+        // http://user:pass@localhost
+        // http://user:pass@localhost:80
+        let port;
+        if ([utils_js_1.TUNNEL_TCP, utils_js_1.TUNNEL_TLS].includes(type)) {
+            const m = target.match(utils_js_1.TARGET_TCP_TLS_REGEX);
+            if (!m) {
+                output_js_1.default.exitError((0, texts_js_1.ERR_TARGET_IS_NOT_VALID)(target));
+            }
+            port = m[3];
+        }
+        else {
+            let m = target.match(utils_js_1.TARGET_ONLY_PORT_REGEX);
+            if (m) {
+                port = m[0];
+            }
+            else {
+                m = target.match(utils_js_1.TARGET_HTTP_REGEX);
+                if (!m) {
+                    output_js_1.default.exitError((0, texts_js_1.ERR_TARGET_IS_NOT_VALID)(target));
+                }
+                else {
+                    let proto;
+                    if (m[2])
+                        proto = m[2];
+                    else
+                        proto = 'http';
+                    if (m[6])
+                        port = m[6];
+                    else if (proto === 'https')
+                        port = '443';
+                    else
+                        port = '80';
+                }
+            }
+        }
+        Input.port(port);
+        return target;
+    }
+    static port(port) {
+        const p = parseInt(port, 10);
+        if (isNaN(p) || p <= 0 || p > 65535)
+            output_js_1.default.exitError((0, texts_js_1.ERR_PORT_IS_NOT_VALID)(port));
+        return p;
+    }
+    static type(type) {
+        if (!type)
+            return utils_js_1.TUNNEL_TCP;
+        type = type.toUpperCase();
+        if (![utils_js_1.TUNNEL_TCP, utils_js_1.TUNNEL_TLS, utils_js_1.TUNNEL_HTTP].includes(type)) {
+            output_js_1.default.exitError((0, texts_js_1.ERR_TYPE_IS_NOT_VALID)(type));
+        }
+        return type;
+    }
+    static name(name) {
+        if (name.includes('*')) {
+            output_js_1.default.exitError(texts_js_1.ERR_NAME_WITHOUT_ASTERISK);
+        }
+        return name;
+    }
+    static ca(caPath) {
+        let cert;
+        try {
+            cert = fs_1.default.readFileSync(caPath, 'utf8');
+        }
+        catch {
+            output_js_1.default.exitError((0, texts_js_1.ERR_CA_PATH_IS_NOT_VALID)(caPath));
+        }
+        try {
+            new crypto_1.default.X509Certificate(cert);
+        }
+        catch {
+            output_js_1.default.exitError((0, texts_js_1.ERR_WRONG_CA)(caPath));
+        }
+        return cert;
+    }
+    static keyCert(keyPath, certPath) {
+        let key;
+        let cert;
+        try {
+            key = fs_1.default.readFileSync(keyPath, 'utf8');
+        }
+        catch {
+            output_js_1.default.exitError((0, texts_js_1.ERR_KEY_PATH_IS_NOT_VALID)(keyPath));
+        }
+        try {
+            cert = fs_1.default.readFileSync(certPath, 'utf8');
+        }
+        catch {
+            output_js_1.default.exitError((0, texts_js_1.ERR_CERT_PATH_IS_NOT_VALID)(certPath));
+        }
+        try {
+            tls_1.default.createSecureContext({
+                cert,
+                key,
+            });
+        }
+        catch {
+            output_js_1.default.exitError(texts_js_1.ERR_WRONG_KEY_CERT);
+        }
+        return {
+            cert,
+            key,
+        };
+    }
+}
+exports.default = Input;

package/distTs/src/logger.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pino_1 = __importDefault(require("pino"));
+const path_1 = require("path");
+const fs_1 = __importDefault(require("fs"));
+const utils_js_1 = require("./utils.js");
+class Logger {
+    rootPath = null;
+    logPath = null;
+    log1Path = null;
+    logStream = null;
+    p = null;
+    ts = null;
+    constructor() {
+        this.rootPath = (0, utils_js_1.getHomeDirectory)();
+    }
+    checkLogSize() {
+        try {
+            const s = fs_1.default.statSync(this.logPath);
+            if (s.size > 5242880) {
+                fs_1.default.copyFileSync(this.logPath, this.log1Path);
+                fs_1.default.truncateSync(this.logPath);
+            }
+        }
+        catch {
+            // do nothing
+        }
+    }
+    getPino() {
+        if (!this.p) {
+            this.logPath = (0, path_1.resolve)(this.rootPath, 'cli.log');
+            this.log1Path = (0, path_1.resolve)(this.rootPath, 'cli.1.log');
+            this.logStream = fs_1.default.openSync(this.logPath, 'w');
+            try {
+                fs_1.default.chmodSync(this.logPath, 0o666);
+            }
+            catch {
+                // do nothing
+            }
+            this.p = (0, pino_1.default)({
+                level: process.env.DEBUG === '1' ? 'debug' : 'info',
+                timestamp: () => `, "time": "${new Date().toISOString()}"`,
+                formatters: {
+                    bindings: () => ({}),
+                    level: (label) => ({
+                        level: label.toUpperCase(),
+                    }),
+                },
+            }, pino_1.default.destination(this.logStream));
+            this.checkLogSize();
+            this.ts = setInterval(() => {
+                this.checkLogSize();
+            }, 30000);
+        }
+        return this.p;
+    }
+    error(...args) {
+        this.getPino().error(...args);
+    }
+    info(...args) {
+        this.getPino().info(...args);
+    }
+    debug(...args) {
+        this.getPino().debug(...args);
+    }
+    fatal(...args) {
+        this.getPino().fatal(...args);
+    }
+    stack() {
+        this.getPino().info(new Error().stack);
+    }
+    changeRootPath(path) {
+        if (this.ts) {
+            clearInterval(this.ts);
+            this.ts = null;
+        }
+        if (this.logStream) {
+            try {
+                this.logStream.close();
+            }
+            catch {
+                // do nothing
+            }
+            this.logStream = null;
+        }
+        this.p = null;
+        this.rootPath = path;
+    }
+}
+exports.default = new Logger();