bdy 1.8.3-dev → 1.8.4-dev

package/distTs/src/command/config/set/timeout.js

@@ -0,0 +1,17 @@
+"use strict";
+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 cfg_js_1 = __importDefault(require("../../../cfg.js"));
+const input_js_1 = __importDefault(require("../../../input.js"));
+const utils_js_1 = require("../../../utils.js");
+const texts_js_1 = require("../../../texts.js");
+const commandConfigSetTimeout = (0, utils_js_1.newCommand)('timeout', texts_js_1.DESC_COMMAND_CONFIG_SET_TIMEOUT);
+commandConfigSetTimeout.argument('[timeout]', texts_js_1.OPTION_TIMEOUT, utils_js_1.DEFAULT_TIMEOUT);
+commandConfigSetTimeout.action((timeout) => {
+    cfg_js_1.default.setTimeout(input_js_1.default.timeout(timeout));
+    output_js_1.default.exitSuccess(texts_js_1.TXT_TIMEOUT_SAVED);
+});
+exports.default = commandConfigSetTimeout;

package/distTs/src/command/config/set/token.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cfg_js_1 = __importDefault(require("../../../cfg.js"));
+const output_js_1 = __importDefault(require("../../../output.js"));
+const texts_js_1 = require("../../../texts.js");
+const utils_1 = require("../../../utils");
+const commandConfigSetToken = (0, utils_1.newCommand)('token', texts_js_1.DESC_COMMAND_CONFIG_SET_TOKEN);
+commandConfigSetToken.argument('[token]', texts_js_1.OPTION_TOKEN, '');
+commandConfigSetToken.action((token) => {
+    cfg_js_1.default.setToken(token);
+    output_js_1.default.exitSuccess(!token ? texts_js_1.TXT_TOKEN_REMOVED : texts_js_1.TXT_TOKEN_SAVED);
+});
+exports.default = commandConfigSetToken;

package/distTs/src/command/config/set/whitelist.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cfg_js_1 = __importDefault(require("../../../cfg.js"));
+const output_js_1 = __importDefault(require("../../../output.js"));
+const input_js_1 = __importDefault(require("../../../input.js"));
+const texts_js_1 = require("../../../texts.js");
+const utils_1 = require("../../../utils");
+const commandConfigSetWhitelist = (0, utils_1.newCommand)('whitelist', texts_js_1.DESC_COMMAND_CONFIG_SET_WHITELIST);
+commandConfigSetWhitelist.argument('[cidrs...]', texts_js_1.OPTION_WHITELIST, []);
+commandConfigSetWhitelist.action((whitelist) => {
+    cfg_js_1.default.setWhitelist(input_js_1.default.whitelist(whitelist));
+    output_js_1.default.exitSuccess(texts_js_1.TXT_WHITELIST_SAVED);
+});
+exports.default = commandConfigSetWhitelist;

package/distTs/src/command/config/set.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const token_js_1 = __importDefault(require("./set/token.js"));
+const region_js_1 = __importDefault(require("./set/region.js"));
+const whitelist_js_1 = __importDefault(require("./set/whitelist.js"));
+const timeout_js_1 = __importDefault(require("./set/timeout.js"));
+const texts_js_1 = require("../../texts.js");
+const utils_1 = require("../../utils");
+const commandConfigSet = (0, utils_1.newCommand)('set', texts_js_1.DESC_COMMAND_CONFIG_SET);
+commandConfigSet.addCommand(token_js_1.default);
+commandConfigSet.addCommand(region_js_1.default);
+commandConfigSet.addCommand(whitelist_js_1.default);
+commandConfigSet.addCommand(timeout_js_1.default);
+exports.default = commandConfigSet;

package/distTs/src/command/config.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const set_js_1 = __importDefault(require("./config/set.js"));
+const get_js_1 = __importDefault(require("./config/get.js"));
+const add_js_1 = __importDefault(require("./config/add.js"));
+const remove_js_1 = __importDefault(require("./config/remove.js"));
+const texts_js_1 = require("../texts.js");
+const utils_1 = require("../utils");
+const commandConfig = (0, utils_1.newCommand)('config', texts_js_1.DESC_COMMAND_CONFIG);
+commandConfig.addCommand(set_js_1.default);
+commandConfig.addCommand(add_js_1.default);
+commandConfig.addCommand(get_js_1.default);
+commandConfig.addCommand(remove_js_1.default);
+exports.default = commandConfig;

package/distTs/src/command/http.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = require("../utils.js");
+const cfg_js_1 = __importDefault(require("../cfg.js"));
+const output_js_1 = __importDefault(require("../output.js"));
+const texts_js_1 = require("../texts.js");
+const buddy_js_1 = __importDefault(require("../api/buddy.js"));
+const commandHttp = (0, utils_js_1.getBasicCommandHttp)();
+commandHttp.description(texts_js_1.DESC_COMMAND_HTTP);
+commandHttp.option('-s, --serve <directory>', texts_js_1.OPTION_SERVE);
+commandHttp.option('--token <token>', texts_js_1.OPTION_TOKEN);
+commandHttp.argument('[protocol://host:port]', texts_js_1.OPTION_TARGET);
+commandHttp.action(async (target, options) => {
+    if (options.token)
+        cfg_js_1.default.setToken(options.token);
+    const prepared = await cfg_js_1.default.prepareTunnel(utils_js_1.TUNNEL_HTTP, target, options, true);
+    await output_js_1.default.spinner(texts_js_1.TXT_OPENING_TUNNEL);
+    const agent = await buddy_js_1.default.register(false, cfg_js_1.default.getTokenHost(), cfg_js_1.default.getToken(), (region) => {
+        cfg_js_1.default.setRegionIfNotSet(region);
+    });
+    await agent.start();
+    agent.startRefreshingConfiguration();
+    const tunnel = await buddy_js_1.default.addTunnel(agent.id, agent.host, agent.token, prepared);
+    agent.addTunnel(tunnel);
+    output_js_1.default.tunnel(tunnel);
+});
+exports.default = commandHttp;

package/distTs/src/command/pre.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = require("../utils.js");
+const output_js_1 = __importDefault(require("../output.js"));
+const manager_js_1 = __importDefault(require("../agent/manager.js"));
+const agent_js_1 = __importDefault(require("../api/agent.js"));
+const commandPre = async (_, command) => {
+    command.agentStatus = null;
+    try {
+        if (!(0, utils_js_1.isDocker)()) {
+            const isEnabled = await manager_js_1.default.system.isEnabled();
+            if (isEnabled) {
+                const json = manager_js_1.default.system.loadSystemConfig();
+                const api = new agent_js_1.default(json.port);
+                command.agentStatus = await api.fetchStatus();
+            }
+        }
+    }
+    catch {
+        // do nothing
+    }
+    command.currentVersion = (0, utils_js_1.getVersion)();
+    try {
+        command.latestVersion = await (0, utils_js_1.getLatestVersion)();
+    }
+    catch {
+        // do nothing
+        return;
+    }
+    if (command.hideVersionUpdate) {
+        return;
+    }
+    const newCli = command.currentVersion !== command.latestVersion;
+    const newAgent = command.agentStatus &&
+        command.agentStatus.version !== command.latestVersion;
+    if ((0, utils_js_1.isDocker)() && newCli) {
+        output_js_1.default.newCliDockerVersion(command.latestVersion);
+    }
+    else if (newCli) {
+        output_js_1.default.newCliVersion(command.latestVersion);
+    }
+    else if (newAgent) {
+        output_js_1.default.newAgentVersion(command.latestVersion);
+    }
+};
+exports.default = commandPre;

package/distTs/src/command/start.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cfg_js_1 = __importDefault(require("../cfg.js"));
+const output_js_1 = __importDefault(require("../output.js"));
+const texts_js_1 = require("../texts.js");
+const buddy_js_1 = __importDefault(require("../api/buddy.js"));
+const utils_1 = require("../utils");
+const commandStart = (0, utils_1.newCommand)('start', texts_js_1.DESC_COMMAND_START);
+commandStart.argument('<name>', texts_js_1.OPTION_NAME);
+commandStart.action(async (name) => {
+    if (!cfg_js_1.default.hasTunnel(name)) {
+        output_js_1.default.exitError((0, texts_js_1.ERR_TUNNEL_NOT_FOUND)(name));
+    }
+    const prepared = cfg_js_1.default.getTunnel(name);
+    await output_js_1.default.spinner(texts_js_1.TXT_OPENING_TUNNEL);
+    const agent = await buddy_js_1.default.register(false, cfg_js_1.default.getTokenHost(), cfg_js_1.default.getToken(), (region) => {
+        cfg_js_1.default.setRegionIfNotSet(region);
+    });
+    await agent.start();
+    agent.startRefreshingConfiguration();
+    const tunnel = await buddy_js_1.default.addTunnel(agent.id, agent.host, agent.token, prepared);
+    agent.addTunnel(tunnel);
+    output_js_1.default.tunnel(tunnel);
+});
+exports.default = commandStart;

package/distTs/src/command/tcp.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = require("../utils.js");
+const cfg_js_1 = __importDefault(require("../cfg.js"));
+const output_js_1 = __importDefault(require("../output.js"));
+const texts_js_1 = require("../texts.js");
+const utils_1 = require("../utils");
+const buddy_js_1 = __importDefault(require("../api/buddy.js"));
+const commandTcp = (0, utils_1.getBasicCommandTcp)();
+commandTcp.description(texts_js_1.DESC_COMMAND_TCP);
+commandTcp.option('--token <token>', texts_js_1.OPTION_TOKEN);
+commandTcp.argument('[host:port]', texts_js_1.OPTION_TARGET);
+commandTcp.action(async (target, options) => {
+    if (options.token)
+        cfg_js_1.default.setToken(options.token);
+    const prepared = await cfg_js_1.default.prepareTunnel(utils_js_1.TUNNEL_TCP, target, options, true);
+    await output_js_1.default.spinner(texts_js_1.TXT_OPENING_TUNNEL);
+    const agent = await buddy_js_1.default.register(false, cfg_js_1.default.getTokenHost(), cfg_js_1.default.getToken(), (region) => {
+        cfg_js_1.default.setRegionIfNotSet(region);
+    });
+    await agent.start();
+    agent.startRefreshingConfiguration();
+    const tunnel = await buddy_js_1.default.addTunnel(agent.id, agent.host, agent.token, prepared);
+    agent.addTunnel(tunnel);
+    output_js_1.default.tunnel(tunnel);
+});
+exports.default = commandTcp;

package/distTs/src/command/tls.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = require("../utils.js");
+const cfg_js_1 = __importDefault(require("../cfg.js"));
+const output_js_1 = __importDefault(require("../output.js"));
+const texts_js_1 = require("../texts.js");
+const utils_1 = require("../utils");
+const buddy_js_1 = __importDefault(require("../api/buddy.js"));
+const commandTls = (0, utils_1.getBasicCommandTls)();
+commandTls.description(texts_js_1.DESC_COMMAND_TLS);
+commandTls.option('--token <token>', texts_js_1.OPTION_TOKEN);
+commandTls.argument('[host:port]', texts_js_1.OPTION_TARGET);
+commandTls.action(async (target, options) => {
+    if (options.token)
+        cfg_js_1.default.setToken(options.token);
+    const prepared = await cfg_js_1.default.prepareTunnel(utils_js_1.TUNNEL_TLS, target, options, true);
+    await output_js_1.default.spinner(texts_js_1.TXT_OPENING_TUNNEL);
+    const agent = await buddy_js_1.default.register(false, cfg_js_1.default.getTokenHost(), cfg_js_1.default.getToken(), (region) => {
+        cfg_js_1.default.setRegionIfNotSet(region);
+    });
+    await agent.start();
+    agent.startRefreshingConfiguration();
+    const tunnel = await buddy_js_1.default.addTunnel(agent.id, agent.host, agent.token, prepared);
+    agent.addTunnel(tunnel);
+    output_js_1.default.tunnel(tunnel);
+});
+exports.default = commandTls;

package/distTs/src/command/version.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = require("../utils.js");
+const output_js_1 = __importDefault(require("../output.js"));
+const utils_1 = require("../utils");
+const commandVersion = (0, utils_1.newCommand)('version');
+commandVersion.action(() => {
+    output_js_1.default.exitNormal((0, utils_js_1.getVersion)());
+});
+exports.default = commandVersion;

package/distTs/src/command/vt/close.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const texts_js_1 = require("../../texts.js");
+const validation_1 = require("../../visualTest/validation");
+const requests_1 = require("../../visualTest/requests");
+const output_1 = __importDefault(require("../../output"));
+const commandVtClose = (0, utils_1.newCommand)('close', texts_js_1.DESC_COMMAND_VT_CLOSE);
+commandVtClose.action(async () => {
+    if (!(0, validation_1.checkToken)()) {
+        output_1.default.exitError(texts_js_1.ERR_MISSING_TOKEN);
+    }
+    if (!(0, validation_1.checkBuildId)()) {
+        output_1.default.exitError(texts_js_1.ERR_MISSING_BUILD_ID);
+    }
+    try {
+        const response = await (0, requests_1.closeSession)();
+        // todo: add types of response
+        output_1.default.exitNormal(response);
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+});
+exports.default = commandVtClose;

package/distTs/src/command/vt/exec.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const texts_js_1 = require("../../texts.js");
+const validation_1 = require("../../visualTest/validation");
+const requests_1 = require("../../visualTest/requests");
+const output_1 = __importDefault(require("../../output"));
+const context_1 = require("../../visualTest/context");
+const server_1 = require("../../visualTest/server");
+const which_1 = __importDefault(require("which"));
+const snapshots_1 = require("../../visualTest/snapshots");
+const ci_1 = require("../../visualTest/ci");
+const exec_1 = require("../../visualTest/exec");
+const browser_1 = require("../../visualTest/browser");
+const commandVtExec = (0, utils_1.newCommand)('exec', texts_js_1.DESC_COMMAND_VT_EXEC);
+commandVtExec.argument('<command>', texts_js_1.OPTION_EXEC_COMMAND);
+commandVtExec.option('--skipDiscovery', texts_js_1.OPTION_EXEC_SKIP_DISCOVERY);
+commandVtExec.option('--oneByOne', texts_js_1.OPTION_EXEC_ONE_BY_ONE);
+commandVtExec.option('--parallel', texts_js_1.OPTION_EXEC_PARALLEL);
+commandVtExec.action(async (command, options) => {
+    output_1.default.normal(JSON.stringify({ command, options }));
+    (0, context_1.setOptions)(options);
+    try {
+        const browserPath = await (0, browser_1.getBrowserPath)();
+        (0, context_1.setBrowserPath)(browserPath);
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+    if (!(0, validation_1.checkToken)()) {
+        output_1.default.exitError(texts_js_1.ERR_MISSING_TOKEN);
+    }
+    if (!(0, validation_1.checkParallel)()) {
+        output_1.default.exitError(texts_js_1.ERR_MISSING_BUILD_ID);
+    }
+    const app = await (0, server_1.createServer)();
+    const [mainCommand, ...mainCommandArguments] = command.split(' ');
+    output_1.default.normal((0, texts_js_1.LOG_RUNNING_EXEC_COMMAND)(`${mainCommand} ${[...mainCommandArguments].join(' ')}`));
+    const resolved = await (0, which_1.default)(mainCommand, { nothrow: true });
+    if (!resolved) {
+        output_1.default.exitError((0, texts_js_1.ERR_MISSING_EXEC_COMMAND)(`${mainCommand} ${[...mainCommandArguments].join(' ')}`));
+    }
+    try {
+        let t1, t11;
+        if (context_1.debug) {
+            t1 = performance.now();
+        }
+        const defaultSettings = await (0, requests_1.getDefaultSettings)();
+        (0, snapshots_1.setDefaultSettings)(defaultSettings);
+        const ciAndGitInfo = await (0, ci_1.getCiAndGitInfo)(defaultSettings.baseBranch);
+        (0, context_1.setCiAndCommitInfo)(ciAndGitInfo);
+        (0, ci_1.logCiInfo)(ciAndGitInfo);
+        if (context_1.debug) {
+            t11 = performance.now();
+        }
+        const spawnedProcessExitCode = await (0, exec_1.testExec)(mainCommand, [
+            ...mainCommandArguments,
+        ]);
+        if (context_1.debug && t11) {
+            const t22 = performance.now();
+            output_1.default.normal((0, texts_js_1.DEBUG_EXEC_TEST_COMMAND)(t22 - t11));
+        }
+        await app.close();
+        await (0, snapshots_1.finishProcessingSnapshots)(spawnedProcessExitCode);
+        if (context_1.debug && t1) {
+            const t2 = performance.now();
+            output_1.default.normal((0, texts_js_1.DEBUG_EXEC_COMMAND)(t2 - t1));
+        }
+        process.exit(spawnedProcessExitCode);
+    }
+    catch (error) {
+        await app.close();
+        output_1.default.exitError(`${error}`);
+    }
+});
+exports.default = commandVtExec;

package/distTs/src/command/vt/storybook.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const texts_js_1 = require("../../texts.js");
+const validation_1 = require("../../visualTest/validation");
+const requests_1 = require("../../visualTest/requests");
+const output_1 = __importDefault(require("../../output"));
+const snapshots_1 = require("../../visualTest/snapshots");
+const ci_1 = require("../../visualTest/ci");
+const context_1 = require("../../visualTest/context");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const commandVtStorybook = (0, utils_1.newCommand)('storybook', texts_js_1.DESC_COMMAND_VT_STORYBOOK);
+commandVtStorybook.action(async () => {
+    if (!(0, validation_1.checkToken)()) {
+        output_1.default.exitError(texts_js_1.ERR_MISSING_TOKEN);
+    }
+    const currentDirectoryFiles = getCurrentDirectoryFiles();
+    if (!isStorybookDirectory(currentDirectoryFiles)) {
+        output_1.default.exitError(texts_js_1.ERR_WRONG_STORYBOOK_DIRECTORY);
+    }
+    const storybookStoriesIndex = getStorybookStoriesIndex(currentDirectoryFiles);
+    const storiesList = getStoriesList(storybookStoriesIndex);
+    const storybookSnapshots = getStorybookSnapshots(storiesList);
+    const defaultSettings = await (0, requests_1.getDefaultSettings)();
+    (0, snapshots_1.setDefaultSettings)(defaultSettings);
+    const ciAndGitInfo = await (0, ci_1.getCiAndGitInfo)(defaultSettings.baseBranch);
+    (0, context_1.setCiAndCommitInfo)(ciAndGitInfo);
+    (0, ci_1.logCiInfo)(ciAndGitInfo);
+    try {
+        const response = await (0, requests_1.sendStorybook)(storybookSnapshots, currentDirectoryFiles);
+        output_1.default.exitSuccess(response);
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+});
+function getCurrentDirectoryFiles() {
+    const cwd = process.cwd();
+    const filesAndDirectories = (0, node_fs_1.readdirSync)(cwd, {
+        encoding: 'utf8',
+        recursive: true,
+    });
+    return filesAndDirectories.filter((file) => {
+        const elementPath = node_path_1.default.join(cwd, file);
+        const stats = (0, node_fs_1.statSync)(elementPath);
+        return stats.isFile();
+    });
+}
+function isStorybookDirectory(files) {
+    return (files.length > 0 &&
+        files.includes('index.html') &&
+        files.includes('iframe.html'));
+}
+function getStorybookStoriesIndex(files) {
+    const indexFiles = files.find((file) => file === 'index.json');
+    if (indexFiles) {
+        return indexFiles;
+    }
+    else {
+        return output_1.default.exitError(texts_js_1.ERR_MISSING_STORYBOOK_INDEX_FILE);
+    }
+}
+function getStoriesList(storybookStoriesIndex) {
+    const storiesListFile = (0, node_fs_1.readFileSync)(storybookStoriesIndex);
+    try {
+        const json = JSON.parse(storiesListFile.toString());
+        if (![4, 5].includes(json.v)) {
+            output_1.default.exitError(texts_js_1.ERR_UNSUPPORTED_STORYBOOK);
+        }
+        return json;
+    }
+    catch {
+        output_1.default.exitError(texts_js_1.ERR_PARSING_STORIES);
+    }
+}
+function getStorybookSnapshots(storiesList) {
+    const stories = Object.entries(storiesList.entries)
+        .filter(([, value]) => value.type === 'story')
+        .map(([key, value]) => ({
+        id: key,
+        name: `${value.title}/${value.name}`,
+    }));
+    output_1.default.normal((0, texts_js_1.TXT_STORIES_AMOUNT)(stories.length));
+    return stories;
+}
+exports.default = commandVtStorybook;

package/distTs/src/command/vt.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const texts_js_1 = require("../texts.js");
+const utils_1 = require("../utils");
+const close_1 = __importDefault(require("./vt/close"));
+const storybook_1 = __importDefault(require("./vt/storybook"));
+const exec_1 = __importDefault(require("./vt/exec"));
+const commandVt = (0, utils_1.newCommand)('vt', texts_js_1.DESC_COMMAND_VT);
+commandVt.addCommand(close_1.default);
+commandVt.addCommand(storybook_1.default);
+commandVt.addCommand(exec_1.default);
+exports.default = commandVt;

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;