bdy 1.16.11-master → 1.16.11-sbs-2

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;

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

@@ -0,0 +1,127 @@
+"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 VALID_RUNTIMES = ['BASH', 'JAVASCRIPT', 'TYPESCRIPT', 'PYTHON'];
+const commandSandboxExec = (0, utils_1.newCommand)('exec', texts_1.DESC_COMMAND_SANDBOX_EXEC);
+commandSandboxExec.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxExec.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxExec.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxExec.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxExec.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxExec.option('--runtime <runtime>', texts_1.OPTION_SANDBOX_RUNTIME);
+commandSandboxExec.option('-d, --detached', texts_1.OPTION_SANDBOX_DETACHED);
+commandSandboxExec.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxExec.argument('<command>', texts_1.OPTION_SANDBOX_COMMAND);
+commandSandboxExec.action(async (identifier, command, 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 runtime if provided
+    const runtime = options.runtime?.toUpperCase() || 'BASH';
+    if (!VALID_RUNTIMES.includes(runtime)) {
+        output_1.default.exitError((0, texts_1.ERR_SANDBOX_INVALID_RUNTIME)(options.runtime));
+    }
+    // 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);
+    }
+    // Execute command
+    const body = {
+        command,
+    };
+    if (runtime !== 'BASH') {
+        body.runtime = runtime;
+    }
+    const cmdResult = await client.executeSandboxCommand(workspace, found.id, body);
+    const commandId = cmdResult.id;
+    // If detached, return immediately with command ID
+    if (options.detached) {
+        output_1.default.exitSuccess(`Command started in background: ${commandId}`);
+    }
+    // Stream logs in real-time
+    const logsUrl = await client.getSandboxCommandLogsUrl(workspace, found.id, commandId);
+    try {
+        const response = await fetch(logsUrl, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/jsonl',
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (response.ok && response.body) {
+            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');
+                }
+            }
+        }
+    }
+    catch {
+        // Streaming failed, fall back to polling
+    }
+    // Poll for command completion and get exit code
+    while (true) {
+        const cmd = await client.getSandboxCommand(workspace, found.id, commandId);
+        if (cmd.status === 'SUCCESSFUL' || cmd.status === 'FAILED') {
+            const exitCode = cmd.exit_code ?? (cmd.status === 'SUCCESSFUL' ? 0 : 1);
+            // Print summary
+            process.stdout.write('\n');
+            process.stdout.write('---\n');
+            process.stdout.write(`Command ID: ${commandId}\n`);
+            process.stdout.write(`Exit code: ${exitCode}\n`);
+            process.exit(exitCode);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+});
+exports.default = commandSandboxExec;

package/distTs/src/command/sandbox/get.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 commandSandboxGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_SANDBOX_GET);
+commandSandboxGet.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxGet.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxGet.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxGet.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxGet.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxGet.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxGet.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);
+    }
+    // Get full sandbox details
+    const sandbox = await client.getSandbox(workspace, found.id);
+    const data = [
+        ['Property', 'Value'],
+        ['ID', sandbox.id || '-'],
+        ['Identifier', sandbox.identifier || '-'],
+        ['Name', sandbox.name || '-'],
+        ['Status', sandbox.status || '-'],
+        ['Setup Status', sandbox.setup_status || '-'],
+        ['App Status', sandbox.app_status || '-'],
+        ['OS', sandbox.os || '-'],
+        ['Resources', sandbox.resources || '-'],
+        ['URL', sandbox.html_url || '-'],
+    ];
+    if (sandbox.endpoints && sandbox.endpoints.length > 0) {
+        data.push(['Endpoints', sandbox.endpoints.map((e) => `${e.name}: ${e.endpoint}`).join('\n')]);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxGet;

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

@@ -0,0 +1,41 @@
+"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 commandSandboxList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_SANDBOX_LIST);
+commandSandboxList.alias('ls');
+commandSandboxList.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxList.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxList.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxList.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);
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    if (sandboxes.length === 0) {
+        output_1.default.exitNormal('No sandboxes found');
+    }
+    const data = [['IDENTIFIER', 'NAME', 'STATUS', 'ID']];
+    for (const sandbox of sandboxes) {
+        data.push([
+            sandbox.identifier || '-',
+            sandbox.name || '-',
+            sandbox.status || '-',
+            sandbox.id || '-',
+        ]);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxList;

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

@@ -0,0 +1,49 @@
+"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 commandSandboxRestart = (0, utils_1.newCommand)('restart', texts_1.DESC_COMMAND_SANDBOX_RESTART);
+commandSandboxRestart.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxRestart.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxRestart.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxRestart.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxRestart.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxRestart.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxRestart.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.restartSandbox(workspace, found.id);
+    // Wait for sandbox to be running
+    const startTime = Date.now();
+    const maxWaitMs = 60000;
+    while (true) {
+        const sandbox = await client.getSandbox(workspace, found.id);
+        if (sandbox.status === 'RUNNING' && (sandbox.setup_status === 'SUCCESS' || sandbox.setup_status === 'DONE')) {
+            output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_RESTARTED)(identifier));
+        }
+        if (sandbox.status === 'FAILED' || sandbox.setup_status === 'FAILED') {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_START_TIMEOUT);
+        }
+        if (Date.now() - startTime > maxWaitMs) {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_START_TIMEOUT);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+});
+exports.default = commandSandboxRestart;

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

@@ -0,0 +1,68 @@
+"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 commandSandboxSnapshotCreate = (0, utils_1.newCommand)('create', texts_1.DESC_COMMAND_SANDBOX_SNAPSHOT_CREATE);
+commandSandboxSnapshotCreate.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxSnapshotCreate.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxSnapshotCreate.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxSnapshotCreate.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxSnapshotCreate.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxSnapshotCreate.option('-n, --name <name>', texts_1.OPTION_SANDBOX_SNAPSHOT_NAME);
+commandSandboxSnapshotCreate.option('-d, --description <description>', texts_1.OPTION_SANDBOX_SNAPSHOT_DESCRIPTION);
+commandSandboxSnapshotCreate.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxSnapshotCreate.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 defaultName = 'snapshot-' + (0, human_id_1.default)({ separator: '-', capitalize: false });
+    const snapshotName = options.name || defaultName;
+    const body = {
+        name: snapshotName,
+    };
+    if (options.description) {
+        body.description = options.description;
+    }
+    output_1.default.normal(`Creating snapshot: ${snapshotName}`);
+    const snapshot = await client.createSandboxSnapshot(workspace, found.id, body);
+    const snapshotId = snapshot.id;
+    // If already ready, exit immediately
+    if (snapshot.status === 'CREATED') {
+        output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_SNAPSHOT_CREATED)(snapshotName));
+    }
+    // Wait for snapshot to be ready
+    output_1.default.normal(texts_1.TXT_SANDBOX_SNAPSHOT_WAITING);
+    // Poll until status is CREATED or FAILED (max 5 minutes)
+    const maxWaitMs = 5 * 60 * 1000;
+    const startTime = Date.now();
+    while (true) {
+        const snap = await client.getSandboxSnapshot(workspace, found.id, snapshotId);
+        if (snap.status === 'CREATED') {
+            output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_SNAPSHOT_CREATED)(snapshotName));
+        }
+        if (snap.status === 'FAILED') {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_SNAPSHOT_FAILED);
+        }
+        if (Date.now() - startTime > maxWaitMs) {
+            output_1.default.exitError('Timeout waiting for snapshot creation');
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+});
+exports.default = commandSandboxSnapshotCreate;

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

@@ -0,0 +1,42 @@
+"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 commandSandboxSnapshotDelete = (0, utils_1.newCommand)('delete', texts_1.DESC_COMMAND_SANDBOX_SNAPSHOT_DELETE);
+commandSandboxSnapshotDelete.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxSnapshotDelete.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxSnapshotDelete.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxSnapshotDelete.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxSnapshotDelete.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxSnapshotDelete.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxSnapshotDelete.argument('<snapshot-name>', texts_1.OPTION_SANDBOX_SNAPSHOT_NAME_ARG);
+commandSandboxSnapshotDelete.action(async (identifier, snapshotName, 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);
+    }
+    // Find snapshot by name
+    const snapshotsResult = await client.listSandboxSnapshots(workspace, found.id);
+    const snapshots = snapshotsResult.snapshots || [];
+    const foundSnapshot = snapshots.find((s) => s.name === snapshotName);
+    if (!foundSnapshot) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_SNAPSHOT_NOT_FOUND);
+    }
+    await client.deleteSandboxSnapshot(workspace, found.id, foundSnapshot.id);
+    output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_SNAPSHOT_DELETED)(snapshotName));
+});
+exports.default = commandSandboxSnapshotDelete;