bdy 1.16.11-master → 1.16.11-sbs-2

package/distTs/src/command/sandbox/command/kill.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 commandSandboxCommandKill = (0, utils_1.newCommand)('kill', texts_1.DESC_COMMAND_SANDBOX_COMMAND_KILL);
+commandSandboxCommandKill.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxCommandKill.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxCommandKill.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxCommandKill.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxCommandKill.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxCommandKill.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxCommandKill.argument('<command-id>', texts_1.OPTION_SANDBOX_COMMAND_ID);
+commandSandboxCommandKill.action(async (identifier, commandId, 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);
+    }
+    await client.terminateSandboxCommand(workspace, found.id, commandId);
+    output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_COMMAND_KILLED)(commandId));
+});
+exports.default = commandSandboxCommandKill;

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

@@ -0,0 +1,54 @@
+"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 commandSandboxCommandList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_SANDBOX_COMMAND_LIST);
+commandSandboxCommandList.alias('ls');
+commandSandboxCommandList.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxCommandList.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxCommandList.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxCommandList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxCommandList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxCommandList.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxCommandList.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 commandsResult = await client.listSandboxCommands(workspace, found.id);
+    const commands = commandsResult.commands || [];
+    if (commands.length === 0) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NO_COMMANDS);
+    }
+    // Sort by ID descending (IDs are timestamp-based, so newest first)
+    commands.sort((a, b) => (b.id || '').localeCompare(a.id || ''));
+    const data = [
+        ['ID', 'COMMAND', 'STATUS', 'EXIT CODE', 'RUNTIME'],
+    ];
+    for (const cmd of commands) {
+        data.push([
+            cmd.id || '-',
+            (cmd.command || '-').substring(0, 40) + (cmd.command?.length > 40 ? '...' : ''),
+            cmd.status || '-',
+            cmd.exit_code !== undefined ? String(cmd.exit_code) : '-',
+            cmd.runtime || 'BASH',
+        ]);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxCommandList;

package/distTs/src/command/sandbox/command/logs.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 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 commandSandboxCommandLogs = (0, utils_1.newCommand)('logs', texts_1.DESC_COMMAND_SANDBOX_COMMAND_LOGS);
+commandSandboxCommandLogs.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxCommandLogs.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxCommandLogs.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxCommandLogs.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxCommandLogs.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxCommandLogs.option('-f, --follow', texts_1.OPTION_SANDBOX_COMMAND_FOLLOW);
+commandSandboxCommandLogs.option('-l, --last', texts_1.OPTION_SANDBOX_COMMAND_LAST);
+commandSandboxCommandLogs.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxCommandLogs.argument('[command-id]', texts_1.OPTION_SANDBOX_COMMAND_ID);
+commandSandboxCommandLogs.action(async (identifier, commandId, 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);
+    }
+    // If --last flag is used or no command-id provided, get the most recent command
+    let resolvedCommandId = commandId || '';
+    if (options.last || !commandId) {
+        const commandsResult = await client.listSandboxCommands(workspace, found.id);
+        const commands = commandsResult.commands || [];
+        if (commands.length === 0) {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_NO_COMMANDS);
+        }
+        // Sort by ID descending (IDs are timestamp-based, so newest first)
+        commands.sort((a, b) => (b.id || '').localeCompare(a.id || ''));
+        resolvedCommandId = commands[0].id;
+    }
+    const logsUrl = await client.getSandboxCommandLogsUrl(workspace, found.id, resolvedCommandId);
+    try {
+        const response = await fetch(logsUrl, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/jsonl',
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (response.ok && response.body) {
+            if (options.follow) {
+                // Streaming mode - read and output as data arrives
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (!line.trim())
+                            continue;
+                        try {
+                            const logEntry = JSON.parse(line);
+                            const content = logEntry.data ?? logEntry.message ?? '';
+                            if (content) {
+                                if (logEntry.stream === 'stderr' || logEntry.type === 'STDERR') {
+                                    process.stderr.write(content + '\n');
+                                }
+                                else {
+                                    process.stdout.write(content + '\n');
+                                }
+                            }
+                        }
+                        catch {
+                            process.stdout.write(line + '\n');
+                        }
+                    }
+                }
+                // Process remaining buffer
+                if (buffer.trim()) {
+                    try {
+                        const logEntry = JSON.parse(buffer);
+                        const content = logEntry.data ?? logEntry.message ?? '';
+                        if (content) {
+                            process.stdout.write(content + '\n');
+                        }
+                    }
+                    catch {
+                        process.stdout.write(buffer + '\n');
+                    }
+                }
+            }
+            else {
+                // Default mode - fetch all and output at once
+                const text = await response.text();
+                const lines = text.split('\n');
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const logEntry = JSON.parse(line);
+                        const content = logEntry.data ?? logEntry.message ?? '';
+                        if (content) {
+                            if (logEntry.stream === 'stderr' || logEntry.type === 'STDERR') {
+                                process.stderr.write(content + '\n');
+                            }
+                            else {
+                                process.stdout.write(content + '\n');
+                            }
+                        }
+                    }
+                    catch {
+                        process.stdout.write(line + '\n');
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        output_1.default.exitError(err);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxCommandLogs;

package/distTs/src/command/sandbox/command/status.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_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 commandSandboxCommandStatus = (0, utils_1.newCommand)('status', texts_1.DESC_COMMAND_SANDBOX_COMMAND_STATUS);
+commandSandboxCommandStatus.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxCommandStatus.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxCommandStatus.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxCommandStatus.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxCommandStatus.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxCommandStatus.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxCommandStatus.argument('<command-id>', texts_1.OPTION_SANDBOX_COMMAND_ID);
+commandSandboxCommandStatus.action(async (identifier, commandId, 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 cmd = await client.getSandboxCommand(workspace, found.id, commandId);
+    const data = [
+        ['Property', 'Value'],
+        ['Command ID', cmd.id || '-'],
+        ['Command', cmd.command || '-'],
+        ['Runtime', cmd.runtime || 'BASH'],
+        ['Status', cmd.status || '-'],
+        ['Exit Code', cmd.exit_code !== undefined ? String(cmd.exit_code) : '-'],
+    ];
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxCommandStatus;

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;