bdy 1.16.11-dev → 1.16.11-sbs-1

package/distTs/src/command/sandbox/command.js

@@ -0,0 +1,18 @@
+"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 list_1 = __importDefault(require("./command/list"));
+const status_1 = __importDefault(require("./command/status"));
+const logs_1 = __importDefault(require("./command/logs"));
+const kill_1 = __importDefault(require("./command/kill"));
+const commandSandboxCommand = (0, utils_1.newCommand)('command', texts_1.DESC_COMMAND_SANDBOX_COMMAND);
+commandSandboxCommand.alias('cmd');
+commandSandboxCommand.addCommand(list_1.default);
+commandSandboxCommand.addCommand(status_1.default);
+commandSandboxCommand.addCommand(logs_1.default);
+commandSandboxCommand.addCommand(kill_1.default);
+exports.default = commandSandboxCommand;

package/distTs/src/command/sandbox/cp.js

@@ -0,0 +1,123 @@
+"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 output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+const client_1 = __importDefault(require("../../api/client"));
+const fdir_1 = require("fdir");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const commandSandboxCp = (0, utils_1.newCommand)('cp', texts_1.DESC_COMMAND_SANDBOX_CP);
+commandSandboxCp.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxCp.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxCp.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxCp.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxCp.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxCp.option('-s, --silent', texts_1.OPTION_SANDBOX_CP_SILENT);
+commandSandboxCp.argument('<source>', texts_1.OPTION_SANDBOX_CP_SOURCE);
+commandSandboxCp.argument('<destination>', texts_1.OPTION_SANDBOX_CP_DEST);
+function parseDestination(dest) {
+    const colonIndex = dest.indexOf(':');
+    if (colonIndex === -1 || colonIndex === 0) {
+        return null;
+    }
+    const identifier = dest.substring(0, colonIndex);
+    let remotePath = dest.substring(colonIndex + 1);
+    // Ensure remote path starts with /
+    if (!remotePath.startsWith('/')) {
+        remotePath = '/' + remotePath;
+    }
+    return { identifier, remotePath };
+}
+async function copyFileToSandbox(client, workspace, sandboxId, localPath, remotePath) {
+    const content = (0, fs_1.readFileSync)(localPath);
+    const base64 = content.toString('base64');
+    // Create parent directory if needed
+    const parentDir = (0, path_1.dirname)(remotePath);
+    if (parentDir !== '/') {
+        await client.executeSandboxCommand(workspace, sandboxId, {
+            command: `mkdir -p '${parentDir}'`,
+        });
+    }
+    // Transfer file using base64
+    // For files up to ~48KB encoded (fits in typical command line)
+    if (base64.length <= 65536) {
+        await client.executeSandboxCommand(workspace, sandboxId, {
+            command: `echo '${base64}' | base64 -d > '${remotePath}'`,
+        });
+    }
+    else {
+        // For larger files, use heredoc approach
+        await client.executeSandboxCommand(workspace, sandboxId, {
+            command: `base64 -d > '${remotePath}' << 'EOFBASE64'\n${base64}\nEOFBASE64`,
+        });
+    }
+}
+commandSandboxCp.action(async (source, destination, options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = new client_1.default(baseUrl, token);
+    // Parse destination
+    const parsed = parseDestination(destination);
+    if (!parsed) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_CP_INVALID_DEST);
+    }
+    const { identifier, remotePath } = parsed;
+    // Validate source exists
+    const sourcePath = (0, path_1.resolve)(source);
+    if (!(0, fs_1.existsSync)(sourcePath)) {
+        output_1.default.exitError((0, texts_1.ERR_SANDBOX_CP_SOURCE_NOT_FOUND)(source));
+    }
+    // Find sandbox by identifier
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    const stats = (0, fs_1.statSync)(sourcePath);
+    const silent = options.silent;
+    if (stats.isFile()) {
+        // Single file copy
+        if (!silent)
+            output_1.default.gray((0, texts_1.TXT_SANDBOX_CP_PROGRESS)(1, 1, (0, path_1.basename)(sourcePath)));
+        await copyFileToSandbox(client, workspace, found.id, sourcePath, remotePath);
+        output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_CP_DONE)(1));
+    }
+    else if (stats.isDirectory()) {
+        // Directory copy - get all files recursively
+        const files = new fdir_1.fdir()
+            .withFullPaths()
+            .crawl(sourcePath)
+            .sync();
+        if (files.length === 0) {
+            output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_CP_DONE)(0));
+        }
+        if (!silent)
+            output_1.default.normal(`Copying ${files.length} file(s)...`);
+        for (let i = 0; i < files.length; i++) {
+            const localFile = files[i];
+            const relativePath = (0, path_1.relative)(sourcePath, localFile);
+            const remoteFile = (0, path_1.join)(remotePath, relativePath).replace(/\\/g, '/');
+            if (!silent)
+                output_1.default.gray((0, texts_1.TXT_SANDBOX_CP_PROGRESS)(i + 1, files.length, relativePath));
+            try {
+                await copyFileToSandbox(client, workspace, found.id, localFile, remoteFile);
+            }
+            catch (err) {
+                output_1.default.error(`Failed to copy ${relativePath}: ${err.message || err}`);
+            }
+        }
+        output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_CP_DONE)(files.length));
+    }
+    else {
+        output_1.default.exitError((0, texts_1.ERR_SANDBOX_CP_SOURCE_NOT_FOUND)(source));
+    }
+});
+exports.default = commandSandboxCp;

package/distTs/src/command/sandbox/create.js

@@ -0,0 +1,99 @@
+"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 output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+const client_1 = __importDefault(require("../../api/client"));
+const human_id_1 = __importDefault(require("human-id"));
+const VALID_RESOURCES = ['1x2', '2x4', '3x6', '4x8', '5x10', '6x12', '7x14', '8x16', '9x18', '10x20', '11x22', '12x24', 'CUSTOM'];
+const commandSandboxCreate = (0, utils_1.newCommand)('create', texts_1.DESC_COMMAND_SANDBOX_CREATE);
+commandSandboxCreate.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxCreate.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxCreate.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxCreate.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxCreate.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxCreate.option('-n, --name <name>', texts_1.OPTION_SANDBOX_NAME);
+commandSandboxCreate.option('-i, --identifier <identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxCreate.option('--os <image>', texts_1.OPTION_SANDBOX_OS);
+commandSandboxCreate.option('--snapshot <snapshot-name>', texts_1.OPTION_SANDBOX_FROM_SNAPSHOT);
+commandSandboxCreate.option('--resources <spec>', texts_1.OPTION_SANDBOX_RESOURCES);
+commandSandboxCreate.option('--install-commands <commands...>', texts_1.OPTION_SANDBOX_INSTALL_COMMANDS);
+commandSandboxCreate.option('--run-command <command>', texts_1.OPTION_SANDBOX_RUN_COMMAND);
+commandSandboxCreate.action(async (options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = new client_1.default(baseUrl, token);
+    // Validate resources if provided
+    if (options.resources && !VALID_RESOURCES.includes(options.resources)) {
+        output_1.default.exitError((0, texts_1.ERR_SANDBOX_INVALID_RESOURCES)(options.resources));
+    }
+    const defaultName = (0, human_id_1.default)({ separator: '-', capitalize: false });
+    const body = {
+        name: options.name || defaultName,
+        identifier: options.identifier || defaultName,
+    };
+    // Use snapshot_id if provided, otherwise use os
+    if (options.snapshot) {
+        // Find snapshot by name across all sandboxes
+        const sandboxesResult = await client.listSandboxes(workspace, project);
+        const sandboxes = sandboxesResult.sandboxes || [];
+        let foundSnapshotId = null;
+        for (const sandbox of sandboxes) {
+            const snapshotsResult = await client.listSandboxSnapshots(workspace, sandbox.id);
+            const snapshots = snapshotsResult.snapshots || [];
+            const foundSnapshot = snapshots.find((s) => s.name === options.snapshot);
+            if (foundSnapshot) {
+                foundSnapshotId = foundSnapshot.id;
+                break;
+            }
+        }
+        if (!foundSnapshotId) {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_SNAPSHOT_NOT_FOUND);
+        }
+        body.snapshot_id = foundSnapshotId;
+    }
+    else {
+        body.os = options.os || 'ubuntu:24.04';
+    }
+    if (options.resources) {
+        body.resources = options.resources;
+    }
+    if (options.installCommands) {
+        body.install_commands = options.installCommands.join('\n');
+    }
+    if (options.runCommand) {
+        body.run_command = options.runCommand;
+    }
+    output_1.default.normal(`Creating sandbox: ${body.name}`);
+    const result = await client.createSandbox(workspace, project, body);
+    const sandboxId = result.id;
+    // If already ready, exit immediately
+    if (result.setup_status === 'SUCCESS' || result.setup_status === 'DONE') {
+        output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_CREATED)(result.name, `${result.html_url}/terminal`));
+    }
+    // Wait for sandbox to be ready
+    output_1.default.normal(texts_1.TXT_SANDBOX_WAITING);
+    // Poll until setup_status is SUCCESS or FAILED (max 5 minutes)
+    const maxWaitMs = 5 * 60 * 1000;
+    const startTime = Date.now();
+    while (true) {
+        const sandbox = await client.getSandbox(workspace, sandboxId);
+        if (sandbox.setup_status === 'SUCCESS' || sandbox.setup_status === 'DONE') {
+            output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_CREATED)(sandbox.name, `${sandbox.html_url}/terminal`));
+        }
+        if (sandbox.setup_status === 'FAILED') {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_SETUP_FAILED);
+        }
+        if (Date.now() - startTime > maxWaitMs) {
+            output_1.default.exitError('Timeout waiting for sandbox setup');
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+});
+exports.default = commandSandboxCreate;

package/distTs/src/command/sandbox/destroy.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 utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+const output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+const client_1 = __importDefault(require("../../api/client"));
+const commandSandboxDestroy = (0, utils_1.newCommand)('destroy', texts_1.DESC_COMMAND_SANDBOX_DESTROY);
+commandSandboxDestroy.alias('rm');
+commandSandboxDestroy.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxDestroy.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxDestroy.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxDestroy.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxDestroy.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxDestroy.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxDestroy.action(async (identifier, options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = new client_1.default(baseUrl, token);
+    // First list sandboxes to find by identifier
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    await client.deleteSandbox(workspace, found.id);
+    output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_DESTROYED)(identifier));
+});
+exports.default = commandSandboxDestroy;

package/distTs/src/command/sandbox/endpoint/add.js

@@ -0,0 +1,91 @@
+"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 output_1 = __importDefault(require("../../../output"));
+const input_1 = __importDefault(require("../../../input"));
+const client_1 = __importDefault(require("../../../api/client"));
+const commandSandboxEndpointAdd = (0, utils_1.newCommand)('add', texts_1.DESC_COMMAND_SANDBOX_ENDPOINT_ADD);
+commandSandboxEndpointAdd.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxEndpointAdd.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxEndpointAdd.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxEndpointAdd.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxEndpointAdd.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxEndpointAdd.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxEndpointAdd.requiredOption('-n, --name <name>', texts_1.OPTION_SANDBOX_ENDPOINT_NAME);
+commandSandboxEndpointAdd.requiredOption('--port <port>', texts_1.OPTION_SANDBOX_ENDPOINT_PORT);
+commandSandboxEndpointAdd.option('-t, --type <type>', texts_1.OPTION_SANDBOX_ENDPOINT_TYPE, 'HTTP');
+commandSandboxEndpointAdd.option('--ep-region <region>', texts_1.OPTION_SANDBOX_ENDPOINT_REGION);
+commandSandboxEndpointAdd.option('--whitelist <cidrs...>', texts_1.OPTION_SANDBOX_ENDPOINT_WHITELIST);
+commandSandboxEndpointAdd.option('--auth <type>', texts_1.OPTION_SANDBOX_ENDPOINT_AUTH);
+commandSandboxEndpointAdd.option('--username <username>', texts_1.OPTION_SANDBOX_ENDPOINT_USERNAME);
+commandSandboxEndpointAdd.option('--password <password>', texts_1.OPTION_SANDBOX_ENDPOINT_PASSWORD);
+commandSandboxEndpointAdd.action(async (identifier, options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = new client_1.default(baseUrl, token);
+    // Find sandbox by identifier
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    // Get current sandbox to get existing endpoints
+    const sandbox = await client.getSandbox(workspace, found.id);
+    const endpoints = sandbox.endpoints || [];
+    // Check if endpoint with this name already exists
+    const existing = endpoints.find((ep) => ep.name === options.name);
+    if (existing) {
+        output_1.default.exitError((0, texts_1.ERR_SANDBOX_ENDPOINT_EXISTS)(options.name));
+    }
+    // Create new endpoint
+    const newEndpoint = {
+        name: options.name,
+        endpoint: options.port,
+        type: options.type.toUpperCase(),
+    };
+    // Add optional fields only if provided
+    if (options.epRegion) {
+        newEndpoint.region = options.epRegion.toUpperCase();
+    }
+    if (options.whitelist) {
+        newEndpoint.whitelist = options.whitelist;
+    }
+    // Add HTTP-specific options (auth)
+    if (options.auth || options.username || options.password) {
+        newEndpoint.http = newEndpoint.http || {};
+        // Auto-set BASIC auth if username/password provided
+        if (options.username || options.password) {
+            newEndpoint.http.auth_type = 'BASIC';
+            if (options.username) {
+                newEndpoint.http.login = options.username;
+            }
+            if (options.password) {
+                newEndpoint.http.password = options.password;
+            }
+        }
+        else if (options.auth) {
+            newEndpoint.http.auth_type = options.auth.toUpperCase();
+        }
+    }
+    // Add the new endpoint to the list
+    const updatedEndpoints = [...endpoints, newEndpoint];
+    // Update sandbox with new endpoints list
+    const updatedSandbox = await client.updateSandbox(workspace, found.id, { endpoints: updatedEndpoints });
+    // Find the added endpoint to get its URL
+    const addedEndpoint = (updatedSandbox.endpoints || []).find((ep) => ep.name === options.name);
+    const url = addedEndpoint?.url;
+    if (url) {
+        output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_ENDPOINT_ADDED)(options.name, url));
+    }
+    else {
+        output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_ENDPOINT_ADDED)(options.name));
+    }
+});
+exports.default = commandSandboxEndpointAdd;

package/distTs/src/command/sandbox/endpoint/delete.js

@@ -0,0 +1,46 @@
+"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 output_1 = __importDefault(require("../../../output"));
+const input_1 = __importDefault(require("../../../input"));
+const client_1 = __importDefault(require("../../../api/client"));
+const commandSandboxEndpointDelete = (0, utils_1.newCommand)('delete', texts_1.DESC_COMMAND_SANDBOX_ENDPOINT_DELETE);
+commandSandboxEndpointDelete.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxEndpointDelete.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxEndpointDelete.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxEndpointDelete.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxEndpointDelete.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxEndpointDelete.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxEndpointDelete.argument('<endpoint-name>', texts_1.OPTION_SANDBOX_ENDPOINT_NAME_ARG);
+commandSandboxEndpointDelete.action(async (identifier, endpointName, options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = new client_1.default(baseUrl, token);
+    // Find sandbox by identifier
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    // Get current sandbox to get existing endpoints
+    const sandbox = await client.getSandbox(workspace, found.id);
+    const endpoints = sandbox.endpoints || [];
+    // Find endpoint by name
+    const endpointIndex = endpoints.findIndex((ep) => ep.name === endpointName);
+    if (endpointIndex === -1) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_ENDPOINT_NOT_FOUND);
+    }
+    // Remove the endpoint from the list
+    const updatedEndpoints = endpoints.filter((ep) => ep.name !== endpointName);
+    // Update sandbox with new endpoints list
+    await client.updateSandbox(workspace, found.id, { endpoints: updatedEndpoints });
+    output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_ENDPOINT_DELETED)(endpointName));
+});
+exports.default = commandSandboxEndpointDelete;

package/distTs/src/command/sandbox/endpoint/get.js

@@ -0,0 +1,58 @@
+"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 output_1 = __importDefault(require("../../../output"));
+const input_1 = __importDefault(require("../../../input"));
+const client_1 = __importDefault(require("../../../api/client"));
+const commandSandboxEndpointGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_SANDBOX_ENDPOINT_GET);
+commandSandboxEndpointGet.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxEndpointGet.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxEndpointGet.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxEndpointGet.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxEndpointGet.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxEndpointGet.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxEndpointGet.argument('<endpoint-name>', texts_1.OPTION_SANDBOX_ENDPOINT_NAME_ARG);
+commandSandboxEndpointGet.action(async (identifier, endpointName, options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = new client_1.default(baseUrl, token);
+    // Find sandbox by identifier
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    // Get sandbox to find endpoint
+    const sandbox = await client.getSandbox(workspace, found.id);
+    const endpoints = sandbox.endpoints || [];
+    const endpoint = endpoints.find((ep) => ep.name === endpointName);
+    if (!endpoint) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_ENDPOINT_NOT_FOUND);
+    }
+    const url = endpoint.url || '-';
+    const whitelist = endpoint.whitelist?.join(', ') || '-';
+    const authType = endpoint.http?.auth_type || '-';
+    const authLogin = endpoint.http?.login || '-';
+    const data = [
+        ['Property', 'Value'],
+        ['Name', endpoint.name || '-'],
+        ['Port', endpoint.endpoint || '-'],
+        ['Type', endpoint.type || '-'],
+        ['Region', endpoint.region || '-'],
+        ['URL', url],
+        ['Whitelist', whitelist],
+        ['Timeout', endpoint.timeout?.toString() || '-'],
+        ['Auth Type', authType],
+        ['Auth Login', authLogin],
+    ];
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxEndpointGet;

package/distTs/src/command/sandbox/endpoint/list.js

@@ -0,0 +1,51 @@
+"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 output_1 = __importDefault(require("../../../output"));
+const input_1 = __importDefault(require("../../../input"));
+const client_1 = __importDefault(require("../../../api/client"));
+const commandSandboxEndpointList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_SANDBOX_ENDPOINT_LIST);
+commandSandboxEndpointList.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxEndpointList.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxEndpointList.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxEndpointList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxEndpointList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxEndpointList.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxEndpointList.action(async (identifier, options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = new client_1.default(baseUrl, token);
+    // Find sandbox by identifier
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    const sandbox = await client.getSandbox(workspace, found.id);
+    const endpoints = sandbox.endpoints || [];
+    if (endpoints.length === 0) {
+        output_1.default.normal('No endpoints found');
+        output_1.default.exitNormal();
+    }
+    const data = [['Name', 'Port', 'Type', 'Region', 'URL']];
+    for (const ep of endpoints) {
+        const url = ep.url || '-';
+        data.push([
+            ep.name || '-',
+            ep.endpoint || '-',
+            ep.type || '-',
+            ep.region || '-',
+            url,
+        ]);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxEndpointList;

package/distTs/src/command/sandbox/endpoint/update.js

@@ -0,0 +1,85 @@
+"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 output_1 = __importDefault(require("../../../output"));
+const input_1 = __importDefault(require("../../../input"));
+const client_1 = __importDefault(require("../../../api/client"));
+const commandSandboxEndpointUpdate = (0, utils_1.newCommand)('update', texts_1.DESC_COMMAND_SANDBOX_ENDPOINT_UPDATE);
+commandSandboxEndpointUpdate.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxEndpointUpdate.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxEndpointUpdate.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxEndpointUpdate.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxEndpointUpdate.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxEndpointUpdate.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxEndpointUpdate.argument('<endpoint-name>', texts_1.OPTION_SANDBOX_ENDPOINT_NAME_ARG);
+commandSandboxEndpointUpdate.option('--port <port>', texts_1.OPTION_SANDBOX_ENDPOINT_PORT);
+commandSandboxEndpointUpdate.option('-t, --type <type>', texts_1.OPTION_SANDBOX_ENDPOINT_TYPE);
+commandSandboxEndpointUpdate.option('--ep-region <region>', texts_1.OPTION_SANDBOX_ENDPOINT_REGION);
+commandSandboxEndpointUpdate.option('--whitelist <cidrs...>', texts_1.OPTION_SANDBOX_ENDPOINT_WHITELIST);
+commandSandboxEndpointUpdate.option('--auth <type>', texts_1.OPTION_SANDBOX_ENDPOINT_AUTH);
+commandSandboxEndpointUpdate.option('--username <username>', texts_1.OPTION_SANDBOX_ENDPOINT_USERNAME);
+commandSandboxEndpointUpdate.option('--password <password>', texts_1.OPTION_SANDBOX_ENDPOINT_PASSWORD);
+commandSandboxEndpointUpdate.action(async (identifier, endpointName, options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = new client_1.default(baseUrl, token);
+    // Find sandbox by identifier
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    // Get current sandbox to get existing endpoints
+    const sandbox = await client.getSandbox(workspace, found.id);
+    const endpoints = sandbox.endpoints || [];
+    // Find endpoint by name
+    const endpointIndex = endpoints.findIndex((ep) => ep.name === endpointName);
+    if (endpointIndex === -1) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_ENDPOINT_NOT_FOUND);
+    }
+    // Update endpoint with provided values
+    const endpoint = { ...endpoints[endpointIndex] };
+    if (options.port) {
+        endpoint.endpoint = options.port;
+    }
+    if (options.type) {
+        endpoint.type = options.type.toUpperCase();
+    }
+    if (options.epRegion) {
+        endpoint.region = options.epRegion.toUpperCase();
+    }
+    if (options.whitelist) {
+        endpoint.whitelist = options.whitelist;
+    }
+    // Update HTTP-specific options (auth)
+    if (options.auth || options.username || options.password) {
+        endpoint.http = endpoint.http || {};
+        // Auto-set BASIC auth if username/password provided
+        if (options.username || options.password) {
+            endpoint.http.auth_type = 'BASIC';
+            if (options.username) {
+                endpoint.http.login = options.username;
+            }
+            if (options.password) {
+                endpoint.http.password = options.password;
+            }
+        }
+        else if (options.auth) {
+            endpoint.http.auth_type = options.auth.toUpperCase();
+        }
+    }
+    // Replace endpoint in the list
+    const updatedEndpoints = [...endpoints];
+    updatedEndpoints[endpointIndex] = endpoint;
+    // Update sandbox with new endpoints list
+    await client.updateSandbox(workspace, found.id, { endpoints: updatedEndpoints });
+    output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_ENDPOINT_UPDATED)(endpointName));
+});
+exports.default = commandSandboxEndpointUpdate;

package/distTs/src/command/sandbox/endpoint.js

@@ -0,0 +1,20 @@
+"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 list_1 = __importDefault(require("./endpoint/list"));
+const get_1 = __importDefault(require("./endpoint/get"));
+const add_1 = __importDefault(require("./endpoint/add"));
+const update_1 = __importDefault(require("./endpoint/update"));
+const delete_1 = __importDefault(require("./endpoint/delete"));
+const commandSandboxEndpoint = (0, utils_1.newCommand)('endpoint', texts_1.DESC_COMMAND_SANDBOX_ENDPOINT);
+commandSandboxEndpoint.alias('ep');
+commandSandboxEndpoint.addCommand(list_1.default);
+commandSandboxEndpoint.addCommand(get_1.default);
+commandSandboxEndpoint.addCommand(add_1.default);
+commandSandboxEndpoint.addCommand(update_1.default);
+commandSandboxEndpoint.addCommand(delete_1.default);
+exports.default = commandSandboxEndpoint;