bdy 1.16.12 → 1.16.15-dev

package/distTs/src/command/workspace/list.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const output_1 = __importDefault(require("../../output"));
+const client_1 = __importDefault(require("../../api/client"));
+const texts_1 = require("../../texts");
+const utils_1 = require("../../utils");
+const input_1 = __importDefault(require("../../input"));
+const commandWorkspaceList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_WORKSPACE_LIST);
+commandWorkspaceList.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandWorkspaceList.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandWorkspaceList.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandWorkspaceList.alias('ls');
+commandWorkspaceList.action(async (options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const client = new client_1.default(baseUrl, token);
+    const response = await client.getWorkspaces();
+    if (!response.workspaces || response.workspaces.length === 0) {
+        output_1.default.normal('No workspaces found.');
+        output_1.default.exitNormal();
+    }
+    const data = [['NAME', 'DOMAIN']];
+    for (const ws of response.workspaces) {
+        data.push([ws.name, ws.domain]);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandWorkspaceList;

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

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cfg_1 = __importDefault(require("../../tunnel/cfg"));
+const output_1 = __importDefault(require("../../output"));
+const client_1 = __importDefault(require("../../api/client"));
+const texts_1 = require("../../texts");
+const utils_1 = require("../../utils");
+const input_1 = __importDefault(require("../../input"));
+const commandWorkspaceSet = (0, utils_1.newCommand)('set', texts_1.DESC_COMMAND_WORKSPACE_SET);
+commandWorkspaceSet.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandWorkspaceSet.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandWorkspaceSet.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandWorkspaceSet.argument('[workspace]', texts_1.ARG_COMMAND_WORKSPACE);
+commandWorkspaceSet.action(async (workspaceDomain, options) => {
+    output_1.default.handleSignals();
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const client = new client_1.default(baseUrl, token);
+    const response = await client.getWorkspaces();
+    if (!response.workspaces || response.workspaces.length === 0) {
+        output_1.default.exitError(texts_1.ERR_LOGIN_NO_WORKSPACES);
+    }
+    let workspace;
+    if (workspaceDomain) {
+        const found = response.workspaces.find((w) => w.domain === workspaceDomain);
+        if (!found) {
+            output_1.default.exitError(texts_1.ERR_LOGIN_NO_WORKSPACE_FOUND);
+        }
+        workspace = found.domain;
+    }
+    else {
+        workspace = await output_1.default.selectWorkspace(response.workspaces);
+    }
+    cfg_1.default.setWorkspace(workspace);
+    output_1.default.exitSuccess((0, texts_1.TXT_WORKSPACE_SET_SUCCESS)(workspace));
+});
+exports.default = commandWorkspaceSet;

package/distTs/src/command/workspace.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 texts_1 = require("../texts");
+const utils_1 = require("../utils");
+const list_1 = __importDefault(require("./workspace/list"));
+const set_1 = __importDefault(require("./workspace/set"));
+const get_1 = __importDefault(require("./workspace/get"));
+const commandWorkspace = (0, utils_1.newCommand)('workspace', texts_1.DESC_COMMAND_WORKSPACE);
+commandWorkspace.alias('ws');
+commandWorkspace.addCommand(list_1.default);
+commandWorkspace.addCommand(set_1.default);
+commandWorkspace.addCommand(get_1.default);
+exports.default = commandWorkspace;

package/distTs/src/index.js

@@ -15,6 +15,12 @@ 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"));
+const sandbox_1 = __importDefault(require("./command/sandbox"));
+const login_1 = __importDefault(require("./command/login"));
+const logout_1 = __importDefault(require("./command/logout"));
+const workspace_1 = __importDefault(require("./command/workspace"));
+const project_1 = __importDefault(require("./command/project"));
+const whoami_1 = __importDefault(require("./command/whoami"));
 stream_1.default.setDefaultHighWaterMark(false, 67108864);
 process.title = 'bdy';
 process.on('uncaughtException', (err) => {
@@ -33,4 +39,10 @@ program.addCommand(version_1.default);
 program.addCommand(vt_1.default);
 program.addCommand(ut_1.default);
 program.addCommand(pipeline_1.default);
+program.addCommand(sandbox_1.default);
+program.addCommand(login_1.default);
+program.addCommand(whoami_1.default);
+program.addCommand(logout_1.default);
+program.addCommand(workspace_1.default);
+program.addCommand(project_1.default);
 program.parse();

package/distTs/src/input.js

@@ -39,12 +39,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const output_1 = __importDefault(require("./output"));
 const netmask_1 = __importDefault(require("netmask"));
 const punycode_1 = __importDefault(require("punycode/"));
-const fs_1 = __importStar(require("fs"));
+const node_fs_1 = __importStar(require("node:fs"));
 const tls_1 = __importDefault(require("tls"));
-const crypto_1 = __importDefault(require("crypto"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_path_1 = __importDefault(require("node:path"));
 const utils_1 = require("./utils");
 const texts_1 = require("./texts");
 const tunnel_1 = require("./types/tunnel");
+const cfg_1 = __importDefault(require("./tunnel/cfg"));
 class Input {
     static timeout(timeout) {
         const t = parseInt(timeout, 10);
@@ -57,7 +59,7 @@ class Input {
         if (!serve)
             return serve;
         try {
-            const info = (0, fs_1.statSync)(serve);
+            const info = (0, node_fs_1.statSync)(serve);
             if (!info.isDirectory()) {
                 output_1.default.exitError((0, texts_1.ERR_PATH_IS_NOT_DIRECTORY)(serve));
             }
@@ -76,6 +78,18 @@ class Input {
         }
         return n;
     }
+    static sandboxHeaders(headers) {
+        const r = {};
+        (headers || []).forEach((h) => {
+            if (!h)
+                return;
+            const s = h.split(':');
+            if (s.length !== 2)
+                return;
+            r[s[0]] = s[1];
+        });
+        return r;
+    }
     static headers(headers) {
         const r = [];
         (headers || []).forEach((h) => {
@@ -91,6 +105,65 @@ class Input {
         });
         return r;
     }
+    static prepareSandboxEndpoint(options) {
+        const type = this.type(options.type);
+        const ep = {
+            type,
+            name: this.name(options.name),
+            endpoint: this.target(options.endpoint, type),
+        };
+        if (options.epRegion !== undefined)
+            ep.region = this.region(options.epRegion);
+        if (options.whitelist !== undefined)
+            ep.whitelist = this.whitelist(options.whitelist);
+        if (options.timeout !== undefined)
+            ep.timeout = this.timeout(options.timeout);
+        if (type === tunnel_1.TUNNEL_TYPE.HTTP) {
+            ep.http = {};
+            ep.http.auth_type = tunnel_1.TUNNEL_HTTP_AUTH_TYPE.NONE;
+            if (options.host !== undefined) {
+                ep.http.rewrite_host_header = options.host;
+            }
+            if (options.auth !== undefined) {
+                const { password, login } = this.auth(options.auth);
+                ep.http.login = login;
+                ep.http.password = password;
+                ep.http.auth_type = tunnel_1.TUNNEL_HTTP_AUTH_TYPE.BASIC;
+            }
+            else if (options.buddy) {
+                ep.http.auth_type = tunnel_1.TUNNEL_HTTP_AUTH_TYPE.BUDDY;
+            }
+            if (options.ca !== undefined)
+                ep.http.tls_ca = this.ca(options.ca);
+            if (options.serve !== undefined)
+                ep.http.serve_path = this.serve(options.serve);
+            if (options.useragent !== undefined)
+                ep.http.whitelist_user_agents = this.useragents(options.useragent);
+            if (options.header !== undefined)
+                ep.http.request_headers = this.sandboxHeaders(options.header);
+            if (options.responseHeader !== undefined)
+                ep.http.response_headers = this.sandboxHeaders(options.responseHeader);
+            if (options.circuitBreaker !== undefined) {
+                ep.http.circuit_breaker = this.circuitBreaker(options.circuitBreaker) * 100;
+            }
+            ep.http.log_requests = !!options.log;
+            ep.http.verify_certificate = !!options.verify;
+            ep.http.http2 = !!options.http2;
+            ep.http.compression = !!options.compression;
+        }
+        else if (type === tunnel_1.TUNNEL_TYPE.TLS) {
+            ep.tls = {};
+            ep.tls.terminate_at = this.terminate(options.terminate);
+            if (options.key !== undefined || options.cert !== undefined) {
+                const { key, cert } = this.keyCert(options.key, options.cert);
+                ep.tls.private_key = key;
+                ep.tls.certificate = cert;
+            }
+            if (options.ca !== undefined)
+                ep.tls.ca_certificate = this.ca(options.ca);
+        }
+        return ep;
+    }
     static auth(auth) {
         const s = auth.split(':');
         if (s.length !== 2) {
@@ -229,6 +302,8 @@ class Input {
         let t = process.env.BUDDY_TOKEN;
         if (token)
             t = token;
+        if (!t)
+            t = cfg_1.default.getApiToken();
         if (!t) {
             output_1.default.exitError(texts_1.ERR_REST_API_TOKEN);
         }
@@ -306,23 +381,34 @@ class Input {
         });
         return list;
     }
+    static restApiRegion(region) {
+        const r = region.toLowerCase();
+        if (Object.values(utils_1.REST_API_REGION).includes(r)) {
+            return r;
+        }
+        else {
+            output_1.default.exitError(texts_1.ERR_REST_API_REGION);
+        }
+    }
     static restApiBaseUrl(api, region) {
         let u = process.env.BUDDY_API_ENDPOINT;
         if (api)
             u = api;
+        if (!u)
+            u = cfg_1.default.getBaseUrl();
         if (!u) {
             let r = process.env.BUDDY_REGION;
             if (region)
                 r = region;
-            if (r === 'eu')
-                u = 'api.eu.buddy.works';
-            else if (r === 'as')
-                u = 'api.as.buddy.works';
-            else if (r === 'us')
-                u = 'api.buddy.works';
+            if (r?.toLowerCase() === utils_1.REST_API_REGION.EU)
+                u = utils_1.REST_API_ENDPOINT.EU;
+            else if (r?.toLowerCase() === utils_1.REST_API_REGION.AS)
+                u = utils_1.REST_API_ENDPOINT.AS;
+            else if (r?.toLowerCase() === utils_1.REST_API_REGION.US)
+                u = utils_1.REST_API_ENDPOINT.US;
         }
         if (!u)
-            u = 'api.buddy.works';
+            u = utils_1.REST_API_ENDPOINT.US;
         u = u.replace(/^https?:\/\//g, '');
         try {
             return new URL(`https://${u}`);
@@ -345,20 +431,62 @@ class Input {
         let w = process.env.BUDDY_WORKSPACE;
         if (workspace)
             w = workspace;
+        if (!w)
+            w = cfg_1.default.getWorkspace();
         if (!w) {
             output_1.default.exitError(texts_1.ERR_REST_API_WORKSPACE);
         }
         return w;
     }
+    static restApiSandboxDestinationPath(destPath) {
+        const s = (destPath || '').split(':');
+        if (s.length !== 2) {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_CP_INVALID_DEST);
+        }
+        const identifier = s[0];
+        let remotePath = s[1];
+        if (!identifier) {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_CP_INVALID_DEST);
+        }
+        if (!remotePath.startsWith('/')) {
+            remotePath = `/${remotePath}`;
+        }
+        return {
+            identifier,
+            remotePath
+        };
+    }
+    static restApiSandboxSourcePath(sourcePath) {
+        const s = node_path_1.default.resolve(sourcePath);
+        let sourceStats;
+        try {
+            sourceStats = node_fs_1.default.statSync(s);
+        }
+        catch {
+            output_1.default.exitError((0, texts_1.ERR_SANDBOX_CP_SOURCE_NOT_FOUND)(sourcePath));
+        }
+        return { sourceStats, sourcePath: s };
+    }
     static restApiProject(project) {
         let p = process.env.BUDDY_PROJECT;
         if (project)
             p = project;
+        if (!p)
+            p = cfg_1.default.getProject();
         if (!p) {
             output_1.default.exitError(texts_1.ERR_REST_API_PROJECT);
         }
         return p;
     }
+    static restApiSandboxExecRuntime(runtime) {
+        if (!runtime)
+            runtime = utils_1.SANDBOX_EXEC_RUNTIME.BASH;
+        const vals = Object.values(utils_1.SANDBOX_EXEC_RUNTIME);
+        if (!vals.includes(runtime)) {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_EXEC_RUNTIME_NOT_FOUND);
+        }
+        return runtime;
+    }
     static name(name) {
         if (name.includes('*')) {
             output_1.default.exitError(texts_1.ERR_NAME_WITHOUT_ASTERISK);
@@ -368,13 +496,13 @@ class Input {
     static ca(caPath) {
         let cert;
         try {
-            cert = fs_1.default.readFileSync(caPath, 'utf8');
+            cert = node_fs_1.default.readFileSync(caPath, 'utf8');
         }
         catch {
             output_1.default.exitError((0, texts_1.ERR_CA_PATH_IS_NOT_VALID)(caPath));
         }
         try {
-            new crypto_1.default.X509Certificate(cert);
+            new node_crypto_1.default.X509Certificate(cert);
         }
         catch {
             output_1.default.exitError((0, texts_1.ERR_WRONG_CA)(caPath));
@@ -385,13 +513,13 @@ class Input {
         let key;
         let cert;
         try {
-            key = fs_1.default.readFileSync(keyPath, 'utf8');
+            key = node_fs_1.default.readFileSync(keyPath, 'utf8');
         }
         catch {
             output_1.default.exitError((0, texts_1.ERR_KEY_PATH_IS_NOT_VALID)(keyPath));
         }
         try {
-            cert = fs_1.default.readFileSync(certPath, 'utf8');
+            cert = node_fs_1.default.readFileSync(certPath, 'utf8');
         }
         catch {
             output_1.default.exitError((0, texts_1.ERR_CERT_PATH_IS_NOT_VALID)(certPath));

package/distTs/src/output.js

@@ -152,6 +152,50 @@ class Output {
         const on = new tunnel_3.default(terminal, tunnel);
         on.start(this);
     }
+    static handleSignals() {
+        terminal.on('key', (key) => {
+            if (key === 'CTRL_C' || key === 'ESCAPE') {
+                terminal.fullscreen(false);
+                terminal.hideCursor(false);
+                terminal.grabInput(false);
+                terminal('\nCanceled\n');
+                process.exit(0);
+            }
+        });
+    }
+    static async inputString() {
+        return new Promise((resolve) => {
+            terminal.inputField((_, input) => {
+                terminal('\n');
+                resolve((input || '').trim());
+            });
+        });
+    }
+    static async inputMenu(items) {
+        return new Promise((resolve) => {
+            terminal.singleColumnMenu(items, (_, response) => {
+                terminal('\n');
+                resolve(response.selectedIndex);
+            });
+        });
+    }
+    static async selectWorkspace(workspaces) {
+        Output.normal(texts_1.TXT_LOGIN_SELECT_WORKSPACE);
+        const items = workspaces.map((w) => `${w.name} (${w.domain})`);
+        const index = await Output.inputMenu(items);
+        return workspaces[index].domain;
+    }
+    static async selectProject(projects) {
+        Output.normal(texts_1.TXT_LOGIN_SELECT_PROJECT);
+        const items = [
+            "Don't set (default)",
+            ...projects.map((p) => `${p.display_name} (${p.name})`),
+        ];
+        const index = await Output.inputMenu(items);
+        if (index > 0)
+            return projects[index - 1].name;
+        return '';
+    }
     static exitError(err) {
         this.killSpinner();
         terminal.fullscreen(false);