bdy 1.12.12-dev-pipeline-run → 1.13.0-beta

package/distTs/src/api/socket.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const https_1 = require("https");
+const events_1 = __importDefault(require("events"));
+const logger_js_1 = __importDefault(require("../logger.js"));
+const texts_1 = require("../texts");
+const utils_1 = require("../utils");
+const socket_io_client_1 = require("socket.io-client");
+const MAX_REQUESTS_SYNC_WINDOW = 30000;
+const MAX_REQUESTS_SYNC_IN_WINDOW = 100;
+class ApiSocketClass extends events_1.default {
+    fetch(activate = true, action = null, disabled = null, resetFirstHeard = false, tunnels) {
+        this.socket.emit('fetchTunnelAgent', {
+            id: this.id,
+            token: this.token,
+            hostname: this.hostname,
+            platform: this.platform,
+            version: this.version,
+            activate,
+            action,
+            disabled,
+            resetFirstHeard,
+            tunnels,
+        });
+    }
+    update(activate, tunnels, force = false) {
+        const now = Date.now();
+        // nie robimy update jak byl mniej niz 5s temu
+        if (!force && this.lastUpdate && now - this.lastUpdate < 5000)
+            return;
+        this.lastUpdate = now;
+        this.socket.emit('updateTunnelAgent', {
+            id: this.id,
+            token: this.token,
+            hostname: this.hostname,
+            platform: this.platform,
+            version: this.version,
+            activate,
+            tunnels,
+        });
+    }
+    emitRequest(tunnelId, logRequest) {
+        this.socket.emit('tunnelRequest', {
+            id: this.id,
+            token: this.token,
+            tunnelId,
+            request: logRequest.toSocket(),
+        });
+    }
+    request(tunnelId, logRequest) {
+        if (this.tunnelRequests > MAX_REQUESTS_SYNC_IN_WINDOW)
+            return;
+        this.tunnelRequests += 1;
+        logRequest.once(utils_1.EVENT_TUNNEL_HTTP_NEW_RESPONSE_END, () => {
+            this.emitRequest(tunnelId, logRequest);
+        });
+        this.emitRequest(tunnelId, logRequest);
+    }
+    onSyncAgent(data, action) {
+        this.emit(utils_1.SOCKET_IO_EVENT_AGENT, data, action);
+    }
+    onSyncTunnel(data, action) {
+        this.emit(utils_1.SOCKET_IO_EVENT_TUNNEL, data, action);
+    }
+    onSync(data) {
+        try {
+            const json = JSON.parse(data);
+            if (json.payloadType === 'TunnelAgentFront')
+                this.onSyncAgent(json.payload, json.action);
+            else if (json.payloadType === 'TunnelFront')
+                this.onSyncTunnel(json.payload, json.action);
+        }
+        catch {
+            // do nothing
+        }
+    }
+    connect(atOnce) {
+        logger_js_1.default.debug('socket connect');
+        if (atOnce && this.socket && !this.socket.connected) {
+            this.socket.connect();
+        }
+        else {
+            setTimeout(() => {
+                if (this.socket && !this.socket.connected)
+                    this.socket.connect();
+            }, 3000);
+        }
+    }
+    destroy() {
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.disconnect();
+            this.socket = null;
+        }
+    }
+    constructor(host, id, token) {
+        super();
+        this.id = id;
+        this.token = token;
+        this.connected = false;
+        this.hostname = (0, utils_1.getHostname)();
+        this.platform = (0, utils_1.getPlatform)();
+        this.version = (0, utils_1.getVersion)();
+        this.lastUpdate = null;
+        this.tunnelRequests = 0;
+        setInterval(() => {
+            this.tunnelRequests = 0;
+        }, MAX_REQUESTS_SYNC_WINDOW);
+        this.socket = (0, socket_io_client_1.io)(host, {
+            forceNew: true,
+            autoConnect: false,
+            autoUnref: true,
+            forceBase64: true,
+            transports: ['websocket'],
+            reconnection: false,
+            rejectUnauthorized: false,
+            agent: new https_1.Agent({
+                rejectUnauthorized: false,
+            }),
+            maxHttpBufferSize: 3e6,
+            extraHeaders: {
+                cookie: 'a=b',
+            },
+        });
+        this.socket.on('connect', () => {
+            this.connected = true;
+            logger_js_1.default.info(texts_1.LOG_SOCKET_CONNECTED);
+            this.emit(utils_1.SOCKET_IO_EVENT_CONNECTED);
+            this.socket.emit('joinTunnelAgent', {
+                id: this.id,
+                token: this.token,
+            });
+        });
+        this.socket.on('disconnect', () => {
+            this.connected = false;
+            logger_js_1.default.info(texts_1.LOG_SOCKET_DISCONNECTED);
+            this.emit(utils_1.SOCKET_IO_EVENT_DISCONNECTED);
+            this.connect();
+        });
+        this.socket.on('connect_error', () => {
+            logger_js_1.default.debug('socket error');
+            this.connect();
+        });
+        this.socket.on('fetchTunnelAgentSuccess', (data) => {
+            logger_js_1.default.debug('Socket fetch success');
+            this.emit(utils_1.SOCKET_IO_EVENT_FETCH_SUCCESS, data);
+        });
+        this.socket.on('fetchTunnelAgentFailed', (code) => {
+            logger_js_1.default.debug('Socket fetch failed');
+            this.emit(utils_1.SOCKET_IO_EVENT_FETCH_FAILED, (0, utils_1.apiErrorCodeToClass)(code, host));
+        });
+        this.socket.on('sync', (data) => this.onSync(data));
+        this.connect(true);
+    }
+}
+exports.default = ApiSocketClass;

package/distTs/src/cfg.js

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

package/distTs/src/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, 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/pipeline/run.js

@@ -24,12 +24,12 @@ commandPipelineRun.option('-f, --refresh', texts_1.OPTION_PIPELINE_RUN_REFRESH);
 commandPipelineRun.option('-c, --clear-cache', texts_1.OPTION_PIPELINE_RUN_CLEAR_CACHE);
 commandPipelineRun.option('--priority <priority>', texts_1.OPTION_PIPELINE_RUN_PRIORITY);
 commandPipelineRun.option('-v, --variable <variables...>', texts_1.OPTION_PIPELINE_RUN_VAR);
-commandPipelineRun.option('-ve, --variable-encrypted <variables...>', texts_1.OPTION_PIPELINE_RUN_VAR);
+commandPipelineRun.option('-vm, --variable-masked <variables...>', texts_1.OPTION_PIPELINE_RUN_VAR);
 commandPipelineRun.option('--schedule <date>', texts_1.OPTION_PIPELINE_RUN_DELAY);
 commandPipelineRun.option('--action <actions...>', texts_1.OPTION_PIPELINE_RUN_ACTION);
-commandPipelineRun.option('--wait', texts_1.OPTION_PIPELINE_RUN_WAIT);
-commandPipelineRun.option('--wait-time <minutes>', texts_1.OPTION_PIPELINE_RUN_WAIT_TIMEOUT);
+commandPipelineRun.option('--wait [minutes]', texts_1.OPTION_PIPELINE_RUN_WAIT);
 commandPipelineRun.argument('<identifier>', texts_1.OPTION_PIPELINE_RUN_ARGUMENT);
+commandPipelineRun.usage('<identifier> [options]');
 commandPipelineRun.action(async (identifier, options) => {
     const token = input_1.default.restApiToken(options.token);
     const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
@@ -84,8 +84,8 @@ commandPipelineRun.action(async (identifier, options) => {
     if (options.variable) {
         body.variables = body.variables.concat(input_1.default.pipelineRunVariable(options.variable, false));
     }
-    if (options.variableEncrypted) {
-        body.variables = body.variables.concat(input_1.default.pipelineRunVariable(options.variableEncrypted, true));
+    if (options.variableMasked) {
+        body.variables = body.variables.concat(input_1.default.pipelineRunVariable(options.variableMasked, true));
     }
     const delay = input_1.default.pipelineRunDelay(options.schedule);
     if (delay) {
@@ -97,38 +97,41 @@ commandPipelineRun.action(async (identifier, options) => {
     }
     const result = await client.postPipelineRun(workspace, project, data.pipeline_id, body);
     if (options.wait) {
-        const minutes = input_1.default.pipelineRunWaitTime(options.waitTime);
-        const start = Date.now();
-        output_1.default.normal((0, texts_1.TXT_PIPELINE_RUN_WAIT)(minutes));
-        let fetchCounter = 1;
-        const ts1 = setTimeout(() => {
-            output_1.default.exitError(texts_1.ERR_RUN_PIPELINE_WAIT_TIMEOUT);
-        }, minutes * 60 * 1000);
-        const ts2 = setInterval(async () => {
-            output_1.default.clearPreviousLine();
-            output_1.default.normal((0, texts_1.TXT_PIPELINE_RUN_STILL_WAITING)(formatWaitTime(start)));
-            if (fetchCounter >= 3) {
-                const pip = await client.getPipelineRun(workspace, project, data.pipeline_id, result.id);
-                if (!['INPROGRESS', 'ENQUEUED', 'TERMINATING'].includes(pip.status)) {
-                    clearTimeout(ts1);
-                    clearInterval(ts2);
-                    output_1.default.clearPreviousLine();
-                    if (pip.status === 'SUCCESSFUL') {
-                        output_1.default.exitSuccess((0, texts_1.TXT_PIPELINE_RUN_FINISH_SUCCESSFULLY)(result.html_url));
-                    }
-                    else {
-                        output_1.default.exitError((0, texts_1.TXT_PIPELINE_RUN_FINISH_FAILED)(pip.status, result.html_url));
-                    }
-                }
-                fetchCounter = 0;
-            }
-            fetchCounter += 1;
-        }, 1000);
+        const minutes = input_1.default.pipelineRunWaitTime(options.wait);
+        wait(minutes, workspace, project, data.pipeline_id, result.id, result.html_url, client);
     }
     else {
         output_1.default.exitSuccess((0, texts_1.TXT_PIPELINE_RUN_SUCCESS)(result.html_url));
     }
 });
+const wait = (minutes, workspace, project, pipelineId, runId, htmlUrl, client) => {
+    const start = Date.now();
+    output_1.default.normal((0, texts_1.TXT_PIPELINE_RUN_WAIT)(minutes));
+    let fetchCounter = 1;
+    const ts1 = setTimeout(() => {
+        output_1.default.exitError(texts_1.ERR_RUN_PIPELINE_WAIT_TIMEOUT);
+    }, minutes * 60 * 1000);
+    const ts2 = setInterval(async () => {
+        output_1.default.clearPreviousLine();
+        output_1.default.normal((0, texts_1.TXT_PIPELINE_RUN_STILL_WAITING)(formatWaitTime(start)));
+        if (fetchCounter >= 3) {
+            const run = await client.getPipelineRun(workspace, project, pipelineId, runId);
+            if (!['INPROGRESS', 'ENQUEUED', 'TERMINATING'].includes(run.status)) {
+                clearTimeout(ts1);
+                clearInterval(ts2);
+                output_1.default.clearPreviousLine();
+                if (run.status === 'SUCCESSFUL') {
+                    output_1.default.exitSuccess((0, texts_1.TXT_PIPELINE_RUN_FINISH_SUCCESSFULLY)(htmlUrl));
+                }
+                else {
+                    output_1.default.exitError((0, texts_1.TXT_PIPELINE_RUN_FINISH_FAILED)(run.status, htmlUrl));
+                }
+            }
+            fetchCounter = 0;
+        }
+        fetchCounter += 1;
+    }, 1000);
+};
 const formatWaitTime = (start) => {
     const elapsed = Math.floor((Date.now() - start) / 1000);
     return format_1.default.pipelineRunWaitTime(elapsed);

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, 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, 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/ut/upload.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };

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

@@ -11,8 +11,8 @@ const linkUtils_1 = require("../../visualTest/linkUtils");
 const node_fs_1 = require("node:fs");
 const requests_1 = require("../../visualTest/requests");
 const validation_2 = require("./compare/validation");
-const ci_1 = require("../../visualTest/ci");
 const context_1 = require("../../visualTest/context");
+const ci_info_1 = require("@buddy-works/ci-info");
 const commandVtCompare = (0, utils_1.newCommand)('compare', texts_1.DESC_COMMAND_VT_COMPARE);
 commandVtCompare.option('--urls <urls>', texts_1.OPTION_COMPARE_URLS);
 commandVtCompare.option('--sitemap <sitemap>', texts_1.OPTION_COMPARE_SITEMAP);
@@ -58,7 +58,7 @@ commandVtCompare.action(async (options) => {
     else if (filteredUrls.length > 1) {
         output_1.default.normal(`List of urls:\n${filteredUrls.join('\n')}`);
     }
-    const ciAndGitInfo = await (0, ci_1.getCiAndGitInfo)({});
+    const ciAndGitInfo = await (0, ci_info_1.getCiAndGitInfo)({});
     (0, context_1.setCiAndCommitInfo)(ciAndGitInfo);
     try {
         const { message } = await (0, requests_1.sendCompareLinks)(filteredUrls, validatedOptions, sitemapSource);