bdy 1.8.3-dev → 1.8.4-dev

package/distTs/src/api/socket.js

@@ -0,0 +1,133 @@
+"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, resetFirstHeard = false, tunnels) {
+        this.socket.emit('fetchTunnelAgent', {
+            id: this.id,
+            token: this.token,
+            hostname: this.hostname,
+            platform: this.platform,
+            version: this.version,
+            activate,
+            action,
+            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
+        }
+    }
+    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: true,
+            autoUnref: true,
+            forceBase64: true,
+            transports: ['websocket'],
+            reconnection: true,
+            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.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));
+    }
+}
+exports.default = ApiSocketClass;

package/distTs/src/cfg.js

@@ -0,0 +1,238 @@
+"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 (options.domain !== undefined)
+            tunnel.domain = input_js_1.default.domain(options.domain);
+        if (options.subdomain !== undefined)
+            tunnel.subdomain = input_js_1.default.subdomain(options.subdomain);
+        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/agent/install.js

@@ -0,0 +1,106 @@
+"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 input_js_1 = __importDefault(require("../../input.js"));
+const texts_js_1 = require("../../texts.js");
+const cfg_js_1 = __importDefault(require("../../cfg.js"));
+const manager_js_1 = __importDefault(require("../../agent/manager.js"));
+const buddy_js_1 = __importDefault(require("../../api/buddy.js"));
+const agent_1 = __importDefault(require("../../api/agent"));
+const wait_js_1 = __importDefault(require("../../agent/wait.js"));
+const utils_1 = require("../../utils");
+const removeAllAndExit = async (txt, id, host, token) => {
+    try {
+        await manager_js_1.default.system.disable();
+    }
+    catch {
+        // do nothing
+    }
+    try {
+        await buddy_js_1.default.unregister(id, host, token);
+    }
+    catch {
+        // do nothing
+    }
+    try {
+        manager_js_1.default.system.clearSystemFiles();
+    }
+    catch {
+        // do nothing
+    }
+    output_js_1.default.exitError(txt);
+};
+const commandAgentInstall = (0, utils_1.newCommand)('install', texts_js_1.DESC_COMMAND_AGENT_INSTALL);
+commandAgentInstall.option('-s, --start', texts_js_1.OPTION_AGENT_START);
+commandAgentInstall.option('-i, --id <id>', texts_js_1.OPTION_AGENT_ID);
+commandAgentInstall.option('-t, --token <token>', texts_js_1.OPTION_AGENT_TOKEN);
+commandAgentInstall.option('-p, --port <port>', texts_js_1.OPTION_AGENT_PORT, '7456');
+commandAgentInstall.option('-u, --user <user>', texts_js_1.OPTION_USER);
+commandAgentInstall.option('--pass <password>', texts_js_1.OPTION_PASS);
+commandAgentInstall.option('-d, --debug', texts_js_1.OPTION_AGENT_DEBUG);
+commandAgentInstall.action(async (options) => {
+    const hasAdminRights = await manager_js_1.default.system.hasAdminRights();
+    if (!hasAdminRights) {
+        output_js_1.default.exitError(texts_js_1.ERR_AGENT_ADMIN_RIGHTS);
+    }
+    const isSupported = await manager_js_1.default.system.isSupported();
+    if (!isSupported) {
+        output_js_1.default.exitError(texts_js_1.ERR_AGENT_NOT_SUPPORTED);
+    }
+    const isEnabled = await manager_js_1.default.system.isEnabled();
+    if (isEnabled) {
+        output_js_1.default.exitSuccess(texts_js_1.TXT_AGENT_ALREADY_ENABLED);
+    }
+    let id;
+    let token;
+    let agent;
+    let port = input_js_1.default.port(options.port);
+    if (options.id && options.token) {
+        // if id & token passed set as it is
+        id = options.id;
+        token = options.token;
+        try {
+            agent = await buddy_js_1.default.fetchAgent(id, cfg_js_1.default.getTokenHost(), token);
+        }
+        catch {
+            output_js_1.default.exitError(texts_js_1.ERR_AGENT_NOT_FOUND);
+        }
+    }
+    else if (options.token) {
+        // set global token if passed
+        cfg_js_1.default.setToken(options.token);
+    }
+    let host = cfg_js_1.default.getTokenHost();
+    if (!agent) {
+        agent = await buddy_js_1.default.register(true, host, cfg_js_1.default.getToken(), (region) => {
+            cfg_js_1.default.setRegionIfNotSet(region);
+        });
+        id = agent.id;
+        token = agent.token;
+    }
+    const saved = manager_js_1.default.system.saveSystemConfig(id, host, token, port);
+    if (!saved) {
+        await removeAllAndExit(texts_js_1.ERR_SWW_AGENT_ENABLING, id, host, token);
+    }
+    await output_js_1.default.spinner(texts_js_1.TXT_ENABLING_AGENT);
+    if (process.env.DEBUG === '1') {
+        manager_js_1.default.start(id, host, token, port, !!options.start);
+        return;
+    }
+    try {
+        await manager_js_1.default.system.enable(id, host, token, port, !!options.start, options.user, options.pass, !!options.debug);
+    }
+    catch {
+        await removeAllAndExit(texts_js_1.ERR_SWW_AGENT_ENABLING, id, host, token);
+    }
+    const api = new agent_1.default(port);
+    await (0, wait_js_1.default)(api, 15000, () => {
+        removeAllAndExit(texts_js_1.ERR_SWW_AGENT_ENABLING, id, host, token);
+    }, () => {
+        output_js_1.default.exitSuccess(texts_js_1.TXT_AGENT_ENABLED);
+    });
+});
+exports.default = commandAgentInstall;

package/distTs/src/command/agent/restart.js

@@ -0,0 +1,27 @@
+"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 texts_js_1 = require("../../texts.js");
+const agent_js_1 = __importDefault(require("../../api/agent.js"));
+const manager_1 = __importDefault(require("../../agent/manager"));
+const utils_1 = require("../../utils");
+const commandAgentRestart = (0, utils_1.newCommand)('restart', texts_js_1.DESC_COMMAND_AGENT_RESTART);
+commandAgentRestart.action(async () => {
+    const isEnabled = await manager_1.default.system.isEnabled();
+    if (!isEnabled) {
+        output_js_1.default.exitError(texts_js_1.ERR_AGENT_NOT_ENABLED);
+    }
+    try {
+        const json = manager_1.default.system.loadSystemConfig();
+        const api = new agent_js_1.default(json.port);
+        await api.restartAgent();
+        output_js_1.default.exitSuccess(texts_js_1.TXT_AGENT_RESTARTED);
+    }
+    catch (err) {
+        output_js_1.default.exitError(err);
+    }
+});
+exports.default = commandAgentRestart;

package/distTs/src/command/agent/run.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const manager_1 = __importDefault(require("../../agent/manager"));
+const logger_1 = __importDefault(require("../../logger"));
+const utils_1 = require("../../utils");
+const commandAgentRun = (0, utils_1.newCommand)('run');
+commandAgentRun.option('--id <id>');
+commandAgentRun.option('--host <host>');
+commandAgentRun.option('--token <token>');
+commandAgentRun.option('--port <port>');
+commandAgentRun.option('--start <start>');
+commandAgentRun.action(async (options) => {
+    logger_1.default.changeRootPath(manager_1.default.system.getAgentConfigDir());
+    manager_1.default.start(options.id, options.host, options.token, options.port, !!options.start);
+});
+module.exports = commandAgentRun;

package/distTs/src/command/agent/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 output_js_1 = __importDefault(require("../../output.js"));
+const texts_js_1 = require("../../texts.js");
+const agent_js_1 = __importDefault(require("../../api/agent.js"));
+const texts_1 = require("../../texts");
+const manager_1 = __importDefault(require("../../agent/manager"));
+const utils_1 = require("../../utils");
+const commandAgentStart = (0, utils_1.newCommand)('start', texts_js_1.DESC_COMMAND_AGENT_START);
+commandAgentStart.action(async () => {
+    const isEnabled = await manager_1.default.system.isEnabled();
+    if (!isEnabled) {
+        output_js_1.default.exitError(texts_1.ERR_AGENT_NOT_ENABLED);
+    }
+    try {
+        const json = manager_1.default.system.loadSystemConfig();
+        const api = new agent_js_1.default(json.port);
+        await api.startAgent();
+        output_js_1.default.exitSuccess(texts_js_1.TXT_AGENT_STARTED);
+    }
+    catch (err) {
+        output_js_1.default.exitError(err);
+    }
+});
+exports.default = commandAgentStart;

package/distTs/src/command/agent/status.js

@@ -0,0 +1,35 @@
+"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 texts_js_1 = require("../../texts.js");
+const utils_js_1 = require("../../utils.js");
+const manager_1 = __importDefault(require("../../agent/manager"));
+const texts_1 = require("../../texts");
+const utils_1 = require("../../utils");
+const commandAgentStatus = (0, utils_1.newCommand)('status', texts_js_1.DESC_COMMAND_AGENT_STATUS);
+commandAgentStatus.action(async () => {
+    const isEnabled = await manager_1.default.system.isEnabled();
+    if (!isEnabled) {
+        output_js_1.default.exitError(texts_js_1.ERR_AGENT_NOT_ENABLED);
+    }
+    if (!commandAgentStatus.agentStatus) {
+        output_js_1.default.exitError(texts_1.ERR_AGENT_NOT_RUNNING);
+    }
+    if (commandAgentStatus.agentStatus.status === utils_js_1.AGENT_STATUS_INITIALIZING) {
+        output_js_1.default.exitError(texts_js_1.TXT_AGENT_IS_ENABLED_AND_INITIALIZING);
+    }
+    if (commandAgentStatus.agentStatus.status === utils_js_1.AGENT_STATUS_FETCH_FAILED) {
+        output_js_1.default.exitError(texts_js_1.TXT_AGENT_IS_ENABLED_AND_HAVE_TROUBLES);
+    }
+    if (commandAgentStatus.agentStatus.status !== utils_js_1.AGENT_STATUS_ENABLED) {
+        output_js_1.default.exitError(texts_js_1.TXT_AGENT_IS_DISABLED);
+    }
+    if (commandAgentStatus.agentStatus.started) {
+        output_js_1.default.exitSuccess(texts_js_1.TXT_AGENT_IS_ENABLED_AND_STARTED);
+    }
+    output_js_1.default.exitError(texts_js_1.TXT_AGENT_IS_ENABLED_AND_STOPPED);
+});
+exports.default = commandAgentStatus;

package/distTs/src/command/agent/stop.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_1 = require("../../texts");
+const manager_1 = __importDefault(require("../../agent/manager"));
+const agent_js_1 = __importDefault(require("../../api/agent.js"));
+const texts_js_1 = require("../../texts.js");
+const output_js_1 = __importDefault(require("../../output.js"));
+const commandAgentStop = (0, utils_1.newCommand)('stop', texts_js_1.DESC_COMMAND_AGENT_STOP);
+commandAgentStop.action(async () => {
+    const isEnabled = await manager_1.default.system.isEnabled();
+    if (!isEnabled) {
+        output_js_1.default.exitError(texts_1.ERR_AGENT_NOT_ENABLED);
+    }
+    try {
+        const json = manager_1.default.system.loadSystemConfig();
+        const api = new agent_js_1.default(json.port);
+        await api.stopAgent();
+        output_js_1.default.exitSuccess(texts_js_1.TXT_AGENT_STOPPED);
+    }
+    catch (err) {
+        output_js_1.default.exitError(err);
+    }
+});
+exports.default = commandAgentStop;

package/distTs/src/command/agent/tunnel/http.js

@@ -0,0 +1,44 @@
+"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 cfg_js_1 = __importDefault(require("../../../cfg.js"));
+const texts_js_1 = require("../../../texts.js");
+const tunnel_1 = __importDefault(require("../../../agent/socket/tunnel"));
+const texts_1 = require("../../../texts");
+const manager_1 = __importDefault(require("../../../agent/manager"));
+const utils_1 = require("../../../utils");
+const agent_js_1 = __importDefault(require("../../../api/agent.js"));
+const commandAgentTunnelHttp = (0, utils_1.getBasicCommandHttp)();
+commandAgentTunnelHttp.description(texts_js_1.DESC_COMMAND_AGENT_TUNNEL_HTTP);
+commandAgentTunnelHttp.option('-f, --follow', texts_1.OPTION_FOLLOW);
+commandAgentTunnelHttp.argument('[protocol://host:port]', texts_js_1.OPTION_TARGET);
+commandAgentTunnelHttp.action(async (target, options) => {
+    const isEnabled = await manager_1.default.system.isEnabled();
+    if (!isEnabled) {
+        output_js_1.default.exitError(texts_js_1.ERR_AGENT_NOT_ENABLED);
+    }
+    const prepared = await cfg_js_1.default.prepareTunnel(utils_js_1.TUNNEL_HTTP, target, options, true);
+    try {
+        await output_js_1.default.spinner(texts_js_1.TXT_OPENING_TUNNEL);
+        const json = manager_1.default.system.loadSystemConfig();
+        const api = new agent_js_1.default(json.port);
+        const data = await api.addTunnel(prepared);
+        if (options.follow) {
+            const ws = await api.socketTunnel(data.id);
+            const tunnel = new tunnel_1.default(ws, data.id);
+            await tunnel.waitForReady();
+            output_js_1.default.tunnel(tunnel);
+        }
+        else {
+            output_js_1.default.exitSuccess((0, texts_js_1.TXT_TUNNEL_STARTED)(data.type));
+        }
+    }
+    catch (err) {
+        output_js_1.default.exitError(err);
+    }
+});
+exports.default = commandAgentTunnelHttp;