bdy 1.8.3-dev → 1.8.4-dev

package/distTs/src/tunnel/compression.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const zlib_1 = __importDefault(require("zlib"));
+const mime_db_1 = __importDefault(require("mime-db"));
+const accept_negotiator_1 = require("@fastify/accept-negotiator");
+const stream_1 = __importDefault(require("stream"));
+const utils_1 = require("../utils");
+class TunnelCompression {
+    static detect(canCompress, reqHeaders, resHeaders) {
+        if (!canCompress || resHeaders['content-encoding'])
+            return utils_1.TUNNEL_COMPRESSION_METHOD_IDENTITY; // already compressed
+        const contentType = resHeaders['content-type'] || 'application/json';
+        const mimeData = mime_db_1.default[contentType.split(';', 1)[0].trim().toLowerCase()];
+        if (!mimeData || !mimeData.compressible)
+            return utils_1.TUNNEL_COMPRESSION_METHOD_IDENTITY;
+        const encoding = (0, accept_negotiator_1.negotiate)(reqHeaders['accept-encoding'] || '', [
+            utils_1.TUNNEL_COMPRESSION_METHOD_BR,
+            utils_1.TUNNEL_COMPRESSION_METHOD_GZIP,
+            utils_1.TUNNEL_COMPRESSION_METHOD_DEFLATE,
+        ]);
+        if (!encoding)
+            return utils_1.TUNNEL_COMPRESSION_METHOD_IDENTITY;
+        return encoding;
+    }
+    static compress(method) {
+        let outStream;
+        if (method === utils_1.TUNNEL_COMPRESSION_METHOD_BR)
+            outStream = zlib_1.default.createBrotliCompress();
+        else if (method === utils_1.TUNNEL_COMPRESSION_METHOD_GZIP)
+            outStream = zlib_1.default.createGzip();
+        else if (method === utils_1.TUNNEL_COMPRESSION_METHOD_DEFLATE)
+            outStream = zlib_1.default.createDeflate();
+        else
+            outStream = new stream_1.default.PassThrough();
+        return outStream;
+    }
+}
+exports.default = TunnelCompression;

package/distTs/src/tunnel/dns.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dns_1 = require("dns");
+class TunnelDns {
+    constructor(sshIp, domain, subdomain, region, sshId) {
+        this.region = region;
+        this.sshId = sshId;
+        this.sshIp = sshIp;
+        this.domain = domain;
+        this.subdomain = subdomain;
+        this.valid = false;
+        this.checking = true;
+        this.ts = null;
+    }
+    check() {
+        const r = new dns_1.Resolver();
+        // todo custom domain
+        const hostname = `${this.subdomain}.${this.region.toLowerCase()}-${this.sshId}.${this.domain}`;
+        r.resolveCname(hostname, (err, a1) => {
+            if (err || !a1 || a1.length !== 1) {
+                this.valid = false;
+                this.checking = false;
+            }
+            else {
+                r.resolve4(a1[0], (err, a2) => {
+                    if (err || !a2 || a2.length !== 1) {
+                        this.valid = false;
+                        this.checking = false;
+                    }
+                    else {
+                        this.valid = a2[0] === this.sshIp;
+                        this.checking = false;
+                    }
+                });
+            }
+        });
+    }
+    startChecking() {
+        this.stopChecking();
+        setTimeout(() => {
+            this.check();
+        }, 1000);
+        this.ts = setInterval(() => {
+            this.check();
+        }, 15000);
+    }
+    stopChecking() {
+        if (this.ts) {
+            clearInterval(this.ts);
+            this.ts = null;
+        }
+    }
+}
+exports.default = TunnelDns;

package/distTs/src/tunnel/html.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const node_sea_1 = require("node:sea");
+const path_1 = require("path");
+class TunnelHtml {
+    static get404() {
+        if (!this.html404) {
+            if ((0, node_sea_1.isSea)()) {
+                this.html404 = (0, node_sea_1.getAsset)('404.html', 'utf8');
+            }
+            else {
+                this.html404 = (0, fs_1.readFileSync)((0, path_1.resolve)(__dirname, 'html/404.html'), 'utf8');
+            }
+        }
+        return this.html404;
+    }
+    static get503(validTarget) {
+        if (!this.html503) {
+            if ((0, node_sea_1.isSea)()) {
+                this.html503 = (0, node_sea_1.getAsset)('503.html', 'utf8');
+            }
+            else {
+                this.html503 = (0, fs_1.readFileSync)((0, path_1.resolve)(__dirname, 'html/503.html'), 'utf8');
+            }
+        }
+        return this.html503.replace('$SERVICE', validTarget);
+    }
+}
+exports.default = TunnelHtml;

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

@@ -0,0 +1,196 @@
+"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 uuid_1 = require("uuid");
+const stream_js_1 = __importDefault(require("./stream.js"));
+const isbinaryfile_1 = require("isbinaryfile");
+const utils_1 = require("../../utils");
+class TunnelHttpLogRequest extends events_1.default {
+    constructor(method, headers, url, httpVersion) {
+        super();
+        this.method = method;
+        this.headers = headers;
+        this.url = url;
+        this.httpVersion = httpVersion;
+        this.status = 'NEW';
+        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.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.once('close', () => {
+            this.emit(utils_1.EVENT_TUNNEL_HTTP_NEW_RESPONSE_END);
+        });
+    }
+    response(statusCode, headers) {
+        this.status = statusCode;
+        this.responseHeaders = headers;
+        const end = process.hrtime(this.start);
+        this.time = Math.round(end[0] * 1000 + end[1] / 1000000);
+        this.finished = true;
+    }
+    toSocket() {
+        let requestBody = null;
+        let requestBodyLength = 0;
+        let requestBodyTooLarge = false;
+        let requestBodyBinary = false;
+        let responseBody = null;
+        let responseBodyLength = 0;
+        let responseBodyTooLarge = false;
+        let responseBodyBinary = false;
+        if (this.requestBody.realLength > 0) {
+            requestBodyLength = this.requestBody.realLength;
+            requestBodyTooLarge =
+                requestBodyLength >= utils_1.TUNNEL_MAX_REQUEST_SIZE_TO_SYNC;
+            requestBodyBinary = (0, isbinaryfile_1.isBinaryFileSync)(this.requestBody.data);
+            if (!requestBodyTooLarge && !requestBodyBinary) {
+                requestBody = this.requestBody.data.toString('base64');
+            }
+        }
+        if (this.responseBody.realLength > 0) {
+            responseBodyLength = this.responseBody.realLength;
+            responseBodyTooLarge =
+                requestBodyLength >= utils_1.TUNNEL_MAX_REQUEST_SIZE_TO_SYNC;
+            responseBodyBinary = (0, isbinaryfile_1.isBinaryFileSync)(this.responseBody.data);
+            if (!responseBodyTooLarge && !responseBodyBinary) {
+                responseBody = this.responseBody.data.toString('base64');
+            }
+        }
+        return {
+            method: this.method,
+            headers: this.headers,
+            url: this.url,
+            httpVersion: this.httpVersion,
+            status: this.status,
+            finished: this.finished,
+            id: this.id,
+            responseHeaders: this.responseHeaders,
+            time: this.time,
+            requestBody,
+            requestBodyTooLarge,
+            requestBodyBinary,
+            requestBodyLength,
+            responseBody,
+            responseBodyTooLarge,
+            responseBodyBinary,
+            responseBodyLength,
+        };
+    }
+}
+class TunnelHttpLog extends events_1.default {
+    constructor(log, circuitBreakerThreshold) {
+        super();
+        this.log = log;
+        this.requests = [];
+        this.rateLimit = {};
+        this.circuitBreaker = {
+            active: circuitBreakerThreshold !== null,
+            threshold: circuitBreakerThreshold,
+            open: false,
+            test: false,
+            total: 0,
+            failed: 0,
+        };
+        this.tsRateLimit = setInterval(() => {
+            this.rateLimit = {};
+        }, utils_1.TUNNEL_HTTP_RATE_WINDOW);
+        if (this.circuitBreaker.active) {
+            this.tsCb = setInterval(() => {
+                const t = this.circuitBreaker.total;
+                const f = this.circuitBreaker.failed;
+                const r = !t ? 0 : f / t;
+                this.circuitBreaker.test = false;
+                if (!this.circuitBreaker.open) {
+                    if (f > 0 &&
+                        t >= utils_1.TUNNEL_HTTP_CB_MIN_REQUESTS &&
+                        r > this.circuitBreaker.threshold) {
+                        this.circuitBreaker.open = true;
+                    }
+                }
+                else {
+                    this.circuitBreaker.open = false;
+                    this.circuitBreaker.test = true;
+                }
+                this.circuitBreaker.total = 0;
+                this.circuitBreaker.failed = 0;
+            }, utils_1.TUNNEL_HTTP_CB_WINDOW);
+        }
+    }
+    stop() {
+        if (this.tsRateLimit) {
+            clearInterval(this.tsRateLimit);
+            this.tsRateLimit = null;
+        }
+        if (this.tsCb) {
+            clearInterval(this.tsCb);
+            this.tsCb = null;
+        }
+    }
+    getIp(req) {
+        let ip;
+        if (req.httpVersion === '2.0') {
+            ip = req.socket.stream ? req.socket.stream.remoteAddress : '::1';
+        }
+        else {
+            ip = req.socket.remoteAddress;
+        }
+        return ip;
+    }
+    increaseRateLimit(req) {
+        const ip = this.getIp(req);
+        if (!this.rateLimit[ip])
+            this.rateLimit[ip] = 0;
+        this.rateLimit[ip] += 1;
+    }
+    isRateLimited(req) {
+        const ip = this.getIp(req);
+        if (!this.rateLimit[ip])
+            return false;
+        return this.rateLimit[ip] >= utils_1.TUNNEL_HTTP_RATE_LIMIT;
+    }
+    isCircuitBreakerOpen() {
+        return this.circuitBreaker.active && this.circuitBreaker.open;
+    }
+    newRequest(method, headers, url, httpVersion, originalReq) {
+        this.increaseRateLimit(originalReq);
+        if (this.log) {
+            const r = new TunnelHttpLogRequest(method, headers, url, httpVersion);
+            this.requests.unshift(r);
+            if (this.requests.length > utils_1.TUNNEL_HTTP_LOG_MAX_REQUESTS)
+                this.requests.pop();
+            this.emit(utils_1.EVENT_TUNNEL_HTTP_NEW_REQUEST, r);
+            return r;
+        }
+    }
+    increaseCircuitBreaker(statusCode) {
+        if (this.circuitBreaker.active && !this.circuitBreaker.open) {
+            this.circuitBreaker.total += 1;
+            if (statusCode >= 500)
+                this.circuitBreaker.failed += 1;
+            if (this.circuitBreaker.test) {
+                const t = this.circuitBreaker.total;
+                const f = this.circuitBreaker.failed;
+                const rate = !t ? 0 : f / t;
+                if (f > 0 &&
+                    t >= utils_1.TUNNEL_HTTP_CB_MIN_REQUESTS &&
+                    rate > this.circuitBreaker.threshold) {
+                    this.circuitBreaker.open = true;
+                }
+            }
+        }
+    }
+    newResponse(req, statusCode, headers, logRequest) {
+        this.increaseCircuitBreaker(statusCode);
+        if (logRequest && this.log) {
+            logRequest.response(statusCode, headers);
+            this.emit(utils_1.EVENT_TUNNEL_HTTP_NEW_RESPONSE, logRequest);
+        }
+    }
+}
+exports.default = TunnelHttpLog;

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

@@ -0,0 +1,132 @@
+"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 path_1 = __importDefault(require("path"));
+const path_is_inside_1 = __importDefault(require("path-is-inside"));
+const range_parser_1 = __importDefault(require("range-parser"));
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = __importDefault(require("fs/promises"));
+const content_disposition_1 = __importDefault(require("content-disposition"));
+const mime_types_1 = __importDefault(require("mime-types"));
+const stream_1 = __importDefault(require("stream"));
+class TunnelHttpServe extends events_1.default {
+    constructor(serve) {
+        super();
+        this.serve = path_1.default.resolve(serve);
+    }
+    triggerError(err) {
+        this.emit('error', err);
+        this.emit('close');
+    }
+    trigger404() {
+        const s = new stream_1.default.Readable();
+        s.push('Not found');
+        s.push(null);
+        this.emit('response', 404, {
+            'content-type': 'text/plain',
+        }, s);
+        this.emit('close');
+    }
+    triggerResponse(statusCode, headers, stream) {
+        this.emit('response', statusCode, headers, stream);
+        this.emit('close');
+    }
+    async process(req) {
+        if (!['GET', 'HEAD'].includes(req.method)) {
+            this.trigger404();
+            return;
+        }
+        let relativePath;
+        try {
+            relativePath = decodeURIComponent(new URL(req.url, 'https://localhost').pathname);
+        }
+        catch (err) {
+            this.triggerError(err);
+            return;
+        }
+        let absolutePath = path_1.default.join(this.serve, relativePath);
+        if (!(0, path_is_inside_1.default)(absolutePath, this.serve)) {
+            this.trigger404();
+            return;
+        }
+        let stats;
+        try {
+            stats = await promises_1.default.lstat(absolutePath);
+        }
+        catch {
+            this.trigger404();
+            return;
+        }
+        if (stats.isDirectory()) {
+            absolutePath = path_1.default.join(absolutePath, 'index.html');
+            try {
+                stats = await promises_1.default.lstat(absolutePath);
+            }
+            catch {
+                this.trigger404();
+                return;
+            }
+        }
+        if (!stats.isFile()) {
+            this.trigger404();
+            return;
+        }
+        const streamOpts = {};
+        const headers = {};
+        let statusCode = 200;
+        if (req.headers.range && stats.size) {
+            const range = (0, range_parser_1.default)(stats.size, req.headers.range);
+            if (typeof range === 'object' && range.type === 'bytes') {
+                const { start, end } = range[0];
+                statusCode = 206;
+                streamOpts.start = start;
+                streamOpts.end = end;
+            }
+            else {
+                statusCode = 416;
+                headers['content-range'] = `bytes */${stats.size}`;
+            }
+        }
+        const { base } = path_1.default.parse(absolutePath);
+        headers['content-length'] = stats.size;
+        headers['content-disposition'] = (0, content_disposition_1.default)(base, {
+            type: 'inline',
+        });
+        headers['accept-ranges'] = 'bytes';
+        headers['last-modified'] = stats.mtime.toUTCString();
+        const contentType = mime_types_1.default.contentType(base);
+        if (contentType) {
+            headers['content-type'] = contentType;
+        }
+        if (streamOpts.start !== undefined && streamOpts.end !== undefined) {
+            headers['content-range'] =
+                `bytes ${streamOpts.start}-${streamOpts.end}/${stats.size}`;
+            headers['content-length'] = streamOpts.end - streamOpts.start + 1;
+        }
+        if (!req.headers.range && req.headers['if-modified-since']) {
+            const ims = Math.floor(Date.parse(req.headers['if-modified-since']) / 1000);
+            const mt = Math.floor(stats.mtime.getTime() / 1000);
+            if (mt <= ims) {
+                this.triggerResponse(304, headers);
+                return;
+            }
+        }
+        if (req.method === 'HEAD') {
+            this.triggerResponse(statusCode, headers);
+            return;
+        }
+        let stream;
+        try {
+            stream = fs_1.default.createReadStream(absolutePath, streamOpts);
+        }
+        catch (err) {
+            this.triggerError(err);
+            return;
+        }
+        this.triggerResponse(statusCode, headers, stream);
+    }
+}
+exports.default = TunnelHttpServe;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+class TunnelHttpStream extends stream_1.Transform {
+    constructor(maxSize) {
+        super();
+        this.maxSize = maxSize;
+        this.data = Buffer.alloc(0);
+        this.realLength = 0;
+        this.tooLarge = false;
+        this.backPressure = [];
+    }
+    _transform(chunk, encoding, callback) {
+        if (!this.tooLarge) {
+            if (this.data.length + chunk.length > this.maxSize) {
+                this.tooLarge = true;
+                this.data = Buffer.alloc(0);
+            }
+            else {
+                this.data = Buffer.concat([this.data, chunk]);
+            }
+        }
+        this.realLength += chunk.length;
+        this.backPressure.push(chunk);
+        this._pushBackPressure();
+        callback();
+    }
+    _pushBackPressure() {
+        while (this.backPressure.length > 0) {
+            const chunk = this.backPressure.shift();
+            if (!this.push(chunk)) {
+                this.removeAllListeners('drain');
+                this.once('drain', () => {
+                    this._pushBackPressure();
+                });
+                break;
+            }
+        }
+    }
+    pipeToNothing(done) {
+        this.once('end', done);
+        this.resume();
+    }
+}
+exports.default = TunnelHttpStream;