bdy 1.12.10-dev-pipeline-run → 1.12.10-dev

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/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);

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

@@ -12,9 +12,9 @@ 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 ci_info_1 = require("@buddy-works/ci-info");
 const commandVtExec = (0, utils_1.newCommand)('exec', texts_1.DESC_COMMAND_VT_EXEC);
 commandVtExec.argument('<command>', texts_1.OPTION_EXEC_COMMAND);
 commandVtExec.option('--skipDiscovery', texts_1.OPTION_EXEC_SKIP_DISCOVERY);
@@ -49,11 +49,12 @@ commandVtExec.action(async (command, options) => {
         }
         const defaultSettings = await (0, requests_1.getDefaultSettings)();
         (0, snapshots_1.setDefaultSettings)(defaultSettings);
-        const ciAndGitInfo = await (0, ci_1.getCiAndGitInfo)({
+        const ciAndGitInfo = await (0, ci_info_1.getCiAndGitInfo)({
             baseBranch: defaultSettings.baseBranch,
+            logger: output_1.default.warning,
         });
         (0, context_1.setCiAndCommitInfo)(ciAndGitInfo);
-        (0, ci_1.logCiInfo)(ciAndGitInfo);
+        output_1.default.normal((0, ci_info_1.formattedCiInfo)(ciAndGitInfo));
         if (context_1.debug) {
             t11 = performance.now();
         }

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

@@ -9,10 +9,10 @@ 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 ci_info_1 = require("@buddy-works/ci-info");
 const commandVtStorybook = (0, utils_1.newCommand)('storybook', texts_1.DESC_COMMAND_VT_STORYBOOK);
 commandVtStorybook.action(async () => {
     if (!(0, validation_1.checkToken)()) {
@@ -27,11 +27,12 @@ commandVtStorybook.action(async () => {
     const storybookSnapshots = getStorybookSnapshots(storiesList);
     const defaultSettings = await (0, requests_1.getDefaultSettings)();
     (0, snapshots_1.setDefaultSettings)(defaultSettings);
-    const ciAndGitInfo = await (0, ci_1.getCiAndGitInfo)({
+    const ciAndGitInfo = await (0, ci_info_1.getCiAndGitInfo)({
         baseBranch: defaultSettings.baseBranch,
+        logger: output_1.default.warning,
     });
     (0, context_1.setCiAndCommitInfo)(ciAndGitInfo);
-    (0, ci_1.logCiInfo)(ciAndGitInfo);
+    output_1.default.normal((0, ci_info_1.formattedCiInfo)(ciAndGitInfo));
     try {
         const { message } = await (0, requests_1.sendStorybook)(storybookSnapshots, currentDirectoryFiles);
         output_1.default.exitSuccess(message);

package/distTs/src/format.js

@@ -128,25 +128,6 @@ class Format {
             entry += ':443';
         return entry;
     }
-    static pipelineRunWaitTime(elapsedSeconds) {
-        const hours = Math.floor(elapsedSeconds / 60 / 60);
-        const minutes = Math.floor(elapsedSeconds / 60) - hours * 60;
-        const seconds = elapsedSeconds - hours * 60 * 60 - minutes * 60;
-        const hoursF = `${hours}h`;
-        let minutesF = '';
-        if (minutes < 10)
-            minutesF += '0';
-        minutesF += `${minutes}m`;
-        let secondsF = '';
-        if (seconds < 10)
-            secondsF += '0';
-        secondsF += `${seconds}s`;
-        if (hours > 0)
-            return `${hoursF}${minutesF}${secondsF}`;
-        if (minutes > 0)
-            return `${minutesF}${secondsF}`;
-        return secondsF;
-    }
     static target(type, target) {
         if (type === tunnel_1.TUNNEL_TYPE.HTTP) {
             let port = '80';

package/distTs/src/index.js

@@ -14,7 +14,6 @@ const texts_1 = require("./texts");
 const vt_1 = __importDefault(require("./command/vt"));
 const ut_1 = __importDefault(require("./command/ut"));
 const tunnel_1 = __importDefault(require("./command/tunnel"));
-const pipeline_1 = __importDefault(require("./command/pipeline"));
 stream_1.default.setDefaultHighWaterMark(false, 67108864);
 process.title = 'bdy';
 process.on('uncaughtException', (err) => {
@@ -32,5 +31,4 @@ if (!(0, utils_1.isDocker)())
 program.addCommand(version_1.default);
 program.addCommand(vt_1.default);
 program.addCommand(ut_1.default);
-program.addCommand(pipeline_1.default);
 program.parse();