bdy 1.16.11-master → 1.16.11-sbs-1

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;

package/distTs/src/command/sandbox/snapshot/get.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 commandSandboxSnapshotGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_SANDBOX_SNAPSHOT_GET);
+commandSandboxSnapshotGet.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxSnapshotGet.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxSnapshotGet.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxSnapshotGet.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxSnapshotGet.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxSnapshotGet.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxSnapshotGet.argument('<snapshot-name>', texts_1.OPTION_SANDBOX_SNAPSHOT_NAME_ARG);
+commandSandboxSnapshotGet.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);
+    }
+    const snapshot = await client.getSandboxSnapshot(workspace, found.id, foundSnapshot.id);
+    const data = [
+        ['Property', 'Value'],
+        ['Name', snapshot.name || '-'],
+        ['Status', snapshot.status || '-'],
+        ['Description', snapshot.description || '-'],
+        ['Created', snapshot.create_date || '-'],
+        ['URL', snapshot.html_url || '-'],
+    ];
+    if (snapshot.creator) {
+        data.push(['Creator', snapshot.creator.name || snapshot.creator.email || '-']);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxSnapshotGet;

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

@@ -0,0 +1,48 @@
+"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 commandSandboxSnapshotList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_SANDBOX_SNAPSHOT_LIST);
+commandSandboxSnapshotList.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxSnapshotList.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxSnapshotList.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxSnapshotList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxSnapshotList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxSnapshotList.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxSnapshotList.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 snapshotsResult = await client.listSandboxSnapshots(workspace, found.id);
+    const snapshots = snapshotsResult.snapshots || [];
+    if (snapshots.length === 0) {
+        output_1.default.normal('No snapshots found');
+        output_1.default.exitNormal();
+    }
+    const data = [['Name', 'Status', 'Created']];
+    for (const snapshot of snapshots) {
+        data.push([
+            snapshot.name || '-',
+            snapshot.status || '-',
+            snapshot.create_date || '-',
+        ]);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxSnapshotList;

package/distTs/src/command/sandbox/snapshot.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("./snapshot/list"));
+const create_1 = __importDefault(require("./snapshot/create"));
+const get_1 = __importDefault(require("./snapshot/get"));
+const delete_1 = __importDefault(require("./snapshot/delete"));
+const commandSandboxSnapshot = (0, utils_1.newCommand)('snapshot', texts_1.DESC_COMMAND_SANDBOX_SNAPSHOT);
+commandSandboxSnapshot.alias('snap');
+commandSandboxSnapshot.addCommand(list_1.default);
+commandSandboxSnapshot.addCommand(create_1.default);
+commandSandboxSnapshot.addCommand(get_1.default);
+commandSandboxSnapshot.addCommand(delete_1.default);
+exports.default = commandSandboxSnapshot;

package/distTs/src/command/sandbox/start.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 commandSandboxStart = (0, utils_1.newCommand)('start', texts_1.DESC_COMMAND_SANDBOX_START);
+commandSandboxStart.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxStart.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxStart.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxStart.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxStart.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxStart.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxStart.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.startSandbox(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') {
+            output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_STARTED)(identifier));
+        }
+        if (sandbox.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 = commandSandboxStart;

package/distTs/src/command/sandbox/status.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 commandSandboxStatus = (0, utils_1.newCommand)('status', texts_1.DESC_COMMAND_SANDBOX_STATUS);
+commandSandboxStatus.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxStatus.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxStatus.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxStatus.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxStatus.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxStatus.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxStatus.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);
+    output_1.default.exitNormal(sandbox.status || 'unknown');
+});
+exports.default = commandSandboxStatus;

package/distTs/src/command/sandbox/stop.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 commandSandboxStop = (0, utils_1.newCommand)('stop', texts_1.DESC_COMMAND_SANDBOX_STOP);
+commandSandboxStop.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxStop.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxStop.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxStop.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxStop.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxStop.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxStop.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.stopSandbox(workspace, found.id);
+    // Wait for sandbox to be stopped
+    const startTime = Date.now();
+    const maxWaitMs = 60000;
+    while (true) {
+        const sandbox = await client.getSandbox(workspace, found.id);
+        if (sandbox.status === 'STOPPED') {
+            output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_STOPPED)(identifier));
+        }
+        if (sandbox.status === 'FAILED') {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_STOP_TIMEOUT);
+        }
+        if (Date.now() - startTime > maxWaitMs) {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_STOP_TIMEOUT);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+});
+exports.default = commandSandboxStop;