bdy 1.8.3-dev → 1.8.4-dev

package/distTs/src/utils.js

@@ -0,0 +1,437 @@
+"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 });
+exports.TUNNEL_EVENT_HTTP_CLOSED = exports.TUNNEL_EVENT_HTTP_OPEN = exports.TUNNEL_EVENT_TLS_CLOSED = exports.TUNNEL_EVENT_TLS_OPEN = exports.TUNNEL_EVENT_TCP_CLOSED = exports.TUNNEL_EVENT_TCP_OPEN = exports.TUNNEL_EVENT_CLOSED = exports.TUNNEL_EVENT_OPEN = exports.EVENT_TUNNEL_HTTP_NEW_RESPONSE_END = exports.EVENT_TUNNEL_HTTP_NEW_RESPONSE = exports.EVENT_TUNNEL_HTTP_NEW_REQUEST_END = exports.EVENT_TUNNEL_HTTP_NEW_REQUEST = exports.TUNNEL_HTTP_CB_MIN_REQUESTS = exports.TUNNEL_HTTP_CB_WINDOW = exports.TUNNEL_MAX_REQUEST_SIZE_TO_SYNC = exports.TUNNEL_HTTP_LOG_MAX_REQUESTS = exports.TUNNEL_HTTP_LOG_MAX_BODY = exports.TUNNEL_HTTP_RATE_WINDOW = exports.TUNNEL_HTTP_RATE_LIMIT = exports.SOCKET_TYPE_SSH = exports.SOCKET_TYPE_HTTP2 = exports.SOCKET_TYPE_HTTP1 = exports.SOCKET_TYPE_TLS = exports.SOCKET_TYPE_TCP = exports.SSH_CLIENT_EVENT_STREAM_HTTP2 = exports.SSH_CLIENT_EVENT_STREAM_HTTP1 = exports.SSH_CLIENT_EVENT_STREAM_TLS = exports.SSH_CLIENT_EVENT_STREAM_TCP = exports.SSH_CLIENT_EVENT_STREAM_SSH = exports.SSH_CLIENT_EVENT_DISCONNECTED = exports.SSH_CLIENT_EVENT_CONNECTED = exports.TLS_SOCKET = exports.HTTP2_REQUEST = exports.HTTP2_SESSION_CLOSED = exports.HTTP2_SESSION_OPEN = exports.HTTP1_REQUEST = exports.HTTP1_SOCKET_CLOSED = exports.HTTP1_SOCKET_OPEN = exports.TUNNEL_IDENTIFIED_HTTP2 = exports.TUNNEL_IDENTIFIED_HTTP1 = exports.EVENT_TUNNEL_IDENTIFIED = exports.TUNNEL_SSH = exports.TUNNEL_TLS = exports.TUNNEL_TCP = exports.TUNNEL_HTTP = exports.TLS_TERMINATE_AT_REGION = exports.TLS_TERMINATE_AT_AGENT = exports.TLS_TERMINATE_AT_TARGET = exports.REGION_EU = exports.REGION_US = void 0;
+exports.TUNNEL_LATENCY_EVENT_RECONNECTED = exports.TUNNEL_COMPRESSION_METHOD_DEFLATE = exports.TUNNEL_COMPRESSION_METHOD_GZIP = exports.TUNNEL_COMPRESSION_METHOD_BR = exports.TUNNEL_COMPRESSION_METHOD_IDENTITY = exports.TARGET_ONLY_PORT_REGEX = exports.TARGET_HTTP_REGEX = exports.TARGET_TCP_TLS_REGEX = exports.ApiErrorTunnelsDisabled = exports.ApiErrorTunnelLimitReached = exports.ApiErrorAgentLimitReached = exports.ApiErrorSubdomainTaken = exports.ApiErrorWrongToken = exports.ApiErrorFailedToConnect = exports.ApiErrorAgentNotFound = exports.SOCKET_IO_EVENT_TUNNEL = exports.SOCKET_IO_EVENT_AGENT = exports.SOCKET_IO_EVENT_FETCH_FAILED = exports.SOCKET_IO_EVENT_FETCH_SUCCESS = exports.SOCKET_IO_EVENT_DISCONNECTED = exports.SOCKET_IO_EVENT_CONNECTED = exports.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RETRY = exports.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RESPONSE = exports.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUEST = exports.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUESTS = exports.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_IDENTIFIED = exports.AGENT_SOCKET_MESSAGE_TUNNEL_TLS_CLOSED = exports.AGENT_SOCKET_MESSAGE_TUNNEL_TLS_OPEN = exports.AGENT_SOCKET_MESSAGE_TUNNEL_TCP_CLOSED = exports.AGENT_SOCKET_MESSAGE_TUNNEL_TCP_OPEN = exports.AGENT_SOCKET_MESSAGE_TUNNEL_CLOSED = exports.AGENT_SOCKET_MESSAGE_TUNNEL_OPEN = exports.AGENT_SOCKET_MESSAGE_TUNNEL_STOPPED = exports.AGENT_SOCKET_MESSAGE_TUNNEL = exports.AGENT_SOCKET_MESSAGE_READY = exports.AGENT_ACTION_DELETE = exports.AGENT_ACTION_RESTART = exports.AGENT_ACTION_START = exports.AGENT_ACTION_STOP = exports.AGENT_STATUS_ENABLED = exports.AGENT_STATUS_FETCH_FAILED = exports.AGENT_STATUS_INITIALIZING = exports.AGENT_STATUS_DISABLED = exports.DEFAULT_TIMEOUT = exports.TUNNEL_CLOSED = exports.TUNNEL_OPEN = exports.TUNNEL_EVENT_STOPPED = exports.TUNNEL_EVENT_HTTP_RESPONSE = exports.TUNNEL_EVENT_HTTP_REQUEST = exports.TUNNEL_EVENT_HTTP_IDENTIFIED = void 0;
+exports.getBasicCommandTls = exports.getBasicCommandHttp = exports.getBasicCommandTcp = exports.createSshHostKey = exports.getRealTargetHost = exports.isWindows = exports.isLinux = exports.isOsx = exports.isDocker = exports.sleep = exports.getLatestVersion = exports.getVersionEnv = exports.getVersionWithoutEnv = exports.getVersion = exports.getHomeDirectory = exports.newCommand = exports.formatHelp = exports.getPlatform = exports.getHostname = exports.isStringRegExp = exports.getRootDir = exports.TCP_EVENT_CLOSED = void 0;
+exports.apiErrorCodeToClass = apiErrorCodeToClass;
+const node_path_1 = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const texts_1 = require("./texts");
+const ssh2_1 = __importDefault(require("ssh2"));
+const node_sea_1 = require("node:sea");
+const commander_1 = require("commander");
+const texts_js_1 = require("./texts.js");
+const node_os_1 = __importStar(require("node:os"));
+exports.REGION_US = 'US';
+exports.REGION_EU = 'EU';
+exports.TLS_TERMINATE_AT_TARGET = 'TARGET';
+exports.TLS_TERMINATE_AT_AGENT = 'AGENT';
+exports.TLS_TERMINATE_AT_REGION = 'REGION';
+exports.TUNNEL_HTTP = 'HTTP';
+exports.TUNNEL_TCP = 'TCP';
+exports.TUNNEL_TLS = 'TLS';
+exports.TUNNEL_SSH = 'SSH';
+exports.EVENT_TUNNEL_IDENTIFIED = 'tunnel identified';
+exports.TUNNEL_IDENTIFIED_HTTP1 = '1.1';
+exports.TUNNEL_IDENTIFIED_HTTP2 = '2.0';
+exports.HTTP1_SOCKET_OPEN = 'http socket open';
+exports.HTTP1_SOCKET_CLOSED = 'http socket closed';
+exports.HTTP1_REQUEST = 'http request';
+exports.HTTP2_SESSION_OPEN = 'http session open';
+exports.HTTP2_SESSION_CLOSED = 'http session closed';
+exports.HTTP2_REQUEST = 'http request';
+exports.TLS_SOCKET = 'tls socket';
+exports.SSH_CLIENT_EVENT_CONNECTED = 'connected';
+exports.SSH_CLIENT_EVENT_DISCONNECTED = 'disconnected';
+exports.SSH_CLIENT_EVENT_STREAM_SSH = 'stream ssh';
+exports.SSH_CLIENT_EVENT_STREAM_TCP = 'stream tcp';
+exports.SSH_CLIENT_EVENT_STREAM_TLS = 'stream tls';
+exports.SSH_CLIENT_EVENT_STREAM_HTTP1 = 'stream http1';
+exports.SSH_CLIENT_EVENT_STREAM_HTTP2 = 'stream http2';
+exports.SOCKET_TYPE_TCP = 0;
+exports.SOCKET_TYPE_TLS = 1;
+exports.SOCKET_TYPE_HTTP1 = 2;
+exports.SOCKET_TYPE_HTTP2 = 3;
+exports.SOCKET_TYPE_SSH = 4;
+exports.TUNNEL_HTTP_RATE_LIMIT = 2000;
+exports.TUNNEL_HTTP_RATE_WINDOW = 60000;
+exports.TUNNEL_HTTP_LOG_MAX_BODY = 5242880; // 5MB
+exports.TUNNEL_HTTP_LOG_MAX_REQUESTS = 20;
+exports.TUNNEL_MAX_REQUEST_SIZE_TO_SYNC = 25600; // 25kB (1 request do frontu moze miec max 1MB, 20 requestow po req i res body)
+exports.TUNNEL_HTTP_CB_WINDOW = 10000;
+exports.TUNNEL_HTTP_CB_MIN_REQUESTS = 20;
+exports.EVENT_TUNNEL_HTTP_NEW_REQUEST = 'new request';
+exports.EVENT_TUNNEL_HTTP_NEW_REQUEST_END = 'new request end';
+exports.EVENT_TUNNEL_HTTP_NEW_RESPONSE = 'new response';
+exports.EVENT_TUNNEL_HTTP_NEW_RESPONSE_END = 'new response end';
+exports.TUNNEL_EVENT_OPEN = 'open';
+exports.TUNNEL_EVENT_CLOSED = 'closed';
+exports.TUNNEL_EVENT_TCP_OPEN = 'tcp open';
+exports.TUNNEL_EVENT_TCP_CLOSED = 'tcp closed';
+exports.TUNNEL_EVENT_TLS_OPEN = 'tls open';
+exports.TUNNEL_EVENT_TLS_CLOSED = 'tls closed';
+exports.TUNNEL_EVENT_HTTP_OPEN = 'http open';
+exports.TUNNEL_EVENT_HTTP_CLOSED = 'http closed';
+exports.TUNNEL_EVENT_HTTP_IDENTIFIED = 'http identified';
+exports.TUNNEL_EVENT_HTTP_REQUEST = 'http request';
+exports.TUNNEL_EVENT_HTTP_RESPONSE = 'http response';
+exports.TUNNEL_EVENT_STOPPED = 'stopped';
+exports.TUNNEL_OPEN = 'OPEN';
+exports.TUNNEL_CLOSED = 'CLOSED';
+exports.DEFAULT_TIMEOUT = 30;
+exports.AGENT_STATUS_DISABLED = 'disabled';
+exports.AGENT_STATUS_INITIALIZING = 'initializing';
+exports.AGENT_STATUS_FETCH_FAILED = 'fetch agent failed, retrying';
+exports.AGENT_STATUS_ENABLED = 'enabled';
+exports.AGENT_ACTION_STOP = 'STOP';
+exports.AGENT_ACTION_START = 'START';
+exports.AGENT_ACTION_RESTART = 'RESTART';
+exports.AGENT_ACTION_DELETE = 'DELETE';
+exports.AGENT_SOCKET_MESSAGE_READY = 'ready';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL = 'tunnel';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL_STOPPED = 'tunnel stopped';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL_OPEN = 'tunnel open';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL_CLOSED = 'tunnel closed';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL_TCP_OPEN = 'tunnel tcp open';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL_TCP_CLOSED = 'tunnel tcp closed';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL_TLS_OPEN = 'tunnel tls open';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL_TLS_CLOSED = 'tunnel tls closed';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_IDENTIFIED = 'tunnel http identified';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUESTS = 'tunnel http requests';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUEST = 'tunnel http request';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RESPONSE = 'tunnel http response';
+exports.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RETRY = 'tunnel http retry';
+exports.SOCKET_IO_EVENT_CONNECTED = 'socket connected';
+exports.SOCKET_IO_EVENT_DISCONNECTED = 'socket disconnected';
+exports.SOCKET_IO_EVENT_FETCH_SUCCESS = 'fetch success';
+exports.SOCKET_IO_EVENT_FETCH_FAILED = 'fetch failed';
+exports.SOCKET_IO_EVENT_AGENT = 'agent';
+exports.SOCKET_IO_EVENT_TUNNEL = 'tunnel';
+function apiErrorCodeToClass(code, host) {
+    if (code === 234000) {
+        return new ApiErrorAgentNotFound();
+    }
+    if (code === 234020) {
+        return new ApiErrorWrongToken();
+    }
+    if (code === 234003) {
+        return new ApiErrorSubdomainTaken();
+    }
+    if (code === 234500) {
+        return new ApiErrorTunnelsDisabled();
+    }
+    if (code === 234502) {
+        return new ApiErrorAgentLimitReached();
+    }
+    if (code === 234501) {
+        return new ApiErrorTunnelLimitReached();
+    }
+    return new ApiErrorFailedToConnect(host);
+}
+class ApiErrorAgentNotFound extends Error {
+    constructor() {
+        super(texts_1.ERR_AGENT_REMOVED);
+    }
+}
+exports.ApiErrorAgentNotFound = ApiErrorAgentNotFound;
+class ApiErrorFailedToConnect extends Error {
+    constructor(host) {
+        super((0, texts_1.ERR_FAILED_TO_CONNECT)(host));
+    }
+}
+exports.ApiErrorFailedToConnect = ApiErrorFailedToConnect;
+class ApiErrorWrongToken extends Error {
+    constructor() {
+        super(texts_1.ERR_WRONG_TOKEN);
+    }
+}
+exports.ApiErrorWrongToken = ApiErrorWrongToken;
+class ApiErrorSubdomainTaken extends Error {
+    constructor() {
+        super(texts_1.ERR_SUBDOMAIN_TAKEN);
+    }
+}
+exports.ApiErrorSubdomainTaken = ApiErrorSubdomainTaken;
+class ApiErrorAgentLimitReached extends Error {
+    constructor() {
+        super(texts_1.ERR_AGENT_LIMIT_REACHED);
+    }
+}
+exports.ApiErrorAgentLimitReached = ApiErrorAgentLimitReached;
+class ApiErrorTunnelLimitReached extends Error {
+    constructor() {
+        super(texts_1.ERR_TUNNEL_LIMIT_REACHED);
+    }
+}
+exports.ApiErrorTunnelLimitReached = ApiErrorTunnelLimitReached;
+class ApiErrorTunnelsDisabled extends Error {
+    constructor() {
+        super(texts_1.ERR_TUNNELS_DISABLED);
+    }
+}
+exports.ApiErrorTunnelsDisabled = ApiErrorTunnelsDisabled;
+exports.TARGET_TCP_TLS_REGEX = /^(([^:]+):)?(\d+)$/i;
+exports.TARGET_HTTP_REGEX = /^((https?):\/\/)?([^:/]+:[^@:]+@)?([^:]+)(:(\d+))?$/i;
+exports.TARGET_ONLY_PORT_REGEX = /^\d+$/i;
+exports.TUNNEL_COMPRESSION_METHOD_IDENTITY = 'identity';
+exports.TUNNEL_COMPRESSION_METHOD_BR = 'br';
+exports.TUNNEL_COMPRESSION_METHOD_GZIP = 'gzip';
+exports.TUNNEL_COMPRESSION_METHOD_DEFLATE = 'deflate';
+exports.TUNNEL_LATENCY_EVENT_RECONNECTED = 'reconnected';
+exports.TCP_EVENT_CLOSED = 'closed';
+let cachedVersion;
+let cachedRoot;
+const getRootDir = () => {
+    if (!cachedRoot) {
+        cachedRoot = node_path_1.default.resolve(__dirname, '..');
+    }
+    return cachedRoot;
+};
+exports.getRootDir = getRootDir;
+const isStringRegExp = (str) => /^\/.*\/$/.test(str);
+exports.isStringRegExp = isStringRegExp;
+const getHostname = () => {
+    return node_os_1.default.hostname();
+};
+exports.getHostname = getHostname;
+const getPlatform = () => {
+    return node_os_1.default.platform();
+};
+exports.getPlatform = getPlatform;
+const formatHelp = (cmd, helper) => {
+    const termWidth = helper.padWidth(cmd, helper);
+    const helpWidth = helper.helpWidth || 80;
+    const itemIndentWidth = 2;
+    const itemSeparatorWidth = 2; // between term and description
+    function formatItem(term, description) {
+        if (description) {
+            const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
+            return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
+        }
+        return term;
+    }
+    function formatList(textArray) {
+        return textArray.join('\n').replace(/^/gm, ' '.repeat(itemIndentWidth));
+    }
+    // Usage
+    let output = ['USAGE:', `  ${helper.commandUsage(cmd)}`, ''];
+    // Description
+    const commandDescription = helper.commandDescription(cmd);
+    if (commandDescription.length > 0) {
+        output = output.concat([
+            'DESCRIPTION:',
+            `  ${helper.wrap(commandDescription, helpWidth, itemIndentWidth)}`,
+            '',
+        ]);
+    }
+    // Arguments
+    const argumentList = helper
+        .visibleArguments(cmd)
+        .map((argument) => {
+        return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
+    });
+    if (argumentList.length > 0) {
+        output = output.concat(['ARGUMENTS:', formatList(argumentList), '']);
+    }
+    // Options
+    const optionList = helper.visibleOptions(cmd).map((option) => {
+        return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+    });
+    if (optionList.length > 0) {
+        output = output.concat(['OPTIONS:', formatList(optionList), '']);
+    }
+    // Commands
+    const commandList = helper.visibleCommands(cmd).map((cmd) => {
+        return formatItem(helper.subcommandTerm(cmd), helper.subcommandDescription(cmd));
+    });
+    if (commandList.length > 0) {
+        output = output.concat(['COMMANDS:', formatList(commandList), '']);
+    }
+    return output.join('\n');
+};
+exports.formatHelp = formatHelp;
+const newCommand = (name, desc) => {
+    const cmd = new commander_1.Command(name);
+    if (desc)
+        cmd.description(desc);
+    cmd.configureHelp({
+        formatHelp: exports.formatHelp,
+    });
+    return cmd;
+};
+exports.newCommand = newCommand;
+const getHomeDirectory = () => {
+    if ((0, exports.isDocker)())
+        return '/buddy';
+    const r = (0, node_os_1.homedir)();
+    const p = node_path_1.default.join(r, '.bdy');
+    if (!(0, node_fs_1.existsSync)(p)) {
+        (0, node_fs_1.mkdirSync)(p, { recursive: true });
+        try {
+            (0, node_fs_1.chmodSync)(p, 0o777);
+        }
+        catch {
+            // do nothing
+        }
+    }
+    return p;
+};
+exports.getHomeDirectory = getHomeDirectory;
+const getVersion = () => {
+    if (!cachedVersion) {
+        let packageJson;
+        if ((0, node_sea_1.isSea)()) {
+            packageJson = JSON.parse((0, node_sea_1.getAsset)('package.json', 'utf8'));
+        }
+        else {
+            const root = (0, exports.getRootDir)();
+            packageJson = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.resolve)(root, 'package.json'), 'utf8'));
+        }
+        cachedVersion = packageJson.version;
+    }
+    return cachedVersion;
+};
+exports.getVersion = getVersion;
+const getVersionWithoutEnv = () => {
+    const v = (0, exports.getVersion)();
+    const m = v.match(/^\d+\.\d+\.\d+/);
+    if (m)
+        return m[0];
+    return '0.0.0';
+};
+exports.getVersionWithoutEnv = getVersionWithoutEnv;
+const getVersionEnv = () => {
+    const v = (0, exports.getVersion)();
+    if (/dev/.test(v))
+        return 'dev';
+    if (/beta/.test(v))
+        return 'beta';
+    if (/stage/.test(v))
+        return 'stage';
+    if (/master/.test(v))
+        return 'master';
+    return 'prod';
+};
+exports.getVersionEnv = getVersionEnv;
+const getLatestVersion = async () => {
+    try {
+        const env = (0, exports.getVersionEnv)();
+        const c = new AbortController();
+        setTimeout(() => {
+            c.abort();
+        }, 10000);
+        const response = await fetch(`https://es.buddy.works/bdy/${env}/latest`, {
+            method: 'GET',
+            signal: c.signal,
+        });
+        if (response.status === 200) {
+            const data = await response.text();
+            const v = data.trim();
+            if (env === 'prod')
+                return v;
+            return `${v}-${env}`;
+        }
+        else {
+            return '0.0.0';
+        }
+    }
+    catch {
+        throw new Error(texts_js_1.ERR_FETCH_VERSION);
+    }
+};
+exports.getLatestVersion = getLatestVersion;
+const sleep = (ms) => {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+};
+exports.sleep = sleep;
+const isDocker = () => {
+    return process.env['IS_IN_DOCKER'] === '1';
+};
+exports.isDocker = isDocker;
+const isOsx = () => {
+    return node_os_1.default.platform() === 'darwin';
+};
+exports.isOsx = isOsx;
+const isLinux = () => {
+    return node_os_1.default.platform() === 'linux';
+};
+exports.isLinux = isLinux;
+const isWindows = () => {
+    return node_os_1.default.platform() === 'win32';
+};
+exports.isWindows = isWindows;
+const getRealTargetHost = (target) => {
+    return target;
+};
+exports.getRealTargetHost = getRealTargetHost;
+const createSshHostKey = () => {
+    const keys = ssh2_1.default.utils.generateKeyPairSync('ed25519', {});
+    return keys.private;
+};
+exports.createSshHostKey = createSshHostKey;
+const getBasicCommandTcp = () => {
+    const commandTcp = (0, exports.newCommand)('tcp');
+    commandTcp.alias('TCP');
+    commandTcp.option('-r, --region <region>', texts_1.OPTION_REGION);
+    commandTcp.option('-w, --whitelist <cidrs...>', texts_1.OPTION_WHITELIST);
+    commandTcp.option('-b, --subdomain <subdomain>', texts_1.OPTION_SUBDOMAIN);
+    commandTcp.option('-d, --domain <domain>', texts_1.OPTION_DOMAIN);
+    commandTcp.option('-t, --timeout <seconds>', texts_1.OPTION_TIMEOUT);
+    return commandTcp;
+};
+exports.getBasicCommandTcp = getBasicCommandTcp;
+const getBasicCommandHttp = () => {
+    const commandHttp = (0, exports.newCommand)('http');
+    commandHttp.alias('HTTP');
+    commandHttp.option('-r, --region <region>', texts_1.OPTION_REGION);
+    commandHttp.option('-w, --whitelist <cidrs...>', texts_1.OPTION_WHITELIST);
+    commandHttp.option('-b, --subdomain <subdomain>', texts_1.OPTION_SUBDOMAIN);
+    commandHttp.option('-d, --domain <domain>', texts_1.OPTION_DOMAIN);
+    commandHttp.option('-t, --timeout <seconds>', texts_1.OPTION_TIMEOUT);
+    commandHttp.option('-h, --host <host>', texts_1.OPTION_HTTP_HOST);
+    commandHttp.option('--header <headers...>', texts_1.OPTION_HEADER);
+    commandHttp.option('--response-header <headers...>', texts_1.OPTION_RESPONSE_HEADER);
+    commandHttp.option('--useragent <useragent...>', texts_1.OPTION_HEADER_USER_AGENT);
+    commandHttp.option('-a, --auth <user:pass>', texts_1.OPTION_HTTP_AUTH);
+    commandHttp.option('-l, --log', texts_1.OPTION_HTTP_LOG);
+    commandHttp.option('-v, --verify', texts_1.OPTION_HTTP_VERIFY);
+    commandHttp.option('-2, --http2', texts_1.OPTION_HTTP_2);
+    commandHttp.option('-c, --compression', texts_1.OPTION_HTTP_COMPRESSION);
+    commandHttp.option('--ca <ca>', texts_1.OPTION_TLS_CA);
+    commandHttp.option('--circuit-breaker <threshold>', texts_1.OPTION_HTTP_CIRCUIT_BREAKER);
+    return commandHttp;
+};
+exports.getBasicCommandHttp = getBasicCommandHttp;
+const getBasicCommandTls = () => {
+    const commandTls = (0, exports.newCommand)('tls');
+    commandTls.alias('TLS');
+    commandTls.option('-r, --region <region>', texts_1.OPTION_REGION);
+    commandTls.option('-w, --whitelist <cidrs...>', texts_1.OPTION_WHITELIST);
+    commandTls.option('-b, --subdomain <subdomain>', texts_1.OPTION_SUBDOMAIN);
+    commandTls.option('-d, --domain <domain>', texts_1.OPTION_DOMAIN);
+    commandTls.option('-t, --timeout <seconds>', texts_1.OPTION_TIMEOUT);
+    commandTls.option('-k, --key <key>', texts_1.OPTION_TLS_KEY);
+    commandTls.option('-c, --cert <cert>', texts_1.OPTION_TLS_CERT);
+    commandTls.option('--ca <ca>', texts_1.OPTION_TLS_CA);
+    commandTls.option('-i, --terminate <at>', texts_1.OPTION_TLS_TERMINATE);
+    return commandTls;
+};
+exports.getBasicCommandTls = getBasicCommandTls;

package/distTs/src/visualTest/browser.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrowserPath = getBrowserPath;
+const browsers_1 = require("@puppeteer/browsers");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const output_1 = __importDefault(require("../output"));
+const texts_1 = require("../texts");
+const customBrowserPath = process.env.SNAPSHOTS_BROWSER_PATH;
+const cacheDir = (0, node_path_1.join)((0, node_os_1.homedir)(), '.cache', 'puppeteer');
+const installOptions = {
+    cacheDir,
+    browser: browsers_1.Browser.CHROMEHEADLESSSHELL,
+    buildId: '130.0.6723.69',
+};
+async function getBrowserPath() {
+    const installedBrowsers = await (0, browsers_1.getInstalledBrowsers)({ cacheDir });
+    const browserFromCache = installedBrowsers.find((browser) => browser.browser === installOptions.browser &&
+        browser.buildId === installOptions.buildId);
+    if (customBrowserPath || browserFromCache) {
+        return customBrowserPath || browserFromCache?.executablePath;
+    }
+    else {
+        await (0, browsers_1.canDownload)(installOptions);
+        const installedBrowser = await (0, browsers_1.install)(installOptions);
+        output_1.default.normal(texts_1.LOG_INSTALLED_BROWSER);
+        return installedBrowser.executablePath;
+    }
+}

package/distTs/src/visualTest/ci.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCiAndGitInfo = getCiAndGitInfo;
+exports.logCiInfo = logCiInfo;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const exec_js_1 = require("./exec.js");
+const ciInfo_js_1 = require("../types/ciInfo.js");
+const output_1 = __importDefault(require("../output"));
+const texts_1 = require("../texts");
+async function getGithubPullRequestCommit() {
+    const payloadPath = process.env.GITHUB_EVENT_PATH;
+    if (!payloadPath) {
+        output_1.default.warning(texts_1.ERR_GITHUB_EVENT_PATH_NOT_FOUND);
+        return process.env.GITHUB_SHA;
+    }
+    try {
+        await promises_1.default.access(payloadPath);
+    }
+    catch (error) {
+        output_1.default.warning((0, texts_1.ERR_MISSING_FILE_WITH_HEAD_COMMIT)(payloadPath, JSON.stringify(error)));
+        return process.env.GITHUB_SHA;
+    }
+    let payload;
+    try {
+        const payloadFile = await promises_1.default.readFile(payloadPath);
+        payload = JSON.parse(payloadFile.toString());
+    }
+    catch (error) {
+        output_1.default.warning((0, texts_1.ERR_READING_FILE_WITH_HEAD_COMMIT)(payloadPath, JSON.stringify(error)));
+        return process.env.GITHUB_SHA;
+    }
+    if (!payload?.pull_request) {
+        output_1.default.warning(texts_1.ERR_MISSING_HEAD_COMMIT_IN_FILE);
+        return process.env.GITHUB_SHA;
+    }
+    return payload.pull_request.head.sha;
+}
+async function getBranchName() {
+    let branch = '';
+    try {
+        branch = await (0, exec_js_1.gitExec)(['rev-parse', '--abbrev-ref', 'HEAD']);
+    }
+    catch (error) {
+        output_1.default.warning((0, texts_1.ERR_GETTING_BRANCH_NAME)(JSON.stringify(error)));
+    }
+    branch = branch.trim();
+    if (!branch) {
+        output_1.default.warning(texts_1.ERR_INVALID_BRANCH_NAME);
+        return;
+    }
+    return branch?.trim();
+}
+async function getCommitHash() {
+    let commit = '';
+    try {
+        commit = await (0, exec_js_1.gitExec)(['rev-parse', '--verify', 'HEAD']);
+    }
+    catch (error) {
+        output_1.default.warning((0, texts_1.ERR_GETTING_COMMIT_HASH)(JSON.stringify(error)));
+    }
+    commit = commit.trim();
+    if (!commit || commit.length !== 40) {
+        output_1.default.warning((0, texts_1.ERR_INVALID_COMMIT_HASH)(commit));
+        return;
+    }
+    return commit;
+}
+async function getBaseCommit(baseBranch, headBranch, requiredOriginPrefix) {
+    if (!baseBranch) {
+        output_1.default.warning(texts_1.ERR_BASE_BRANCH_NOT_DEFINED);
+        return;
+    }
+    if (!headBranch) {
+        output_1.default.warning(texts_1.ERR_HEAD_BRANCH_NOT_DEFINED);
+        return;
+    }
+    let commit = '';
+    try {
+        const preparedBranch = requiredOriginPrefix && !headBranch.includes('origin/')
+            ? `origin/${headBranch}`
+            : headBranch;
+        const preparedBaseBranch = requiredOriginPrefix && !baseBranch.includes('origin/')
+            ? `origin/${baseBranch}`
+            : baseBranch;
+        commit = await (0, exec_js_1.gitExec)(['merge-base', preparedBranch, preparedBaseBranch]);
+    }
+    catch (error) {
+        output_1.default.warning((0, texts_1.ERR_GETTING_BASE_COMMIT)(baseBranch, headBranch, JSON.stringify(error)));
+    }
+    commit = commit.trim();
+    if (!commit || commit.length !== 40) {
+        output_1.default.warning((0, texts_1.ERR_INVALID_COMMIT_HASH)(commit));
+        return;
+    }
+    return commit;
+}
+async function getCommitDetails(commitHash) {
+    if (commitHash) {
+        try {
+            const commitDetails = await (0, exec_js_1.gitExec)([
+                'show',
+                '--no-patch',
+                '--pretty=%an%n%ae%n%ct%n%B',
+                commitHash,
+            ]);
+            const [authorName, authorEmail, authorDate, message] = commitDetails.split('\n');
+            const authorDateNumber = Number(authorDate);
+            return {
+                authorName,
+                authorEmail,
+                authorDate: Number.isNaN(authorDateNumber)
+                    ? undefined
+                    : authorDateNumber,
+                message,
+            };
+        }
+        catch (error) {
+            output_1.default.warning((0, texts_1.ERR_GETTING_COMMIT_DETAILS)(JSON.stringify(error)));
+        }
+    }
+}
+async function getCiAndGitInfo(baseBranch) {
+    const isBuddy = process.env.BUDDY === 'true';
+    const isGithubAction = process.env.GITHUB_ACTIONS === 'true';
+    const isCircleCI = process.env.CIRCLECI === 'true';
+    const forceBranch = process.env.SNAPSHOTS_BRANCH;
+    const forceCommit = process.env.SNAPSHOTS_COMMIT;
+    const forceBaseCommit = process.env.SNAPSHOTS_BASE_COMMIT;
+    if (isBuddy) {
+        const isPR = process.env.BUDDY_EXECUTION_PULL_REQUEST_ID;
+        const branch = forceBranch || isPR
+            ? process.env.BUDDY_EXECUTION_PULL_REQUEST_HEAD_BRANCH
+            : process.env.BUDDY_EXECUTION_BRANCH;
+        const commit = forceCommit || process.env.BUDDY_EXECUTION_REVISION;
+        const baseCommit = forceBaseCommit || isPR
+            ? await getBaseCommit(baseBranch, branch, true)
+            : undefined;
+        const invokerId = Number(process.env.BUDDY_INVOKER_ID);
+        const pipelineId = Number(process.env.BUDDY_PIPELINE_ID);
+        const actionId = Number(process.env.BUDDY_ACTION_ID);
+        const executionId = Number(process.env.BUDDY_EXECUTION_ID);
+        return {
+            ci: ciInfo_js_1.CI.BUDDY,
+            branch,
+            commit,
+            baseCommit,
+            pipelineName: process.env.BUDDY_PIPELINE_NAME,
+            pipelineId: Number.isNaN(pipelineId) ? undefined : pipelineId,
+            actionId: Number.isNaN(actionId) ? undefined : actionId,
+            executionId: Number.isNaN(executionId) ? undefined : executionId,
+            invokerId: Number.isNaN(invokerId) ? undefined : invokerId,
+            commitDetails: await getCommitDetails(commit),
+        };
+    }
+    if (isGithubAction) {
+        const isPR = process.env.GITHUB_EVENT_NAME === 'pull_request';
+        const branch = forceBranch || isPR
+            ? process.env.GITHUB_HEAD_REF
+            : process.env.GITHUB_REF_NAME;
+        const commit = forceCommit || isPR
+            ? await getGithubPullRequestCommit()
+            : process.env.GITHUB_SHA;
+        const baseCommit = forceBaseCommit || isPR
+            ? await getBaseCommit(baseBranch, branch, true)
+            : undefined;
+        return {
+            ci: ciInfo_js_1.CI.GITHUB_ACTION,
+            branch,
+            commit,
+            baseCommit,
+            commitDetails: await getCommitDetails(commit),
+        };
+    }
+    if (isCircleCI) {
+        const isPR = process.env.CIRCLE_PULL_REQUEST;
+        const branch = forceBranch || process.env.CIRCLE_BRANCH;
+        const commit = forceCommit || process.env.CIRCLE_SHA1;
+        const baseCommit = forceBaseCommit || isPR
+            ? await getBaseCommit(baseBranch, branch)
+            : undefined;
+        return {
+            ci: ciInfo_js_1.CI.CIRCLE_CI,
+            branch: process.env.CIRCLE_BRANCH,
+            commit,
+            baseCommit,
+            commitDetails: await getCommitDetails(commit),
+        };
+    }
+    const branch = forceBranch || (await getBranchName());
+    const commit = forceCommit || (await getCommitHash());
+    return {
+        ci: ciInfo_js_1.CI.NONE,
+        branch,
+        commit,
+        baseCommit: branch && branch !== baseBranch
+            ? forceBaseCommit || (await getBaseCommit(baseBranch, branch))
+            : undefined,
+        commitDetails: await getCommitDetails(commit),
+    };
+}
+function logCiInfo(ciInfo) {
+    output_1.default.normal((0, texts_1.TXT_CI_INFO)(ciInfo));
+}