bdy 1.16.11-master → 1.16.11-sbs-2

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.16.11-master",
+  "version": "1.16.11-sbs-2",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {
@@ -31,6 +31,8 @@
     "eventsource": "4.0.0",
     "fastify": "4.28.1",
     "fdir": "6.5.0",
+    "fflate": "0.8.2",
+    "human-id": "^4.1.3",
     "isbinaryfile": "5.0.2",
     "jsonwebtoken": "9.0.2",
     "mime-db": "1.52.0",
@@ -52,8 +54,7 @@
     "uuid": "10.0.0",
     "which": "4.0.0",
     "ws": "8.18.0",
-    "zod": "3.24.2",
-    "fflate": "0.8.2"
+    "zod": "3.24.2"
   },
   "devDependencies": {
     "@eslint/js": "9.13.0",

package/distTs/src/api/client.js

@@ -55,7 +55,19 @@ class ApiClient {
             throw new Error(texts_1.ERR_REST_API_WRONG_TOKEN);
         }
         if (status === 403) {
-            await responseBody.dump();
+            let json;
+            try {
+                json = await responseBody.json();
+                logger_1.default.debug('API CLIENT PARSED RESPONSE:');
+                logger_1.default.debug(json);
+            }
+            catch (err) {
+                await responseBody.dump();
+                throw new Error(texts_1.ERR_REST_API_RATE_LIMIT);
+            }
+            if (json.errors && json.errors[0] && json.errors[0].message) {
+                throw new Error(json.errors[0].message);
+            }
             throw new Error(texts_1.ERR_REST_API_RATE_LIMIT);
         }
         if ([400, 404].includes(status)) {
@@ -79,7 +91,7 @@ class ApiClient {
             else
                 throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
         }
-        if (status === 200) {
+        if (status === 200 || status === 201) {
             if (parseResponseBody) {
                 try {
                     const b = await responseBody.json();
@@ -98,6 +110,10 @@ class ApiClient {
                 return null;
             }
         }
+        else if (status === 204) {
+            await responseBody.dump();
+            return null;
+        }
         else {
             await responseBody.dump();
             throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
@@ -112,5 +128,65 @@ class ApiClient {
     async postPipelineRun(workspace, project, pipelineId, body) {
         return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions`, body, true);
     }
+    // Sandbox methods
+    async createSandbox(workspace, project, body) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes?project_name=${encodeURIComponent(project)}`, body, true);
+    }
+    async listSandboxes(workspace, project) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes?project_name=${encodeURIComponent(project)}`, null, true);
+    }
+    async getSandbox(workspace, sandboxId) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}`, null, true);
+    }
+    async deleteSandbox(workspace, sandboxId) {
+        return await this.request('DELETE', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}`, null, false);
+    }
+    async updateSandbox(workspace, sandboxId, body) {
+        return await this.request('PATCH', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}`, body, true);
+    }
+    async startSandbox(workspace, sandboxId) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/start`, {}, true);
+    }
+    async stopSandbox(workspace, sandboxId) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/stop`, {}, true);
+    }
+    async restartSandbox(workspace, sandboxId) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/restart`, {}, true);
+    }
+    async executeSandboxCommand(workspace, sandboxId, body) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands`, body, true);
+    }
+    async getSandboxCommand(workspace, sandboxId, commandId) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}`, null, true);
+    }
+    async listSandboxCommands(workspace, sandboxId) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands`, null, true);
+    }
+    async getSandboxCommandLogsUrl(workspace, sandboxId, commandId) {
+        return `${this.baseUrl.origin}/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}/logs`;
+    }
+    async terminateSandboxCommand(workspace, sandboxId, commandId) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}/terminate`, {}, true);
+    }
+    // Snapshot methods
+    async listSandboxSnapshots(workspace, sandboxId) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots`, null, true);
+    }
+    async createSandboxSnapshot(workspace, sandboxId, body) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots`, body, true);
+    }
+    async getSandboxSnapshot(workspace, sandboxId, snapshotId) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(snapshotId)}`, null, true);
+    }
+    async deleteSandboxSnapshot(workspace, sandboxId, snapshotId) {
+        return await this.request('DELETE', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(snapshotId)}`, null, false);
+    }
+    // Workspace and Project methods
+    async getWorkspaces() {
+        return await this.request('GET', '/workspaces', null, true);
+    }
+    async getProjects(workspace) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/projects`, null, true);
+    }
 }
 exports.default = ApiClient;

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

@@ -61,19 +61,20 @@ const installService = async (options) => {
         id = options.id;
         token = options.token;
         try {
-            agent = await buddy_1.default.fetchAgent(id, cfg_1.default.getTokenHost(), token);
+            const host = cfg_1.default.getTokenHost(token);
+            agent = await buddy_1.default.fetchAgent(id, host, token);
         }
         catch {
             output_1.default.exitError(texts_1.ERR_AGENT_NOT_FOUND);
         }
     }
-    else if (options.token) {
-        // set global token if passed
-        cfg_1.default.setToken(options.token);
+    else {
+        // Use fallback logic for token
+        token = input_1.default.tunnelToken(options.token);
     }
-    const host = cfg_1.default.getTokenHost();
+    const host = cfg_1.default.getTokenHost(token);
     if (!agent) {
-        agent = await buddy_1.default.register(true, target, host, cfg_1.default.getToken(), (region) => {
+        agent = await buddy_1.default.register(true, target, host, token, (region) => {
             cfg_1.default.setRegionIfNotSet(region);
         });
         id = agent.id;
@@ -128,21 +129,16 @@ const installApp = async (options) => {
     }
     let id;
     let host;
-    let token;
+    let token = input_1.default.tunnelToken(options.token);
     const port = input_1.default.port(options.port);
     if (options.id) {
         id = options.id;
     }
-    if (!token) {
-        token = options.token;
-    }
     if (!id) {
-        if (token)
-            cfg_1.default.setToken(token);
-        host = cfg_1.default.getTokenHost();
+        host = cfg_1.default.getTokenHost(token);
         try {
             output_1.default.normal(texts_1.TXT_AGENT_STANDALONE_AGENT_REGISTERING, false);
-            const agent = await buddy_1.default.register(true, !!options.target, host, cfg_1.default.getToken(), (region) => {
+            const agent = await buddy_1.default.register(true, !!options.target, host, token, (region) => {
                 cfg_1.default.setRegionIfNotSet(region);
             });
             logger_1.default.info(texts_1.TXT_AGENT_STANDALONE_AGENT_REGISTERED);
@@ -159,9 +155,7 @@ const installApp = async (options) => {
         }
     }
     else {
-        if (!host) {
-            host = cfg_1.default.getTokenHost();
-        }
+        host = cfg_1.default.getTokenHost(token);
         try {
             logger_1.default.info(texts_1.TXT_AGENT_STANDALONE_AGENT_FETCHING);
             output_1.default.normal(texts_1.TXT_AGENT_STANDALONE_AGENT_FETCHING, false);

package/distTs/src/command/login.js

@@ -0,0 +1,298 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const termkit_no_lazy_require_1 = __importDefault(require("terminal-kit/lib/termkit-no-lazy-require"));
+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 terminal = termkit_no_lazy_require_1.default.terminal;
+// Handle Ctrl+C and ESC
+terminal.on('key', (key) => {
+    if (key === 'CTRL_C' || key === 'ESCAPE') {
+        terminal.grabInput(false);
+        terminal('\nCanceled\n');
+        process.exit(0);
+    }
+});
+function getSecurityUrl(region, baseUrl) {
+    switch (region) {
+        case 'us':
+            return 'https://app.buddy.works/security';
+        case 'eu':
+            return 'https://eu.buddy.works/security';
+        case 'as':
+            return 'https://asia.buddy.works/security';
+        case 'onprem':
+            return `https://${baseUrl}/security`;
+    }
+}
+function getApiUrl(region, baseUrl) {
+    switch (region) {
+        case 'us':
+            return 'api.buddy.works';
+        case 'eu':
+            return 'api.eu.buddy.works';
+        case 'as':
+            return 'api.asia.buddy.works';
+        case 'onprem':
+            return `${baseUrl}/api`;
+    }
+}
+function normalizeBaseUrl(url) {
+    let normalized = url.trim();
+    normalized = normalized.replace(/^https?:\/\//i, '');
+    normalized = normalized.replace(/\/+$/, '');
+    return normalized;
+}
+async function selectRegion() {
+    terminal(`${texts_1.TXT_LOGIN_SELECT_REGION}\n`);
+    const items = ['US (default)', 'EU', 'Asia', 'On-premises'];
+    return new Promise((resolve) => {
+        terminal.singleColumnMenu(items, (error, response) => {
+            terminal('\n');
+            if (response.selectedIndex === 0)
+                resolve('us');
+            else if (response.selectedIndex === 1)
+                resolve('eu');
+            else if (response.selectedIndex === 2)
+                resolve('as');
+            else
+                resolve('onprem');
+        });
+    });
+}
+async function inputBaseUrl() {
+    terminal(`${texts_1.TXT_LOGIN_ENTER_BASE_URL} `);
+    return new Promise((resolve) => {
+        terminal.inputField((error, input) => {
+            terminal('\n');
+            const normalized = normalizeBaseUrl(input || '');
+            if (!normalized) {
+                output_1.default.exitError(texts_1.ERR_LOGIN_INVALID_BASE_URL);
+            }
+            resolve(normalized);
+        });
+    });
+}
+async function inputToken() {
+    terminal(`${texts_1.TXT_LOGIN_ENTER_TOKEN} `);
+    return new Promise((resolve) => {
+        terminal.inputField((error, input) => {
+            terminal('\n');
+            resolve(input?.trim() || '');
+        });
+    });
+}
+async function inputTunnelToken() {
+    terminal(`${texts_1.TXT_LOGIN_ENTER_TUNNEL_TOKEN} `);
+    return new Promise((resolve) => {
+        terminal.inputField((error, input) => {
+            terminal('\n');
+            resolve(input?.trim() || '');
+        });
+    });
+}
+async function selectWorkspace(workspaces) {
+    terminal(`${texts_1.TXT_LOGIN_SELECT_WORKSPACE}\n`);
+    const items = workspaces.map((w) => `${w.name} (${w.domain})`);
+    return new Promise((resolve) => {
+        terminal.singleColumnMenu(items, (error, response) => {
+            terminal('\n');
+            resolve(workspaces[response.selectedIndex]);
+        });
+    });
+}
+async function selectProject(projects) {
+    return new Promise((resolve) => {
+        terminal(`${texts_1.TXT_LOGIN_SELECT_PROJECT}\n`);
+        const items = ["Don't set (default)", ...projects.map((p) => `${p.display_name} (${p.name})`)];
+        // Use nextTick to ensure text is rendered before menu
+        process.nextTick(() => {
+            terminal.singleColumnMenu(items, (error, response) => {
+                terminal('\n');
+                if (response.selectedIndex === 0) {
+                    resolve(null);
+                }
+                else {
+                    resolve(projects[response.selectedIndex - 1]);
+                }
+            });
+        });
+    });
+}
+async function fetchProjects(apiUrl, token, workspace) {
+    try {
+        const client = new client_1.default(new URL(`https://${apiUrl}`), token);
+        const response = await client.getProjects(workspace);
+        return response.projects || [];
+    }
+    catch {
+        return [];
+    }
+}
+async function verifyTokenAndGetWorkspaces(apiUrl, token) {
+    const client = new client_1.default(new URL(`https://${apiUrl}`), token);
+    const response = await client.getWorkspaces();
+    return response.workspaces;
+}
+const commandLogin = (0, utils_1.newCommand)('login', texts_1.DESC_COMMAND_LOGIN);
+commandLogin.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandLogin.option('--tunnel-token <token>', 'tunnel token for agent operations');
+commandLogin.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandLogin.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandLogin.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandLogin.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandLogin.action(async (options) => {
+    try {
+        const hasToken = !!options.token;
+        const hasRegionOrApi = !!options.region || !!options.api;
+        // Non-interactive mode: token is required, region/api optional (defaults to us)
+        if (hasToken) {
+            const token = options.token;
+            let region;
+            let baseUrl;
+            let apiUrl;
+            if (options.api) {
+                region = 'onprem';
+                baseUrl = normalizeBaseUrl(options.api);
+                apiUrl = baseUrl;
+            }
+            else if (options.region?.toLowerCase() === 'eu') {
+                region = 'eu';
+                apiUrl = 'api.eu.buddy.works';
+            }
+            else if (options.region?.toLowerCase() === 'as') {
+                region = 'as';
+                apiUrl = 'api.asia.buddy.works';
+            }
+            else {
+                region = 'us';
+                apiUrl = 'api.buddy.works';
+            }
+            // Verify token
+            output_1.default.normal(texts_1.TXT_LOGIN_VERIFYING);
+            let workspaces;
+            try {
+                workspaces = await verifyTokenAndGetWorkspaces(apiUrl, token);
+            }
+            catch {
+                output_1.default.exitError(texts_1.ERR_LOGIN_INVALID_TOKEN);
+            }
+            if (!workspaces || workspaces.length === 0) {
+                output_1.default.exitError(texts_1.ERR_LOGIN_NO_WORKSPACES);
+            }
+            // Select workspace
+            let selectedWorkspace;
+            if (options.workspace) {
+                const found = workspaces.find((w) => w.domain === options.workspace);
+                if (!found) {
+                    output_1.default.exitError(`Workspace "${options.workspace}" not found`);
+                }
+                selectedWorkspace = found;
+            }
+            else if (workspaces.length === 1) {
+                selectedWorkspace = workspaces[0];
+            }
+            else {
+                selectedWorkspace = await selectWorkspace(workspaces);
+            }
+            // Select project (optional)
+            let selectedProject = null;
+            if (options.project) {
+                const projects = await fetchProjects(apiUrl, token, selectedWorkspace.domain);
+                const found = projects.find((p) => p.name === options.project);
+                if (found) {
+                    selectedProject = found;
+                }
+            }
+            // Save to config
+            cfg_1.default.clearLogin();
+            cfg_1.default.setToken(token);
+            cfg_1.default.setWorkspace(selectedWorkspace.domain);
+            if (selectedProject) {
+                cfg_1.default.setProject(selectedProject.name);
+            }
+            if (options.tunnelToken) {
+                cfg_1.default.setTunnelToken(options.tunnelToken);
+            }
+            if (region === 'onprem' && baseUrl) {
+                cfg_1.default.setBaseUrl(apiUrl);
+            }
+            else {
+                cfg_1.default.setRegion(region.toUpperCase());
+            }
+            output_1.default.exitSuccess(texts_1.TXT_LOGIN_SUCCESS);
+            return;
+        }
+        // Interactive mode
+        // Step 1: Select region
+        const region = await selectRegion();
+        // Step 2: Get base URL if on-premises
+        let baseUrl;
+        if (region === 'onprem') {
+            baseUrl = await inputBaseUrl();
+        }
+        // Step 3: Show token URL and ask for token
+        const securityUrl = getSecurityUrl(region, baseUrl);
+        terminal.cyan(`${(0, texts_1.TXT_LOGIN_TOKEN_INFO)(securityUrl)}\n`);
+        const token = await inputToken();
+        if (!token) {
+            output_1.default.exitError(texts_1.ERR_LOGIN_INVALID_TOKEN);
+        }
+        // Step 4: Verify token by fetching workspaces
+        terminal(`${texts_1.TXT_LOGIN_VERIFYING}\n`);
+        const apiUrl = getApiUrl(region, baseUrl);
+        let workspaces;
+        try {
+            workspaces = await verifyTokenAndGetWorkspaces(apiUrl, token);
+        }
+        catch {
+            output_1.default.exitError(texts_1.ERR_LOGIN_INVALID_TOKEN);
+        }
+        if (!workspaces || workspaces.length === 0) {
+            output_1.default.exitError(texts_1.ERR_LOGIN_NO_WORKSPACES);
+        }
+        // Step 5: Select workspace (or auto-select if only one)
+        let selectedWorkspace;
+        if (workspaces.length === 1) {
+            selectedWorkspace = workspaces[0];
+        }
+        else {
+            selectedWorkspace = await selectWorkspace(workspaces);
+        }
+        // Step 6: Optionally select project
+        const projects = await fetchProjects(apiUrl, token, selectedWorkspace.domain);
+        let selectedProject = null;
+        if (projects.length > 0) {
+            selectedProject = await selectProject(projects);
+        }
+        // Step 7: Optionally ask for tunnel token
+        const tunnelToken = await inputTunnelToken();
+        // Step 8: Save to config
+        cfg_1.default.clearLogin();
+        cfg_1.default.setToken(token);
+        cfg_1.default.setWorkspace(selectedWorkspace.domain);
+        if (selectedProject) {
+            cfg_1.default.setProject(selectedProject.name);
+        }
+        if (tunnelToken) {
+            cfg_1.default.setTunnelToken(tunnelToken);
+        }
+        if (region === 'onprem' && baseUrl) {
+            cfg_1.default.setBaseUrl(apiUrl);
+        }
+        else {
+            cfg_1.default.setRegion(region.toUpperCase());
+        }
+        output_1.default.exitSuccess(texts_1.TXT_LOGIN_SUCCESS);
+    }
+    catch (err) {
+        output_1.default.exitError(err);
+    }
+});
+exports.default = commandLogin;

package/distTs/src/command/logout.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cfg_1 = __importDefault(require("../tunnel/cfg"));
+const output_1 = __importDefault(require("../output"));
+const texts_1 = require("../texts");
+const utils_1 = require("../utils");
+const commandLogout = (0, utils_1.newCommand)('logout', texts_1.DESC_COMMAND_LOGOUT);
+commandLogout.action(async () => {
+    cfg_1.default.clearLogin();
+    output_1.default.exitSuccess(texts_1.TXT_LOGOUT_SUCCESS);
+});
+exports.default = commandLogout;